@mc-and-his-agents/loom-installer 0.1.1 → 0.1.5

package/README.md

@@ -44,4 +44,5 @@ npx loom-installer add skill loom-init
 
 - PR 只做门禁，不直接发布 npm
 - `main` 是唯一发布真相源
-- publish 成功后再创建同版本 git tag
+- Loom 仓库主 release 与 installer npm 包版本线独立维护
+- publish 成功后再创建 `loom-installer-v<version>` git tag 与同名前缀的 GitHub Release

package/dist/src/codex.js

@@ -41,7 +41,7 @@ function ensureMarketplace(targetRoot, force) {
     }
     const expectedPath = './plugins/loom';
     const existing = marketplace.plugins.find((entry) => typeof entry === 'object' && entry !== null && entry.name === 'loom');
-    if (existing && existing.source?.path && existing.source.path !== expectedPath) {
+    if (existing && existing.source?.path && existing.source.path !== expectedPath && !force) {
         throw new InstallerError(`Codex marketplace already declares loom from a different path: ${existing.source.path}`, `refusing to take over non-Loom marketplace entry for loom: ${existing.source.path}`);
     }
     if (!existing) {

package/dist/test/installer.test.js

@@ -34,6 +34,12 @@ function prepareEnv(base) {
         LOOM_INSTALLER_PYTHON_BIN: resolveTestPython(),
     };
 }
+function writeCodexMarketplace(repoRoot, marketplace) {
+    const marketplacePath = join(repoRoot, '.agents', 'plugins', 'marketplace.json');
+    mkdirSync(join(repoRoot, '.agents', 'plugins'), { recursive: true });
+    writeFileSync(marketplacePath, JSON.stringify(marketplace, null, 2));
+    return marketplacePath;
+}
 function writeFakeClaude(binDir, logPath) {
     const scriptPath = join(binDir, 'claude');
     writeFileSync(scriptPath, `#!/bin/sh\nset -eu\nprintf '%s\\n' "$*" >> ${JSON.stringify(logPath)}\nif [ "$1" = "--version" ]; then\n  echo '2.1.0'\n  exit 0\nfi\nif [ "$1" = "plugin" ] && [ "$2" = "list" ] && [ "$3" = "--json" ]; then\n  echo '[{"name":"loom"}]'\n  exit 0\nfi\nexit 0\n`, { mode: 0o755 });
@@ -96,6 +102,67 @@ test('codex plugin install writes marketplace entry', () => {
     assert.equal(marketplace.plugins[0].name, 'loom');
     assert.equal(marketplace.plugins[0].source.path, './plugins/loom');
 });
+test('codex plugin install fails closed on marketplace conflicts without force', () => {
+    const base = fixtureRoot();
+    const envSource = prepareEnv(base);
+    mkdirSync(envSource.CODEX_HOME, { recursive: true });
+    const repoRoot = join(base, 'repo');
+    mkdirSync(repoRoot, { recursive: true });
+    writeCodexMarketplace(repoRoot, {
+        name: 'custom-marketplace',
+        plugins: [
+            {
+                name: 'loom',
+                source: {
+                    source: 'local',
+                    path: './plugins/not-loom',
+                },
+            },
+        ],
+    });
+    const parsed = {
+        mode: 'plugin',
+        options: {
+            host: 'codex',
+            target: repoRoot,
+            force: false,
+            json: false,
+        },
+    };
+    assert.throws(() => runInstaller(parsed, envSource, packageRoot()), /already declares loom from a different path/);
+});
+test('codex plugin install lets --force take over conflicting marketplace entry', () => {
+    const base = fixtureRoot();
+    const envSource = prepareEnv(base);
+    mkdirSync(envSource.CODEX_HOME, { recursive: true });
+    const repoRoot = join(base, 'repo');
+    mkdirSync(repoRoot, { recursive: true });
+    writeCodexMarketplace(repoRoot, {
+        name: 'custom-marketplace',
+        plugins: [
+            {
+                name: 'loom',
+                source: {
+                    source: 'local',
+                    path: './plugins/not-loom',
+                },
+            },
+        ],
+    });
+    const parsed = {
+        mode: 'plugin',
+        options: {
+            host: 'codex',
+            target: repoRoot,
+            force: true,
+            json: false,
+        },
+    };
+    const result = runInstaller(parsed, envSource, packageRoot());
+    const marketplace = JSON.parse(readFileSync(join(repoRoot, '.agents', 'plugins', 'marketplace.json'), 'utf8'));
+    assert.equal(result.mode, 'plugin');
+    assert.equal(marketplace.plugins[0].source.path, './plugins/loom');
+});
 test('codex skill install writes skills.config entry', () => {
     const base = fixtureRoot();
     const envSource = prepareEnv(base);
@@ -120,6 +187,84 @@ test('codex skill install writes skills.config entry', () => {
     assert.match(config, /loom-review\/SKILL\.md/);
     assert.match(config, /enabled = true/);
 });
+test('codex skill install fails closed on conflicting skills.config entry without force', () => {
+    const base = fixtureRoot();
+    const envSource = prepareEnv(base);
+    mkdirSync(envSource.CODEX_HOME, { recursive: true });
+    const repoRoot = join(base, 'repo');
+    mkdirSync(repoRoot, { recursive: true });
+    writeFileSync(join(envSource.CODEX_HOME, 'config.toml'), [
+        'model = "gpt-5"',
+        '',
+        '[[skills.config]]',
+        'path = "/tmp/other/loom-review/SKILL.md"',
+        'enabled = true',
+        '',
+    ].join('\n'), 'utf8');
+    const parsed = {
+        mode: 'skill',
+        skillId: 'loom-review',
+        options: {
+            host: 'codex',
+            target: repoRoot,
+            force: false,
+            json: false,
+        },
+    };
+    assert.throws(() => runInstaller(parsed, envSource, packageRoot()), /already has loom-review from a different path/);
+});
+test('codex skill install lets --force take over conflicting skills.config entry', () => {
+    const base = fixtureRoot();
+    const envSource = prepareEnv(base);
+    mkdirSync(envSource.CODEX_HOME, { recursive: true });
+    const repoRoot = join(base, 'repo');
+    mkdirSync(repoRoot, { recursive: true });
+    writeFileSync(join(envSource.CODEX_HOME, 'config.toml'), [
+        'model = "gpt-5"',
+        '',
+        '[[skills.config]]',
+        'path = "/tmp/other/loom-review/SKILL.md"',
+        'enabled = true',
+        '',
+    ].join('\n'), 'utf8');
+    const parsed = {
+        mode: 'skill',
+        skillId: 'loom-review',
+        options: {
+            host: 'codex',
+            target: repoRoot,
+            force: true,
+            json: false,
+        },
+    };
+    const result = runInstaller(parsed, envSource, packageRoot());
+    const config = readFileSync(join(envSource.CODEX_HOME, 'config.toml'), 'utf8');
+    assert.equal(result.mode, 'skill');
+    assert.doesNotMatch(config, /\/tmp\/other\/loom-review\/SKILL\.md/);
+    assert.match(config, /loom-review\/SKILL\.md/);
+});
+test('single-skill installs stay scoped to the named skill for codex', () => {
+    const base = fixtureRoot();
+    const envSource = prepareEnv(base);
+    mkdirSync(envSource.CODEX_HOME, { recursive: true });
+    const repoRoot = join(base, 'repo');
+    mkdirSync(repoRoot, { recursive: true });
+    const parsed = {
+        mode: 'skill',
+        skillId: 'loom-init',
+        options: {
+            host: 'codex',
+            target: repoRoot,
+            force: false,
+            json: false,
+        },
+    };
+    const result = runInstaller(parsed, envSource, packageRoot());
+    assert.equal(result.mode, 'skill');
+    assert.match(result.warnings[0] ?? '', /only the named skill, not the full Loom plugin surface/);
+    assert.equal(existsSync(join(repoRoot, 'plugins', 'loom')), false);
+    assert.equal(existsSync(join(repoRoot, '.agents', 'plugins', 'marketplace.json')), false);
+});
 test('claude plugin install assembles marketplace and calls claude CLI', () => {
     const base = fixtureRoot();
     const envSource = prepareEnv(base);
@@ -149,6 +294,28 @@ test('claude plugin install assembles marketplace and calls claude CLI', () => {
     assert.match(log, /plugin marketplace add/);
     assert.match(log, /plugin install loom@loom-local/);
 });
+test('single-skill installs stay scoped to the named skill for claude', () => {
+    const base = fixtureRoot();
+    const envSource = prepareEnv(base);
+    mkdirSync(envSource.CLAUDE_CONFIG_DIR, { recursive: true });
+    const repoRoot = join(base, 'repo');
+    mkdirSync(repoRoot, { recursive: true });
+    const parsed = {
+        mode: 'skill',
+        skillId: 'loom-init',
+        options: {
+            host: 'claude',
+            target: repoRoot,
+            force: false,
+            json: false,
+        },
+    };
+    const result = runInstaller(parsed, envSource, packageRoot());
+    assert.equal(result.mode, 'skill');
+    assert.match(result.warnings[0] ?? '', /does not expose the full Loom plugin surface/);
+    assert.equal(existsSync(join(repoRoot, '.claude', 'skills', 'loom-init', 'SKILL.md')), true);
+    assert.equal(existsSync(join(repoRoot, '.claude', 'marketplaces', 'loom-local')), false);
+});
 test('cli emits structured json on success', () => {
     const base = fixtureRoot();
     const envSource = prepareEnv(base);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mc-and-his-agents/loom-installer",
-  "version": "0.1.1",
+  "version": "0.1.5",
   "description": "Node installer for Loom plugin and single-skill installation surfaces.",
   "type": "module",
   "bin": {

package/payload/manifest.json

@@ -2,9 +2,9 @@
   "schema_version": "loom-installer-payload/v1",
   "loom_version": "0.4.0",
   "source_repository": "https://github.com/MC-and-his-Agents/Loom",
-  "source_commit": "fee19dfa04c0f1055886fd99b223fd1e9760577d",
+  "source_commit": "83a8df67892e8aa04b1ec02faac0acd7da4d1dbd",
   "source_ref": "main",
-  "built_at": "2026-04-22T15:22:47.408Z",
+  "built_at": "2026-04-23T21:00:32+08:00",
   "runtime": {
     "python_minimum": "3.10",
     "python_recommended": "3.11+"
@@ -72,8 +72,8 @@
     },
     {
       "path": "plugin/loom/skills/distribution-and-adapter-contract.md",
-      "bytes": 15031,
-      "sha256": "9e6caf2737cefd538e5c8a853554aea58d8ddb092ec9deacd441ce2e59475f4d"
+      "bytes": 15198,
+      "sha256": "d6c46ae189d24328b62a52771347e7d7dc8ce0fddd4aee5c6ec096cbc19aec54"
     },
     {
       "path": "plugin/loom/skills/install-layout.json",
@@ -327,8 +327,8 @@
     },
     {
       "path": "plugin/loom/skills/README.md",
-      "bytes": 5335,
-      "sha256": "c253cbfc9469d3d66a793803afb85a42d0e97227007bd915d326cd2dee9dd463"
+      "bytes": 6723,
+      "sha256": "716f397324c9fa619d01f00c602929e93dcf68d20a93d2b65cfc4fec8ec52e43"
     },
     {
       "path": "plugin/loom/skills/registry.json",
@@ -522,8 +522,8 @@
     },
     {
       "path": "plugin/loom/skills/shared/scripts/loom_check.py",
-      "bytes": 219260,
-      "sha256": "31b8b57bbcb0b166a6c9fcb1ee6e9a89a54eaa46d5fb709473bfb17a6be585b2"
+      "bytes": 224303,
+      "sha256": "73bdf57078efceb8fac228a44c41fc9d92fc791fbe84699a837b92b491d50299"
     },
     {
       "path": "plugin/loom/skills/shared/scripts/loom_flow.py",

package/payload/plugin/loom/skills/README.md

@@ -33,12 +33,28 @@ Loom 在 `skills` 层固定承认两类对象：
 
 ## 安装入口
 
+Loom 在安装层固定区分两条路径：
+
+- 通过 npm 安装
+  - 面向“在别的项目里使用 Loom”
+  - 使用已发布的 `@mc-and-his-agents/loom-installer`
+  - 这是默认推荐路径
+- 通过 Loom 仓库接入
+  - 面向“让 Agent 直接以 Loom 仓库作为接入来源”
+  - 适合调试、验证、演示，或希望按仓库当前 truth 直接接入的场景
+  - 这不是另一种 npm 命令，而是把 Loom 仓库地址交给 Agent 作为安装来源
+
+如果目标是把 Loom 稳定接到别的项目里，优先走 npm 路径。
+如果目标是验证仓库 truth、调试接入链，或让 Agent 直接按仓库当前状态完成接入，再走仓库路径。
+
+### 通过 npm 安装
+
 Loom 当前正式承认一条 npm / `npx` 安装入口：
 
 - `npx @mc-and-his-agents/loom-installer add plugin`
 - `npx @mc-and-his-agents/loom-installer add skill <skill-id>`
 
-这条入口负责安装、发现与验证，不替代 Python runtime。
+这条 npm 入口负责安装、发现与验证，不替代 Python runtime。
 
 运行前提：
 
@@ -51,6 +67,22 @@ Loom 当前正式承认一条 npm / `npx` 安装入口：
 - `add skill <skill-id>` 只承诺对应标准 skill
 - 安装成功不等于已经执行 Loom runtime，只代表安装 / 发现 / 验证链成立
 
+### 通过 Loom 仓库接入
+
+如果不走已发布 npm 包，也可以把 Loom 仓库直接交给 Agent 作为接入来源：
+
+- Loom 仓库：`https://github.com/MC-and-his-Agents/Loom`
+
+这种方式表达的是“按仓库当前 truth 直接接入 Loom”，而不是“通过 npm 获取 installer”。
+它适合：
+
+- 验证仓库当前 truth 是否可被直接接入
+- 调试、演示或本地试装 Loom
+- 让 Agent 在当前环境里自行判断更适合 plugin 还是 single-skill 接入
+
+这条路径不等于已经安装 `@mc-and-his-agents/loom-installer`。
+如果用户需要稳定、可复用、面向已发布版本的安装面，应回到 npm 路径。
+
 ## 用户会看到哪些入口
 
 Loom 当前稳定提供 1 个 root entry 和 7 个 scenario skills：

package/payload/plugin/loom/skills/distribution-and-adapter-contract.md

@@ -251,7 +251,8 @@ Node installer 的职责边界：
 - 对安装失败维持 fail-closed
 - main 分支是真相源
 - PR 只做门禁，不直接发布 npm
-- publish 成功后再创建同版本 git tag
+- Loom 仓库主 release 与 installer npm 包版本线独立维护
+- publish 成功后再创建 `loom-installer-v<version>` git tag 与同名前缀的 GitHub Release
 
 Node installer 当前打包的正式安装源：
 
@@ -325,7 +326,7 @@ Node installer 的最小 verify 输出必须覆盖：
 
 这类验证属于入口层能力验证，不等同于业务代码测试，也不等同于下游仓库的业务回归测试。
 
-上述最小验证面当前已经形成稳定接口；宿主完整回归矩阵仍停留在候选层，不进入 Loom 默认 core。
+上述最小验证面当前已经形成 Loom 默认承认的稳定 core 接口；宿主完整回归矩阵仍停留在候选层，不进入 Loom 默认 core。
 
 ## 十、与 `automation-frontload` 的边界
 
@@ -334,8 +335,8 @@ Node installer 的最小 verify 输出必须覆盖：
 - `automation-frontload` 的默认 core 检查
   - 关注结构完整性、规则落点、模板存在性、交叉引用、执行支撑入口与明显越界信号
 - `skills` 触发与行为回归验证
-  - 当前属于候选型前置 / 回归验证能力
-  - 可以被 Loom 明确承认，但不应伪装成所有仓库默认必装的 core 检查
+  - 当前已形成 Loom 默认承认的最小入口回归面
+  - 只要求稳定合同与 fail-closed 语义，不要求每个仓库立即具备完整宿主矩阵
 
 换言之，Loom 可以定义入口层最小验证面，但不要求每个仓库都立即具备完整宿主矩阵。
 

package/payload/plugin/loom/skills/shared/scripts/loom_check.py

@@ -359,6 +359,10 @@ def load_json_file(path: Path) -> object:
         return json.load(handle)
 
 
+def load_text_file(path: Path) -> str:
+    return path.read_text(encoding="utf-8")
+
+
 def run_command(
     root: Path,
     args: list[str],
@@ -1200,6 +1204,73 @@ def require_route_payload(
         )
 
 
+def check_root_route_contracts(root: Path) -> list[Failure]:
+    category = "skill-routing-contract"
+    failures: list[Failure] = []
+    readme_path = root / "README.md"
+    skills_readme_path = root / "skills/README.md"
+    route_matrix_path = root / "skills/route-matrix.md"
+    contract_path = root / "skills/loom-init/contract.json"
+
+    try:
+        readme = load_text_file(readme_path)
+        skills_readme = load_text_file(skills_readme_path)
+        route_matrix = load_text_file(route_matrix_path)
+        contract = load_json_file(contract_path)
+    except FileNotFoundError:
+        return failures
+    except json.JSONDecodeError as exc:
+        return [Failure(category, f"`skills/loom-init/contract.json` is invalid JSON: {exc.msg}")]
+
+    if not isinstance(contract, dict):
+        return [Failure(category, "`skills/loom-init/contract.json` must be a JSON object")]
+
+    if "### 完整接入 Loom Plugin" not in readme:
+        failures.append(Failure(category, "`README.md` must keep the Loom plugin installation entry section"))
+    if "### `loom-init`" not in readme:
+        failures.append(Failure(category, "`README.md` must keep the single-skill `loom-init` installation section"))
+    if "它是 Loom 唯一的 root entry" not in skills_readme:
+        failures.append(Failure(category, "`skills/README.md` must keep `loom-init` as the unique root entry"))
+    if "显式 skill 名称调用优先" not in route_matrix:
+        failures.append(Failure(category, "`skills/route-matrix.md` must keep explicit routing as the first priority"))
+    if "若无法稳定判断，回退到 `loom-init`" not in route_matrix:
+        failures.append(Failure(category, "`skills/route-matrix.md` must keep fallback-to-loom-init semantics"))
+    if "`plugin` 与 `single-skill` 两类安装结果边界" not in route_matrix and "fallback_to: \"loom-init\"" not in route_matrix:
+        failures.append(Failure(category, "`skills/route-matrix.md` must keep the stable fallback payload contract"))
+
+    if contract.get("id") != "loom-init":
+        failures.append(Failure(category, "`skills/loom-init/contract.json` id must remain `loom-init`"))
+    if contract.get("root_entry") is not True:
+        failures.append(Failure(category, "`skills/loom-init/contract.json` must keep `root_entry: true`"))
+
+    routing = contract.get("routing")
+    if not isinstance(routing, dict):
+        failures.append(Failure(category, "`skills/loom-init/contract.json` must declare `routing`"))
+    else:
+        if routing.get("reference") != "../route-matrix.md":
+            failures.append(Failure(category, "`skills/loom-init/contract.json` must reference `../route-matrix.md`"))
+        if routing.get("fallback_entry") != "loom-init":
+            failures.append(Failure(category, "`skills/loom-init/contract.json` fallback entry must remain `loom-init`"))
+        if routing.get("priority_order") != [
+            "explicit skill name",
+            "task signal routing",
+            "fallback to loom-init with missing inputs",
+        ]:
+            failures.append(Failure(category, "`skills/loom-init/contract.json` routing priority order drifted from the stable contract"))
+
+    installation_commands = (
+        "npx @mc-and-his-agents/loom-installer add plugin",
+        "npx @mc-and-his-agents/loom-installer add skill <skill-id>",
+    )
+    for command in installation_commands:
+        if command not in skills_readme:
+            failures.append(Failure(category, f"`skills/README.md` must document `{command}`"))
+    if "请按当前 Agent 环境支持的方式，只接入 `loom-init`" not in readme:
+        failures.append(Failure(category, "`README.md` must preserve the `loom-init` single-skill boundary prompt"))
+
+    return failures
+
+
 def check_skill_manifests(root: Path) -> list[Failure]:
     failures: list[Failure] = []
     expected_entries = {
@@ -1484,22 +1555,18 @@ def check_skill_routing(root: Path) -> list[Failure]:
         if error:
             failures.append(Failure("skill-routing", f"explicit route for `{skill_id}` failed: {error}"))
             continue
-        if payload.get("command") != "route":
-            failures.append(Failure("skill-routing", f"explicit route for `{skill_id}` must report `command: route`"))
-        if payload.get("result") != "pass":
-            failures.append(Failure("skill-routing", f"explicit route for `{skill_id}` must pass"))
-        if payload.get("selected_skill") != skill_id:
-            failures.append(Failure("skill-routing", f"explicit route for `{skill_id}` selected `{payload.get('selected_skill')}`"))
-        if payload.get("mode") != "explicit":
-            failures.append(Failure("skill-routing", f"explicit route for `{skill_id}` must report `mode: explicit`"))
+        require_route_payload(
+            failures,
+            category="skill-routing",
+            context=f"explicit route for `{skill_id}`",
+            payload=payload,
+            expected_skill=skill_id,
+            expected_mode="explicit",
+            expected_runtime_scene="repo-local-demo",
+            expected_runtime_carrier="repo-local-wrapper",
+        )
         if not isinstance(payload.get("summary"), str) or not payload.get("summary"):
             failures.append(Failure("skill-routing", f"explicit route for `{skill_id}` must include `summary`"))
-        if not isinstance(payload.get("matched_signals"), list):
-            failures.append(Failure("skill-routing", f"explicit route for `{skill_id}` must include `matched_signals`"))
-        if not isinstance(payload.get("missing_inputs"), list):
-            failures.append(Failure("skill-routing", f"explicit route for `{skill_id}` must include `missing_inputs`"))
-        if payload.get("fallback_to") != "loom-init":
-            failures.append(Failure("skill-routing", f"explicit route for `{skill_id}` must keep `fallback_to: loom-init`"))
         if skill_id in GOVERNANCE_SURFACE_ROUTE_SKILLS and payload.get("result") == "pass":
             require_governance_surface(
                 failures,
@@ -1525,20 +1592,20 @@ def check_skill_routing(root: Path) -> list[Failure]:
         if error:
             failures.append(Failure("skill-routing", f"implicit route for `{skill_id}` failed: {error}"))
             continue
-        if payload.get("command") != "route":
-            failures.append(Failure("skill-routing", f"implicit route for `{skill_id}` must report `command: route`"))
-        if payload.get("result") != "pass":
-            failures.append(Failure("skill-routing", f"implicit route for `{skill_id}` must pass"))
-        if payload.get("selected_skill") != skill_id:
-            failures.append(Failure("skill-routing", f"implicit route for `{skill_id}` selected `{payload.get('selected_skill')}`"))
-        if payload.get("mode") != "implicit":
-            failures.append(Failure("skill-routing", f"implicit route for `{skill_id}` must report `mode: implicit`"))
+        require_route_payload(
+            failures,
+            category="skill-routing",
+            context=f"implicit route for `{skill_id}`",
+            payload=payload,
+            expected_skill=skill_id,
+            expected_mode="implicit",
+            expected_runtime_scene="repo-local-demo",
+            expected_runtime_carrier="repo-local-wrapper",
+        )
         if not isinstance(payload.get("matched_signals"), list) or not payload.get("matched_signals"):
             failures.append(Failure("skill-routing", f"implicit route for `{skill_id}` must include matched signals"))
         if not isinstance(payload.get("summary"), str) or not payload.get("summary"):
             failures.append(Failure("skill-routing", f"implicit route for `{skill_id}` must include `summary`"))
-        if payload.get("fallback_to") != "loom-init":
-            failures.append(Failure("skill-routing", f"implicit route for `{skill_id}` must keep `fallback_to: loom-init`"))
         if skill_id in GOVERNANCE_SURFACE_ROUTE_SKILLS and payload.get("result") == "pass":
             require_governance_surface(
                 failures,
@@ -1554,10 +1621,17 @@ def check_skill_routing(root: Path) -> list[Failure]:
     if error:
         failures.append(Failure("skill-routing", f"fallback route failed: {error}"))
     else:
-        if fallback_payload.get("result") != "fallback":
-            failures.append(Failure("skill-routing", "ambiguous task must return `fallback`"))
-        if fallback_payload.get("selected_skill") != "loom-init":
-            failures.append(Failure("skill-routing", "fallback route must select `loom-init`"))
+        require_route_payload(
+            failures,
+            category="skill-routing",
+            context="fallback route",
+            payload=fallback_payload,
+            expected_skill="loom-init",
+            expected_mode="fallback",
+            expected_runtime_scene="repo-local-demo",
+            expected_runtime_carrier="repo-local-wrapper",
+            allowed_results={"fallback"},
+        )
         if not isinstance(fallback_payload.get("missing_inputs"), list) or not fallback_payload.get("missing_inputs"):
             failures.append(Failure("skill-routing", "fallback route must include `missing_inputs`"))
 
@@ -1576,10 +1650,17 @@ def check_skill_routing(root: Path) -> list[Failure]:
     if error:
         failures.append(Failure("skill-routing", f"ambiguous route failed: {error}"))
     else:
-        if ambiguous_payload.get("result") != "fallback":
-            failures.append(Failure("skill-routing", "multi-match task must return `fallback`"))
-        if ambiguous_payload.get("selected_skill") != "loom-init":
-            failures.append(Failure("skill-routing", "multi-match route must select `loom-init`"))
+        require_route_payload(
+            failures,
+            category="skill-routing",
+            context="multi-match route",
+            payload=ambiguous_payload,
+            expected_skill="loom-init",
+            expected_mode="fallback",
+            expected_runtime_scene="repo-local-demo",
+            expected_runtime_carrier="repo-local-wrapper",
+            allowed_results={"fallback"},
+        )
         if not isinstance(ambiguous_payload.get("matched_signals"), list) or len(ambiguous_payload.get("matched_signals", [])) < 2:
             failures.append(Failure("skill-routing", "multi-match route must expose matched signals"))
 
@@ -1590,10 +1671,62 @@ def check_skill_routing(root: Path) -> list[Failure]:
     if error:
         failures.append(Failure("skill-routing", f"unknown explicit route failed: {error}"))
     else:
-        if unknown_payload.get("result") != "block":
-            failures.append(Failure("skill-routing", "unknown explicit skill must block"))
-        if unknown_payload.get("selected_skill") != "loom-init":
-            failures.append(Failure("skill-routing", "unknown explicit skill must fall back to `loom-init`"))
+        require_route_payload(
+            failures,
+            category="skill-routing",
+            context="unknown explicit route",
+            payload=unknown_payload,
+            expected_skill="loom-init",
+            expected_mode="explicit",
+            expected_runtime_scene="repo-local-demo",
+            expected_runtime_carrier="repo-local-wrapper",
+            allowed_results={"block"},
+        )
+        if "unknown skill" not in str(unknown_payload.get("summary", "")):
+            failures.append(Failure("skill-routing", "unknown explicit skill must expose an `unknown skill` summary"))
+
+    with tempfile.TemporaryDirectory(prefix="loom-check-route-registry-") as tmp:
+        broken_skills = Path(tmp) / "skills"
+        shutil.copytree(root / "skills", broken_skills)
+        registry_path = broken_skills / "registry.json"
+        registry = load_json_file(registry_path)
+        if isinstance(registry, dict):
+            entries = registry.get("entries")
+            if isinstance(entries, list):
+                registry["entries"] = [
+                    entry
+                    for entry in entries
+                    if not (isinstance(entry, dict) and entry.get("id") == "loom-review")
+                ]
+                registry_path.write_text(json.dumps(registry, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+        drift_payload, error = load_command_json(
+            root,
+            [
+                "python3",
+                str(broken_skills / "loom-init" / "scripts" / "loom-init.py"),
+                "route",
+                "--target",
+                str(target),
+                "--task",
+                "请对当前事项做正式 review 并给出审查结论",
+            ],
+        )
+        if error:
+            failures.append(Failure("skill-routing", f"registry drift route failed: {error}"))
+        else:
+            require_route_payload(
+                failures,
+                category="skill-routing",
+                context="registry drift route",
+                payload=drift_payload,
+                expected_skill="loom-init",
+                expected_mode="implicit",
+                expected_runtime_scene="installed-runtime",
+                expected_runtime_carrier="installed-skills-root",
+                allowed_results={"block"},
+            )
+            if "route table resolved to unknown registry skill" not in str(drift_payload.get("summary", "")):
+                failures.append(Failure("skill-routing", "registry drift route must expose an unknown registry skill summary"))
 
     return failures
 
@@ -4677,6 +4810,7 @@ def collect_failures(root: Path) -> list[Failure]:
             AUTOMATION_FRONTLOAD_EXECUTION_SUPPORT,
         )
     )
+    failures.extend(check_root_route_contracts(root))
     failures.extend(check_skill_manifests(root))
     failures.extend(check_skill_routing(root))
     failures.extend(check_demo_assets(root))
@@ -4692,7 +4826,7 @@ def collect_failures(root: Path) -> list[Failure]:
 
 
 def print_report(root: Path, failures: list[Failure]) -> None:
-    categories_checked = 16
+    categories_checked = 17
     if not failures:
         print(f"loom_check: OK ({root})")
         print(f"checked {categories_checked} surfaces")