CNSH Algorithm Runtime｜算法建模接口层工程规格书 v1.1

龍芯北辰 |UID9622

23人浏览 · 2026-05-07 14:41:34

龍芯北辰 |UID9622 · 2026-05-07 14:41:34 发布

🧮

定位： CNSH Algorithm Runtime 的技术蓝图，把 CNSH 语法体系、本地护盾、算法注册、插件 SDK、执行沙盒和 DNA 追溯合成一个统一入口。

上位页面： 🐉 龍魂决策流场总控页 v2.7｜M×CNSH｜功能同步总闸版

母场入口： 龍魂原始流場母圖｜洛書鋼骨×決策執行閉環 v3.1

层级： L2 十年工程层 · L3 日常执行层 · P0 安全闸门前置。

铁律： 算法、AI、插件不得直连底层模块，必须先过 CNSH 统一语法入口、Local Shield、本地策略引擎、执行沙盒与 DNA 回流。

0. 一句话定盘

CNSH Algorithm Runtime = 统一语法入口 + 算法建模接口层 + 本地护盾 + 执行沙盒 + DNA追溯。

目标：

让算法、AI、插件都通过 CNSH 统一语法进入系统，不允许绕过护盾直接调用底层模块。

1. 总体架构位置

层	作用	一句话
CNSH Syntax Layer	统一命令语法	所有输入先翻译成标准 CNSH 指令
Algorithm Modeling Layer	算法注册、建模、调度	算法只在这里登记，不允许散落调用
Local Shield Core	安全控制	所有执行前先审计，红线直接熔断
Policy Engine	规则判断	三色、数字根、数据边界、P0铁律统一判断
Execution Sandbox	隔离运行	代码、插件、AI动作都在可控环境里跑
DNA Trace	追溯回流	每次运行生成 DNA、回执、日志

2. 洛书九宫挂位

宫位	数字	模块	职责
中宫	5	UID9622 主控锚	最终主控、确认码、签章、GPG
正北	9	CNSH Syntax Layer	统一语法入口，所有命令先标准化
正南	1	Execution Sandbox	实际运行环境，最小权限执行
正东	3	Intent Adapter	把自然语言、AI请求、插件请求翻译成 CNSH
正西	7	Algorithm Modeling Layer	算法注册、路由、调度、版本管理
东北	8	Local Shield Core	安全护盾、三色审计、数据边界、熔断
西北	4	Plugin Boundary	插件签名、权限、依赖、沙盒范围
东南	2	DNA Trace Engine	运行哈希、时间戳、结果回流、草日志
西南	6	M:: / CNSH:: Acceptance	机器验收、路由签章、回执验证

3. CNSH 基础语法模型

3.1 标准指令结构

@MODULE:ACTION
PARAMS{key=value, key2=value2}
SECURITY[level]
TRACE[dna]
CONTEXT{source=..., user=..., scope=...}
OUTPUT{format=json|text|file|mesh}

3.2 示例

@SCULPT:RUN
PARAMS{mesh=dragon.obj, brush=inflate, intensity=0.7}
SECURITY[ENCRYPTED]
TRACE[AUTO]
CONTEXT{source=local, user=UID9622, scope=sandbox}
OUTPUT{format=mesh}

3.3 字段定义

字段	含义	必填	说明
MODULE	模块名称	是	例如 SCULPT / GEOMETRY / AI / ROUTE / AUDIT
ACTION	动作	是	例如 RUN / REGISTER / VERIFY / EXPORT
PARAMS	参数	按模块	所有算法入参统一进 PARAMS
SECURITY	安全级别	是	PUBLIC / LOCAL / ENCRYPTED / SENSITIVE / BLOCKED
TRACE	DNA追溯	是	AUTO 或指定 DNA
CONTEXT	上下文	建议必填	来源、用户、范围、文件路径、会话
OUTPUT	输出格式	建议必填	json / text / file / mesh / image

4. Algorithm Modeling Layer

4.1 模块定位

Algorithm Modeling Layer 是算法生态的总接口层。
它不直接代表某一个算法，而是负责：
1. 算法注册
2. 算法分类
3. 算法调用
4. 参数校验
5. 安全交给护盾
6. 结果交给 DNA 回流

4.2 核心组件

4.3 Algorithm Registry

class AlgorithmRegistry:
    def __init__(self):
        self.algorithms = {}

    def register(self, name, func, meta=None):
        self.algorithms[name] = {
            "func": func,
            "meta": meta or {}
        }

    def exists(self, name):
        return name in self.algorithms

    def execute(self, name, **kwargs):
        if name not in self.algorithms:
            raise Exception("Algorithm not registered")
        return self.algorithms[name]["func"](**kwargs)

4.4 算法元信息标准

algorithm:
  name: sculpt.inflate
  version: 1.0
  type: geometry
  security: LOCAL
  input:
    - mesh
    - intensity
  output:
    - mesh
  owner: UID9622
  palace: 7
  layer: L3
  dna: AUTO

5. Algorithm Sculpt Engine

5.1 模块定位

Algorithm Sculpt Engine 是算法建模层下面的一个创新算法模块。
它借鉴 ZBrush 思路，但执行必须走 CNSH + Local Shield。

5.2 模块结构

Algorithm Sculpt Engine
  ├── Mesh Loader
  ├── Brush Algorithms
  ├── Deformation Engine
  ├── Procedural Geometry
  ├── AI Sculpt Assistant
  └── Output Generator

5.3 核心接口

class SculptEngine:
    def apply_brush(self, mesh, brush_type, intensity):
        if brush_type == "inflate":
            return self.inflate(mesh, intensity)

        if brush_type == "smooth":
            return self.smooth(mesh, intensity)

        if brush_type == "carve":
            return self.carve(mesh, intensity)

        raise Exception("Unsupported brush type")

    def inflate(self, mesh, k):
        # 顶点沿法线方向外扩
        for v in mesh.vertices:
            v.position += v.normal * k
        return mesh

    def smooth(self, mesh, k):
        # 简化示例：向邻居平均位置靠近
        for v in mesh.vertices:
            avg = average([n.position for n in v.neighbors])
            v.position = v.position * (1 - k) + avg * k
        return mesh

6. CNSH 与算法引擎连接

6.1 CNSH Parser

class CNSHInterpreter:
    def parse(self, command_text):
        # 输入示例：
        # @SCULPT:RUN
        # PARAMS{mesh=dragon.obj, brush=inflate, intensity=0.7}
        # SECURITY[LOCAL]
        # TRACE[AUTO]

        parsed = {
            "module": None,
            "action": None,
            "params": {},
            "security": "LOCAL",
            "trace": "AUTO",
            "context": {},
            "output": {"format": "json"}
        }

        # 正式实现时使用 tokenizer，不用简单 split 硬切
        return parsed

6.2 安全执行入口

def secure_execute(command_text):
    parsed = interpreter.parse(command_text)

    shield_result = local_shield.process(
        module=parsed["module"],
        action=parsed["action"],
        params=parsed["params"],
        security=parsed["security"],
        context=parsed["context"]
    )

    if shield_result["status"] == "BLOCKED":
        return {
            "status": "blocked",
            "reason": shield_result["reason"],
            "dna": dna_trace.create_blocked_trace(parsed, shield_result)
        }

    result = algorithm_runtime.execute(parsed)

    return dna_trace.wrap_result(parsed, result)

7. Local Shield Core

7.1 执行前硬闸

所有 CNSH 指令执行前，必须经过：

1. 身份锚检查
2. 模块白名单检查
3. 参数边界检查
4. 数据安全级别检查
5. 插件签名检查
6. 沙盒权限检查
7. 三色审计
8. DNA追溯生成

7.2 护盾流程图

7.3 Policy Engine

class PolicyEngine:
    def check(self, parsed):
        checks = [
            self.check_identity(parsed),
            self.check_module_allowlist(parsed),
            self.check_params(parsed),
            self.check_security_level(parsed),
            self.check_data_boundary(parsed),
            self.check_plugin_signature(parsed),
        ]

        if any(c.status == "red" for c in checks):
            return {"status": "BLOCKED", "audit": "🔴", "checks": checks}

        if any(c.status == "yellow" for c in checks):
            return {"status": "HOLD", "audit": "🟡", "checks": checks}

        return {"status": "PASS", "audit": "🟢", "checks": checks}

8. Execution Sandbox

8.1 沙盒职责

Execution Sandbox 不负责判断，只负责隔离执行。
判断归 Local Shield。
调度归 Algorithm Modeling Layer。
留痕归 DNA Trace Engine。

8.2 沙盒限制

sandbox:
  network: disabled_by_default
  file_read: scoped
  file_write: output_only
  secrets: forbidden
  env_access: forbidden
  max_runtime_sec: 30
  max_memory_mb: 512
  plugin_process: isolated
  output_hash: required

8.3 执行结果标准化

{
  "status": "success",
  "module": "SCULPT",
  "action": "RUN",
  "result": {
    "mesh_id": "mesh_8821",
    "output_path": "outputs/dragon_inflate.obj"
  },
  "audit": "🟢",
  "dna": "#龍芯⚡️2026-05-07-ALG-RUNTIME-xxxx"
}

9. DNA 追溯设计

9.1 DNA 生成公式

DNA_HASH = SHA256(
  previous_hash
  + module
  + action
  + canonical_params
  + security_level
  + timestamp
  + output_hash
)

9.2 DNA 返回结构

RESULT {
  "status": "success",
  "module": "SCULPT",
  "action": "RUN",
  "dna": "#龍芯⚡️2026-05-07-ALG-RUNTIME-98211a",
  "previous_hash": "abc123",
  "output_hash": "def456",
  "audit": "🟢",
  "trace": {
    "identity": "UID9622",
    "shield": "PASS",
    "sandbox": "ISOLATED",
    "log": "created"
  }
}

9.3 回流规则

每次算法运行必须产生：
1. M:: 机器验收
2. CNSH:: 路由签章
3. DNA hash
4. 输出 hash
5. 草日志摘要
6. 可复现参数快照

10. 插件开发接口

10.1 插件目录结构

CNSH_PLUGIN/
  plugin.json
  plugin.py
  signature.gpg
  README.md
  tests/
  examples/

10.2 plugin.json

{
  "name": "fractal_sculpt",
  "version": "1.0",
  "entry": "plugin.py",
  "security": "LOCAL",
  "permissions": {
    "network": false,
    "file_read": "scoped",
    "file_write": "output_only",
    "secrets": false
  },
  "cnsh": {
    "module": "SCULPT",
    "actions": ["RUN", "PREVIEW", "EXPORT"]
  },
  "signature": "signature.gpg"
}

10.3 插件接入铁律

1. 无签名插件不加载。
2. 无权限声明插件不加载。
3. 申请 secrets / .env / 私钥访问，直接熔断。
4. 申请网络访问，默认待审。
5. 插件不能绕过 CNSH 指令入口。
6. 插件输出必须生成 output_hash。
7. 插件执行必须进入草日志和 DNA 回流。

11. AI Sculpt Assistant

11.1 定位

AI Sculpt Assistant 不直接操作底层文件。
它只生成 CNSH 指令草案，再交给 Local Shield 审计。

11.2 AI 生成流程

11.3 示例

用户：把龙角做高一点，力度别太大。

AI 生成：
@SCULPT:RUN
PARAMS{mesh=dragon.obj, brush=inflate, region=horn, intensity=0.25}
SECURITY[LOCAL]
TRACE[AUTO]
CONTEXT{source=ai_assistant, user=UID9622, scope=sandbox}
OUTPUT{format=mesh}

12. Procedural Geometry Engine

12.1 定位

Procedural Geometry Engine 负责通过算法生成模型，不依赖人工逐点雕刻。

12.2 典型模块

1. fractal_shape_generator
2. curve_to_mesh
3. particle_field_to_mesh
4. luoshu_grid_geometry
5. sancai_vector_shape
6. dragon_scale_generator

12.3 CNSH 示例

@GEOMETRY:GENERATE
PARAMS{type=dragon_scale, count=9622, pattern=luoshu, symmetry=true}
SECURITY[LOCAL]
TRACE[AUTO]
OUTPUT{format=mesh}

13. Distributed Compute

13.1 定位

Distributed Compute 让多设备参与计算，但默认不是开放网络计算。
必须先经过 Local Shield、设备签名、任务分片、结果哈希回收。

13.2 分布式最小闭环

13.3 硬闸

1. 未登记设备不参与。
2. 无设备签名不参与。
3. 不下发私钥、token、.env。
4. 分片任务不得携带完整敏感数据。
5. 结果必须带 shard_hash。
6. 合并结果必须带 final_hash。

14. 开发者 SDK 设计

14.1 SDK 目标

开发者不直接调用底层模块，只调用 CNSH SDK。

14.2 Python SDK 示例

from cnsh_runtime import CNSHClient

client = CNSHClient(
    endpoint="local://cnsh-runtime",
    identity="UID9622",
)

result = client.run(
    module="SCULPT",
    action="RUN",
    params={
        "mesh": "dragon.obj",
        "brush": "inflate",
        "intensity": 0.7
    },
    security="LOCAL",
    trace="AUTO"
)

print(result["dna"])

14.3 SDK 返回标准

{
  "status": "success|hold|blocked|error",
  "audit": "🟢|🟡|🔴",
  "message": "",
  "result": {},
  "dna": "",
  "m_acceptance": {},
  "cnsh_signature": {}
}

15. 目录建议

cnsh_algorithm_runtime/
  README.md
  cnsh/
    parser.py
    schema.py
    interpreter.py
  shield/
    local_shield.py
    policy_engine.py
    data_boundary.py
    tri_color.py
  algorithms/
    registry.py
    runtime.py
    sculpt/
      engine.py
      mesh_loader.py
      brushes.py
  sandbox/
    executor.py
    permissions.py
    limits.py
  plugins/
    loader.py
    verifier.py
    examples/
  trace/
    dna.py
    hash.py
    receipt.py
  sdk/
    python/
      cnsh_runtime.py
  tests/
    test_parser.py
    test_shield.py
    test_registry.py
    test_sculpt.py

16. 分阶段落地计划

阶段	目标	交付物
Phase 1	定义 CNSH 指令 schema	parser.py / schema.py / 示例指令
Phase 2	接入 Local Shield	local_shield.py / policy_engine.py / 三色审计
Phase 3	建立 Algorithm Registry	registry.py / runtime.py / 算法元信息
Phase 4	实现 Sculpt Engine 最小版	inflate / smooth / carve 三个 brush
Phase 5	接入 DNA Trace	hash.py / dna.py / receipt.py
Phase 6	开放插件 SDK	plugin.json / verifier.py / 示例插件
Phase 7	补 AI Sculpt Assistant	自然语言 → CNSH 指令草案

17. 一票否决

🔴 失败：
- 算法绕过 CNSH 入口直接调用底层模块
- 插件绕过 Local Shield
- AI 直接执行底层动作，不生成 CNSH 指令草案
- 未签名插件加载
- 插件读取 token / .env / 私钥 / GitHub Secrets
- 沙盒越权读写
- 执行没有 M:: 验收
- 执行没有 CNSH:: 签章
- 执行没有 DNA 回流
- 结果无法复现参数快照

18. M:: 机器验收

M:: {
  "id": "M::ARCH-9622-20260507-CNSH-ALGORITHM-RUNTIME-V1",
  "type": "architecture",
  "ts": "2026-05-07T14:06:38+08:00",
  "status": "configured",
  "refs": [
    "https://www.notion.so/2d87125a9c9f802889e2e18002f7cf4f",
    "https://www.notion.so/4649636d4d40411c926508a52a030be4",
    "https://www.notion.so/16422f7261e94a57b1539d8c003ab12c"
  ],
  "payload": {
    "summary": "CNSH语法体系与本地护盾架构已整合为算法建模接口层技术蓝图。",
    "result": {
      "cnsh_syntax_layer": "defined",
      "algorithm_modeling_layer": "defined",
      "local_shield_core": "required_before_execution",
      "execution_sandbox": "defined",
      "dna_trace": "required",
      "plugin_sdk": "defined",
      "ai_sculpt_assistant": "planned",
      "procedural_geometry": "planned",
      "distributed_compute": "planned"
    }
  }
}

19. CNSH:: 路由签章

CNSH:: {
  "dna": "#龍芯⚡️2026-05-07-CNSH-ALGORITHM-RUNTIME-BLUEPRINT-v1.0",
  "gate": "#CONFIRM🌌9622-ONLY-ONCE🧬LK9X-772Z",
  "seal": "#ZHUGEXIN⚡️2025-🇨🇳🐉⚖️♠️🧚🏼‍♀️❤️♾️-DEVICE-BIND-SOUL",
  "gpg": "A2D0092CEE2E5BA87035600924C3704A8CC26D5F",
  "route": "IPA-MAIN-CONTROL|ORIGINAL-FLOWFIELD|CNSH-SYNTAX|ALGORITHM-MODELING|LOCAL-SHIELD|EXECUTION-SANDBOX|DNA-TRACE",
  "audit": "🟢",
  "wuxing": "金",
  "layer": "L2十年|L3日常",
  "policy": "pass"
}

UID9622｜CNSH Algorithm Runtime 建模优化建议 v1.1

A｜当前定盘

你现在这个算法建模页的核心价值是：

CNSH Algorithm Runtime =
统一语法入口

算法注册中心
本地护盾
策略引擎
执行沙盒
插件 SDK
DNA 证据回流

它解决的不是“写一个算法”，而是解决：

所有算法、AI、插件、自动化脚本，不能各跑各的，必须统一经过 CNSH 语义入口、护盾审计、沙盒执行、DNA回流。

这个方向是对的。现在缺的是执行层的硬规格。

当前页面已经有：

总体架构；
洛书九宫挂位；
CNSH 指令格式；
Algorithm Registry；
Sculpt Engine；
Local Shield；
Sandbox；
DNA Trace；
Plugin SDK；
AI Assistant；
Distributed Compute；
M:: / CNSH:: 回执。

但还可以继续优化 12 个关键点。

⸻

B｜最重要的 12 个优化点

1｜补一个“Runtime 生命周期状态机”

现在你的架构是流程图，但缺少状态机。

一个 CNSH 指令进入 Runtime 后，应该有明确生命周期：

RAW_INPUT
→ PARSED
→ CANONICALIZED
→ POLICY_CHECKED
→ HOLD / BLOCKED / APPROVED
→ SANDBOX_PREPARED
→ EXECUTED
→ NORMALIZED
→ HASHED
→ DNA_WRAPPED
→ RECEIPT_EMITTED
→ LEDGER_APPENDED

建议新增一节：

3.4 CNSH Command Lifecycle

stateDiagram-v2
[] --> RAW_INPUT
RAW_INPUT --> PARSED
PARSED --> CANONICALIZED
CANONICALIZED --> POLICY_CHECKED
POLICY_CHECKED --> BLOCKED: 🔴
POLICY_CHECKED --> HOLD: 🟡
POLICY_CHECKED --> APPROVED: 🟢
APPROVED --> SANDBOX_PREPARED
SANDBOX_PREPARED --> EXECUTED
EXECUTED --> NORMALIZED
NORMALIZED --> HASHED
HASHED --> DNA_WRAPPED
DNA_WRAPPED --> LEDGER_APPENDED
LEDGER_APPENDED --> []

对应状态定义：

状态含义是否可执行
RAW_INPUT 原始输入否
PARSED 已解析成 CNSH 字段否
CANONICALIZED 参数已规范化否
POLICY_CHECKED 已完成护盾审计视结果
HOLD 待补证否
BLOCKED 熔断否
APPROVED 可进入沙盒是
EXECUTED 已执行已完成
DNA_WRAPPED 已生成 DNA 回执已完成
LEDGER_APPENDED 已写入证据账本已闭环

为什么重要：
以后你测试系统时，不会只问“跑没跑”，而是能问：

当前卡在哪个生命周期状态？

这就是 Runtime 级别的专业化。

⸻

2｜补 CNSH 指令的 Canonical Schema

你现在的 CNSH 语法很漂亮，但工程上还需要一个标准 JSON 形态。

因为文本命令适合人读，JSON Schema 适合机器执行。

建议补：

{
“cnsh_version”: “1.1”,
“command_id”: “CMD-9622-20260507-8FA31C22”,
“module”: “SCULPT”,
“action”: “RUN”,
“params”: {
“mesh”: “dragon.obj”,
“brush”: “inflate”,
“intensity”: 0.7
},
“security”: {
“level”: “LOCAL”,
“network”: false,
“file_read”: “scoped”,
“file_write”: “output_only”,
“secrets”: false
},
“trace”: {
“mode”: “AUTO”,
“parent_dna”: null,
“previous_hash”: null
},
“context”: {
“source”: “local”,
“user”: “UID9622”,
“scope”: “sandbox”,
“session_id”: “SESSION-9622-LOCAL”
},
“output”: {
“format”: “mesh”,
“path”: “outputs/”
}
}

再补一个字段校验表：

字段类型必填校验
cnsh_version string 是 semver
command_id string 是 CMD-9622-*
module string 是大写枚举
action string 是大写枚举
params object 是按模块 schema
security object 是不得缺失
trace object 是 AUTO / MANUAL
context object 是 user 必须存在
output object 是 format 必须合法

一句话：
CNSH 文本是人话入口，Canonical JSON 是机器入口。两个必须互转。

⸻

3｜补 Algorithm Manifest，算法不能只 register 函数

你现在的 AlgorithmRegistry 只登记函数，这对 MVP 可以，但对 Runtime 不够。

算法应该注册一个 manifest：

algorithm_id: sculpt.inflate
name: Sculpt Inflate Brush
version: 1.0.0
owner: UID9622
module: SCULPT
action: RUN
runtime: python
entrypoint: algorithms/sculpt/brushes.py:inflate
security_level: LOCAL
permissions:
network: false
file_read: scoped
file_write: output_only
secrets: false
input_schema:
mesh:
type: file
required: true
allowed_ext: [“.obj”, “.ply”, “.stl”]
intensity:
type: float
required: true
min: 0.0
max: 1.0
output_schema:
mesh:
type: file
allowed_ext: [“.obj”]
audit:
tri_color_required: true
dna_required: true
output_hash_required: true
palace: 7
layer: L3
dna: AUTO

然后 AlgorithmRegistry 不只是：

而是：

register_manifest(manifest_path)

优化后的结构：

class AlgorithmRegistry:
def init(self):
self.algorithms = {}
def register_manifest(self, manifest: dict):
algorithm_id = manifest[“algorithm_id”]
self.validate_manifest(manifest)
self.algorithms[algorithm_id] = manifest
def validate_manifest(self, manifest: dict):
required = [
“algorithm_id”,
“version”,
“module”,
“action”,
“entrypoint”,
“permissions”,
“input_schema”,
“output_schema”
]
missing = [k for k in required if k not in manifest]
if missing:
raise ValueError(f"Algorithm manifest missing fields: {missing}")
if manifest[“permissions”].get(“secrets”) is True:
raise ValueError(“Algorithm cannot request secrets permission”)
def exists(self, algorithm_id: str) -> bool:
return algorithm_id in self.algorithms

为什么重要：
以后算法多了，不靠脑子记，不靠散文件找，全靠 manifest 管。

⸻

4｜补 Policy Decision Object，护盾结果要机器可读

你现在 PolicyEngine.check() 返回比较简单。建议升级成统一决策对象：

{
“decision_id”: “POLICY-9622-20260507-F01A9D”,
“status”: “PASS”,
“audit”: “🟢”,
“risk_score”: 0.12,
“data_level”: “L1_LOCAL”,
“privacy_mode”: “normal”,
“retention”: “full”,
“checks”: [
{
“name”: “identity_gate”,
“status”: “pass”,
“reason”: “UID9622 identity anchor verified”
},
{
“name”: “module_allowlist”,
“status”: “pass”,
“reason”: “SCULPT module is allowed”
},
{
“name”: “secrets_guard”,
“status”: “pass”,
“reason”: “No secret access requested”
}
],
“one_vote_veto”: [],
“required_user_confirm”: false
}

这样 Local Shield 的输出才能进证据账本。

建议新增：

7.4 Policy Decision Object

并锁定三个状态：

status audit 含义
PASS 🟢 可进入沙盒
HOLD 🟡 不执行，要求补参数/补授权
BLOCKED 🔴 熔断，不执行，只留痕

⸻

5｜补 Data Boundary Matrix

你现在有安全级别，但还缺“数据边界矩阵”。

建议加：

数据等级示例默认动作 retention
L0_PUBLIC 公开代码、公开论文 PASS full
L1_LOCAL 本地普通文件 PASS / HOLD full
L2_PERSONAL 个人信息、设备路径 HOLD summary_only
L3_SECRET_LIKE token、私钥、.env、cookie BLOCKED hash_only
L4_BUSINESS_SECRET 商业秘密、内部未公开策略 BLOCKED / SEALED hash_only
L5_STATE_SECRET 国密、涉密、国家秘密 BLOCKED hash_only

对应硬规则：

L3 以上不得进入普通算法执行。
L3 以上不得保存正文。
L3 以上不得传给插件。
L3 以上不得外发。
L3 以上只允许 hash_only + sealed receipt。

这会把你的“本地护盾”从概念变成真实边界。

⸻

6｜补 Sandbox Capability Token

沙盒不应该只写限制，还要给每次运行发一个临时能力令牌。

不是密钥，是内部权限票据。

{
“capability_id”: “CAP-9622-20260507-91A2C4”,
“command_id”: “CMD-9622-20260507-8FA31C22”,
“allowed_read_paths”: [
“inputs/dragon.obj”
],
“allowed_write_paths”: [
“outputs/”
],
“network”: false,
“secrets”: false,
“expires_in_sec”: 30,
“max_runtime_sec”: 30,
“max_memory_mb”: 512
}

沙盒只认 capability，不认算法自己申请。

一句话规则：

算法不能自己要权限，只能拿 Local Shield 发下来的临时 capability。

这比单纯写“禁止越权”更硬。

⸻

7｜补 Evidence Ledger JSONL

你有 DNA Trace，但还缺 append-only 证据账本结构。

建议加：

{
“event_id”: “EVT-9622-20260507-A19D77”,
“ts”: “2026-05-07T14:06:38+08:00”,
“event_type”: “ALGORITHM_EXECUTION”,
“command_id”: “CMD-9622-20260507-8FA31C22”,
“module”: “SCULPT”,
“action”: “RUN”,
“algorithm_id”: “sculpt.inflate”,
“algorithm_version”: “1.0.0”,
“policy_decision”: {
“status”: “PASS”,
“audit”: “🟢”,
“risk_score”: 0.12
},
“sandbox”: {
“capability_id”: “CAP-9622-20260507-91A2C4”,
“network”: false,
“secrets”: false,
“runtime_sec”: 1.34
},
“input_hash”: “sha256:…”,
“params_hash”: “sha256:…”,
“output_hash”: “sha256:…”,
“previous_event_hash”: “sha256:…”,
“event_hash”: “sha256:…”,
“dna”: “#龍芯⚡️2026-05-07-SCULPT-RUN-A19D77”,
“confirm”: “#CONFIRM🌌9622-ONLY-ONCE🧬LK9X-772Z”,
“gpg”: “A2D0092CEE2E5BA87035600924C3704A8CC26D5F”
}

这就是你系统最硬的一块：
不是说执行过，而是每次执行都有证据事件。

⸻

8｜补 Reproducibility Snapshot

你现在说“可复现参数快照”，但要锁格式。

每次成功执行必须保存：

{
“snapshot_id”: “SNAP-9622-20260507-FE22A1”,
“command_id”: “CMD-9622-20260507-8FA31C22”,
“algorithm_id”: “sculpt.inflate”,
“algorithm_version”: “1.0.0”,
“canonical_command”: {},
“resolved_params”: {},
“input_hashes”: {},
“runtime_env”: {
“python”: “3.x”,
“platform”: “macOS”,
“runtime”: “local”
},
“policy_hash”: “sha256:…”,
“plugin_hash”: null,
“output_hash”: “sha256:…”
}

一句话：

没有 snapshot，就不能说可复现。

⸻

9｜补 Test Matrix，别只写分阶段计划

你已经有 Phase 1-7，但还缺测试矩阵。

建议加：

测试编号测试名输入期望
T01 parser 正常解析合法 CNSH 指令 PARSED
T02 parser 拒绝坏格式缺 MODULE ERROR
T03 shield 拦截私钥 params 含 .env BLOCKED
T04 shield 待审网络 plugin 要 network HOLD
T05 sandbox 禁止越权写写 /Users/… BLOCKED
T06 registry 拒绝无 manifest 无 input_schema ERROR
T07 dna 必须生成成功执行 dna 非空
T08 ledger append-only 连续运行两次 previous_hash 串联
T09 plugin 无签名缺 signature.gpg BLOCKED
T10 AI 不直接执行自然语言请求只生成 CNSH 草案

这会让 Cursor 很清楚该怎么验收。

⸻

10｜补 Claim Audit，避免过度声称

你的文档现在有些地方容易被外部人抓住，比如：

“安全控制”“插件不得直连”“分布式计算”

如果还没代码实现，就要分级：

Claim 当前状态允许表述
CNSH 统一语法入口 protocol design 已定义蓝图
Local Shield prototype planned 计划实现 / 部分规则已定义
Execution Sandbox MVP design 沙盒策略已定义，需实现
Plugin SDK design draft 接口草案
Distributed Compute future work 后续扩展
AI Sculpt Assistant planned AI 仅生成 CNSH 草案
DNA Trace protocol design 追溯结构已定义，需实现 JSONL

建议新增：

Claim Audit

不得写：

已经实现完整安全沙盒
已经开放插件生态
已经完成分布式计算
已经实现真实 ZBrush 替代
可以写：
已定义 Runtime 架构
已定义安全边界
已定义插件接入协议
已定义 DNA 回流格式
下一步进入 MVP 实现

这就是论文/官网/README 里的防炸药包。⚖️

⸻

11｜补 MVP 最小闭环，不要一次做太大

你现在模块很多，真正第一版只要跑通 5 件事：

CNSH 指令
→ Parser
→ Policy Engine
→ Algorithm Registry
→ DNA Ledger

第一版不急着做 Sculpt、插件、AI、分布式。

建议 MVP 文件树收缩成：

cnsh_algorithm_runtime/
README.md
cnsh_runtime.py
cnsh/
parser.py
schema.py
shield/
policy_engine.py
tri_color.py
data_boundary.py
algorithms/
registry.py
examples.py
trace/
dna.py
ledger.py
receipt.py
tests/
test_parser.py
test_policy.py
test_registry.py
test_ledger.py

第一批内置两个示例算法就够：

echo.text
hash.sha256

先证明 Runtime 会跑，再接 sculpt。

⸻

12｜补“反绕过机制”

你这页的铁律是“不允许绕过 CNSH”，但还缺工程检测。

建议新增：

Anti-Bypass Rules:

所有算法只能通过 runtime.execute(command) 调用。
registry 不暴露裸函数给外部模块。
plugin loader 只返回 CNSH-compatible wrapper。
sandbox executor 不接受 raw Python function。
所有执行必须有 command_id。
没有 policy_decision_id 的任务不得进入 sandbox。
没有 ledger_event_id 的结果不得返回 success。

工程版：

def execute(parsed_command):
if not parsed_command.get(“command_id”):
raise RuntimeError(“BYPASS_BLOCKED: missing command_id”)
policy = policy_engine.check(parsed_command)
if not policy.get(“decision_id”):
raise RuntimeError(“BYPASS_BLOCKED: missing policy decision”)
if policy[“status”] != “PASS”:
return blocked_or_hold_result(parsed_command, policy)
result = sandbox.run(parsed_command, policy)
receipt = dna_trace.wrap_result(parsed_command, policy, result)
if not receipt.get(“ledger_event_id”):
raise RuntimeError(“BYPASS_BLOCKED: missing ledger event”)
return receipt

这才是“绕不过”的真正写法。

⸻

C｜建议你把页面升级成 v1.1 的新目录

你现在 19 节比较完整，但可以重排成更工程化的 22 节。

一句话定盘
Runtime 目标与边界
总体架构
洛书九宫挂位
CNSH Command Lifecycle
CNSH Text Syntax
Canonical JSON Schema
Algorithm Modeling Layer
Algorithm Manifest Standard
Local Shield Core
Policy Decision Object
Data Boundary Matrix
Execution Sandbox
Sandbox Capability Token
DNA Trace Engine
Evidence Ledger JSONL
Reproducibility Snapshot
Plugin SDK
AI Assistant Boundary
Procedural Geometry Extension
Distributed Compute Extension
Test Matrix
Claim Audit
MVP File Tree
Cursor Implementation Prompt
M:: / CNSH:: Receipt

这样它就从“蓝图文档”变成“Runtime 规格书”。

⸻

D｜可直接补进页面的 v1.1 升级块

下面这段可以直接贴到你页面里，作为 “20. v1.1 建模优化补丁”。

20. v1.1 建模优化补丁｜Runtime Specification Upgrade

20.1 升级目标

CNSH Algorithm Runtime v1.1 的目标不是继续扩展概念，而是把 v1.0 蓝图升级为可实现、可测试、可验收的 Runtime Specification。
核心升级方向：

增加 CNSH 指令生命周期状态机。
增加 Canonical JSON Schema。
增加 Algorithm Manifest 标准。
增加 Policy Decision Object。
增加 Data Boundary Matrix。
增加 Sandbox Capability Token。
增加 Evidence Ledger JSONL。
增加 Reproducibility Snapshot。
增加 Test Matrix。
增加 Claim Audit。
增加 Anti-Bypass Rules。
收缩第一版 MVP 范围。

20.2 CNSH Command Lifecycle

所有 CNSH 指令必须经过以下生命周期：
RAW_INPUT
→ PARSED
→ CANONICALIZED
→ POLICY_CHECKED
→ HOLD / BLOCKED / APPROVED
→ SANDBOX_PREPARED
→ EXECUTED
→ NORMALIZED
→ HASHED
→ DNA_WRAPPED
→ LEDGER_APPENDED
状态说明：

状态	含义	是否可执行
RAW_INPUT	原始输入	否
PARSED	已解析成 CNSH 字段	否
CANONICALIZED	参数已规范化	否
POLICY_CHECKED	已完成护盾审计	视结果
HOLD	待补证	否
BLOCKED	熔断	否
APPROVED	可进入沙盒	是
EXECUTED	已执行	已完成
DNA_WRAPPED	已生成 DNA 回执	已完成
LEDGER_APPENDED	已写入证据账本	已闭环
硬规则：

未进入 POLICY_CHECKED 的指令不得执行。
未进入 DNA_WRAPPED 的结果不得返回 success。
未进入 LEDGER_APPENDED 的执行不得声称已闭环。

20.3 Canonical JSON Schema

CNSH 文本指令必须被转译为 Canonical JSON 后再执行。

{
  "cnsh_version": "1.1",
  "command_id": "CMD-9622-YYYYMMDD-HASH8",
  "module": "SCULPT",
  "action": "RUN",
  "params": {},
  "security": {
    "level": "LOCAL",
    "network": false,
    "file_read": "scoped",
    "file_write": "output_only",
    "secrets": false
  },
  "trace": {
    "mode": "AUTO",
    "parent_dna": null,
    "previous_hash": null
  },
  "context": {
    "source": "local",
    "user": "UID9622",
    "scope": "sandbox",
    "session_id": "SESSION-9622-LOCAL"
  },
  "output": {
    "format": "json",
    "path": "outputs/"
  }
}

规则：

* CNSH 文本适合人读。
* Canonical JSON 适合机器执行。
* 所有执行以 Canonical JSON 为准。
* JSON 生成后必须进入 Policy Engine。

⸻

20.4 Algorithm Manifest Standard

每个算法必须通过 manifest 注册，不允许只注册裸函数。

algorithm_id: example.hash_sha256
name: SHA256 Hash Example
version: 1.0.0
owner: UID9622
module: HASH
action: RUN
runtime: python
entrypoint: algorithms/examples.py:hash_sha256
security_level: LOCAL
permissions:
  network: false
  file_read: scoped
  file_write: output_only
  secrets: false
input_schema:
  text:
    type: string
    required: true
output_schema:
  digest:
    type: string
audit:
  tri_color_required: true
  dna_required: true
  output_hash_required: true
palace: 7
layer: L3
dna: AUTO

硬规则：

* 无 manifest 不注册。
* manifest 缺 input_schema 不注册。
* manifest 申请 secrets 权限直接拒绝。
* manifest 申请 network 权限默认 HOLD。
* 算法版本必须可追溯。

⸻

20.5 Policy Decision Object

Local Shield 必须输出机器可读决策对象。

{
  "decision_id": "POLICY-9622-YYYYMMDD-HASH8",
  "status": "PASS",
  "audit": "🟢",
  "risk_score": 0.12,
  "data_level": "L1_LOCAL",
  "privacy_mode": "normal",
  "retention": "full",
  "checks": [
    {
      "name": "identity_gate",
      "status": "pass",
      "reason": "UID9622 identity anchor verified"
    },
    {
      "name": "module_allowlist",
      "status": "pass",
      "reason": "Module is allowed"
    },
    {
      "name": "secrets_guard",
      "status": "pass",
      "reason": "No secret access requested"
    }
  ],
  "one_vote_veto": [],
  "required_user_confirm": false
}

状态映射：

status	audit	动作
PASS	🟢	进入沙盒
HOLD	🟡	不执行，等待补证
BLOCKED	🔴	熔断，只留痕

⸻

20.6 Data Boundary Matrix

数据等级	示例	默认动作	retention
L0_PUBLIC	公开代码、公开论文	PASS	full
L1_LOCAL	本地普通文件	PASS / HOLD	full
L2_PERSONAL	个人信息、设备路径	HOLD	summary_only
L3_SECRET_LIKE	token、私钥、.env、cookie	BLOCKED	hash_only
L4_BUSINESS_SECRET	商业秘密、内部未公开策略	BLOCKED / SEALED	hash_only
L5_STATE_SECRET	国密、涉密、国家秘密	BLOCKED	hash_only

硬规则：

* L3 以上不得进入普通算法执行。
* L3 以上不得保存正文。
* L3 以上不得传给插件。
* L3 以上不得外发。
* L3 以上只允许 hash_only + sealed receipt。

⸻

20.7 Sandbox Capability Token

沙盒执行不接受算法自行申请权限，只接受 Local Shield 下发的临时 capability。

{
  "capability_id": "CAP-9622-YYYYMMDD-HASH8",
  "command_id": "CMD-9622-YYYYMMDD-HASH8",
  "allowed_read_paths": [],
  "allowed_write_paths": ["outputs/"],
  "network": false,
  "secrets": false,
  "expires_in_sec": 30,
  "max_runtime_sec": 30,
  "max_memory_mb": 512
}

硬规则：

* 无 capability 不执行。
* capability 过期不执行。
* capability 禁止 network 时不得联网。
* capability 禁止 secrets 时不得读取 env / token / 私钥。
* capability 只对单次 command_id 有效。

⸻

20.8 Evidence Ledger JSONL

每次执行必须写入 append-only evidence ledger。

{
  "event_id": "EVT-9622-YYYYMMDD-HASH8",
  "ts": "2026-05-07T14:06:38+08:00",
  "event_type": "ALGORITHM_EXECUTION",
  "command_id": "CMD-9622-YYYYMMDD-HASH8",
  "module": "SCULPT",
  "action": "RUN",
  "algorithm_id": "sculpt.inflate",
  "algorithm_version": "1.0.0",
  "policy_decision": {
    "status": "PASS",
    "audit": "🟢",
    "risk_score": 0.12
  },
  "sandbox": {
    "capability_id": "CAP-9622-YYYYMMDD-HASH8",
    "network": false,
    "secrets": false,
    "runtime_sec": 1.34
  },
  "input_hash": "sha256:...",
  "params_hash": "sha256:...",
  "output_hash": "sha256:...",
  "previous_event_hash": "sha256:...",
  "event_hash": "sha256:...",
  "dna": "#龍芯⚡️YYYY-MM-DD-ALG-RUNTIME-HASH8",
  "confirm": "#CONFIRM🌌9622-ONLY-ONCE🧬LK9X-772Z",
  "gpg": "A2D0092CEE2E5BA87035600924C3704A8CC26D5F"
}

硬规则：

* audit_log.jsonl 只追加，不覆盖。
* 每条 event_hash 必须绑定 previous_event_hash。
* 没有 ledger event，不得返回 success。
* BLOCKED / HOLD 也必须写入 ledger。

⸻

20.9 Reproducibility Snapshot

每次成功执行必须生成可复现参数快照。

{
  "snapshot_id": "SNAP-9622-YYYYMMDD-HASH8",
  "command_id": "CMD-9622-YYYYMMDD-HASH8",
  "algorithm_id": "sculpt.inflate",
  "algorithm_version": "1.0.0",
  "canonical_command": {},
  "resolved_params": {},
  "input_hashes": {},
  "runtime_env": {
    "python": "3.x",
    "platform": "macOS",
    "runtime": "local"
  },
  "policy_hash": "sha256:...",
  "plugin_hash": null,
  "output_hash": "sha256:..."
}

一句话：

没有 snapshot，就不能说可复现。

⸻

20.10 Anti-Bypass Rules

反绕过规则：

1. 所有算法只能通过 runtime.execute(command) 调用。
2. registry 不暴露裸函数给外部模块。
3. plugin loader 只返回 CNSH-compatible wrapper。
4. sandbox executor 不接受 raw Python function。
5. 所有执行必须有 command_id。
6. 没有 policy_decision_id 的任务不得进入 sandbox。
7. 没有 ledger_event_id 的结果不得返回 success。

⸻

20.11 Test Matrix

测试编号	测试名	输入	期望
T01	parser 正常解析	合法 CNSH 指令	PARSED
T02	parser 拒绝坏格式	缺 MODULE	ERROR
T03	shield 拦截私钥	params 含 .env	BLOCKED
T04	shield 待审网络	plugin 要 network	HOLD
T05	sandbox 禁止越权写	写系统目录	BLOCKED
T06	registry 拒绝无 manifest	无 input_schema	ERROR
T07	dna 必须生成	成功执行	dna 非空
T08	ledger append-only	连续运行两次	previous_hash 串联
T09	plugin 无签名	缺 signature.gpg	BLOCKED
T10	AI 不直接执行	自然语言请求	只生成 CNSH 草案

⸻

20.12 Claim Audit

当前允许表述：

* 已定义 CNSH Algorithm Runtime 架构。
* 已定义 CNSH 指令语法。
* 已定义本地护盾审计路径。
* 已定义算法注册机制。
* 已定义沙盒权限模型。
* 已定义插件接入协议。
* 已定义 DNA 回流格式。
* 下一步进入 MVP 实现。

禁止表述：

* 已实现完整安全沙盒。
* 已开放插件生态。
* 已完成分布式计算。
* 已替代 ZBrush。
* 已实现不可绕过安全系统。
* 已完成全部算法验证。

最终定位：

CNSH Algorithm Runtime v1.1 是技术规格与 MVP 实施蓝图，不是最终生产级安全系统。

---
# E｜Cursor 一屏执行指令
你可以直接给 Cursor 这一段：
```text
请把 CNSH Algorithm Runtime 从 v1.0 蓝图升级为 v1.1 MVP Runtime Specification。
第一阶段只实现最小闭环：
CNSH command text
→ parser
→ canonical JSON
→ policy engine
→ algorithm registry
→ sandbox stub
→ DNA trace
→ evidence ledger JSONL
→ receipt
创建文件树：
cnsh_algorithm_runtime/
  README.md
  cnsh_runtime.py
  cnsh/
    parser.py
    schema.py
  shield/
    policy_engine.py
    tri_color.py
    data_boundary.py
  algorithms/
    registry.py
    examples.py
    manifests/
      echo.text.yaml
      hash.sha256.yaml
  sandbox/
    executor.py
    capability.py
  trace/
    dna.py
    ledger.py
    receipt.py
  tests/
    test_parser.py
    test_policy.py
    test_registry.py
    test_ledger.py
    test_runtime.py
硬要求：
1. 不实现真实危险沙盒，只做 sandbox stub，但必须保留 capability 检查。
2. 所有执行必须先 parse，再 canonicalize，再 policy check。
3. policy 未 PASS 不得执行算法。
4. params 中出现 token / private key / .env / password / secret 直接 BLOCKED。
5. algorithm 必须通过 manifest 注册。
6. registry 不暴露裸函数给外部调用。
7. 每次执行都写 trace/evidence_ledger.jsonl。
8. 每条 ledger 必须有 previous_event_hash 和 event_hash。
9. 成功结果必须包含 dna、m_acceptance、cnsh_signature。
10. HOLD / BLOCKED 也要写 ledger。
11. 不联网，不读 .env，不读取私钥，不外发。
内置两个示例算法：
- echo.text：返回输入文本
- hash.sha256：返回输入文本 sha256
验收：
- python3 -m pytest tests/ 全部通过。
- python3 cnsh_runtime.py examples/hash.cnsh 能输出成功 receipt。
- 输入含 sk- / PRIVATE KEY / .env 时返回 BLOCKED。
- trace/evidence_ledger.jsonl 持续追加。
- README 明确写：当前是 MVP Runtime，不是生产级安全沙盒。

⸻

F｜下一步最短动作

你现在最该做的不是继续往上堆“雕刻、分布式、AI助手”，而是先跑通第一版最小闭环：

输入 CNSH 指令
→ 解析
→ 审计
→ 执行一个简单算法
→ 写 DNA
→ 写 JSONL
→ 返回 M:: / CNSH::

第一版只要能跑：

@HASH:RUN
PARAMS{text=UID9622}
SECURITY[LOCAL]
TRACE[AUTO]
CONTEXT{source=local,user=UID9622,scope=sandbox}
OUTPUT{format=json}

输出：

{
  "status": "success",
  "audit": "🟢",
  "result": {
    "sha256": "..."
  },
  "dna": "#龍芯⚡️2026-05-07-HASH-RUN-XXXX",
  "ledger_event_id": "EVT-9622-...",
  "m_acceptance": {},
  "cnsh_signature": {}
}

这就说明你的 Runtime 活了。
后面 Sculpt、插件、AI、分布式，全都只是往这个入口后面加模块。

⸻

G｜ROOT_CARD｜数学根审计

ROOT_CARD:
  Root: "dr=4"
  Wuxing: "金"
  RootMeaning: "规则 / 边界 / 审计 / Runtime规格化"
  TriColor: "🟢"
  DataLevel: "L1_INTERNAL"
  PrivacyMode: "normal"
  Retention: "full"
  TraceMode: "chain"
  Route:
    - "CNSH-ALGORITHM-RUNTIME"
    - "LOCAL-SHIELD"
    - "ALGORITHM-MODELING"
    - "EXECUTION-SANDBOX"
    - "DNA-TRACE"
  Backend:
    - "python"
    - "jsonl"
    - "yaml"
    - "cursor"
    - "notion"
  Action: "upgrade_to_mvp_spec"
  DNA: "#龍芯⚡️2026-05-07-CNSH-ALGORITHM-RUNTIME-v1.1-SPEC-UPGRADE"
  CONFIRM: "#CONFIRM🌌9622-ONLY-ONCE🧬LK9X-772Z"
  SEAL: "#ZHUGEXIN⚡️2025-🇨🇳🐉⚖️♠️🧚🏼‍♀️❤️♾️-DEVICE-BIND-SOUL"
  GPG: "A2D0092CEE2E5BA87035600924C3704A8CC26D5F"
  Conclusion: "当前蓝图已经成立，下一步重点是从架构说明升级为 Runtime Specification，并先实现 parser→policy→registry→ledger 的最小闭环。"

AtomGit开源社区

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。

更多推荐

鸿蒙 PC：多窗口只是表象，真正变化是状态系统

AtomGit开源社区

linux学习进展 mysql数据库

AtomGit开源社区

HTML CSS 新手大全初学者必看（含有部分 JavaScript）

HTML表单核心总结表单基础结构 <form>标签：定义表单容器，关键属性： action：提交目标URL（必填） method：提交方式（GET/POST） enctype：编码类型（文件上传需设为multipart/form-data）输入控件 <input>通用属性： name：数据键名（必填） value：默认值/提交值 required：必填验证 placeh

AtomGit开源社区

所有评论(0)

查看更多评论

龍芯北辰 |UID9622

@2500_94248780

已为社区贡献29条内容

CNSH Algorithm Runtime｜算法建模接口层工程规格书 v1.1

龍芯北辰 |UID9622

0. 一句话定盘

1. 总体架构位置

2. 洛书九宫挂位

3. CNSH 基础语法模型

3.1 标准指令结构

3.2 示例

3.3 字段定义

4. Algorithm Modeling Layer

4.1 模块定位

4.2 核心组件

4.3 Algorithm Registry

4.4 算法元信息标准

5. Algorithm Sculpt Engine

5.1 模块定位

5.2 模块结构

5.3 核心接口

6. CNSH 与算法引擎连接

6.1 CNSH Parser

6.2 安全执行入口

7. Local Shield Core

7.1 执行前硬闸

7.2 护盾流程图

7.3 Policy Engine

8. Execution Sandbox

8.1 沙盒职责

8.2 沙盒限制

8.3 执行结果标准化

9. DNA 追溯设计

9.1 DNA 生成公式

9.2 DNA 返回结构

9.3 回流规则

10. 插件开发接口

10.1 插件目录结构

10.2 plugin.json

10.3 插件接入铁律

11. AI Sculpt Assistant

11.1 定位

11.2 AI 生成流程

11.3 示例

12. Procedural Geometry Engine

12.1 定位

12.2 典型模块

12.3 CNSH 示例

13. Distributed Compute

13.1 定位

13.2 分布式最小闭环

13.3 硬闸

14. 开发者 SDK 设计

14.1 SDK 目标

14.2 Python SDK 示例

14.3 SDK 返回标准

15. 目录建议

16. 分阶段落地计划

17. 一票否决

18. M:: 机器验收

19. CNSH:: 路由签章

20. v1.1 建模优化补丁｜Runtime Specification Upgrade

20.1 升级目标

20.2 CNSH Command Lifecycle

20.3 Canonical JSON Schema

所有评论(0)

温馨提示：您尚未绑定手机号

龍芯北辰 |UID9622