@siming-org/cli 0.8.1 → 0.8.3

package/dist/index.js

@@ -666,12 +666,12 @@ async function healthcheckCommand(opts) {
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/mcp/server.ts
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { VERSION } from "@siming-org/core";
 
 // src/client/handlers/task.ts
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 import {
   ARTIFACT_TYPES
 } from "@siming-org/core";
@@ -682,6 +682,44 @@ var MIN_AI_CHECK_ITEM_LENGTH = 15;
 var VAGUE_AI_CHECK_BLACKLIST = ["\u5DF2\u5B8C\u6210", "\u901A\u8FC7", "\u5B8C\u6210", "done", "ok", "pass"];
 
 // src/client/checks/git-checks.ts
+async function perRepoCheck(ctx, type, judge) {
+  const results = [];
+  for (const repo of ctx.repos) {
+    results.push({ repo, r: await judge(repo) });
+  }
+  const failed = results.filter((x) => x.r.status === "fail");
+  if (failed.length > 0) {
+    const failLines = failed.slice(0, 4).map((x) => `${x.repo}: ${x.r.detail}`);
+    const rest = results.filter((x) => x.r.status !== "fail").map((x) => `${x.repo}: ${x.r.status === "pass" ? "pass" : "N/A"}`);
+    const suffix = failed.length > 4 ? `\uFF08\u53E6\u6709 ${failed.length - 4} \u4ED3 fail \u89C1\u626B\u63CF\u8DEF\u5F84\u9010\u4ED3\u91CD\u67E5\uFF09` : "";
+    const okPart = rest.length > 0 ? `\uFF1B\u5176\u4F59\u4ED3\uFF1A${rest.join("\u3001")}` : "";
+    return {
+      type,
+      status: "fail",
+      // 尾附扫描详情：fail 时用户需核对 R 完整性（子目录启动漏仓诊断——scanned from 可观测启动位置）
+      detail: `${failed.length}/${results.length} \u4ED3\u672A\u8FC7\u2014\u2014${failLines.join("\uFF1B")}${suffix}${okPart}\u3002\u4FEE\u590D\uFF1A\u9010\u4ED3\u5904\u7406\u540E\u91CD\u8BD5\uFF08\u591A\u4ED3\u987B\u5168\u90E8\u9002\u914D\u76F8\u540C\u5206\u652F\u7BA1\u7406\uFF09
+${ctx.reposScanDetail}`
+    };
+  }
+  const allNa = results.every((x) => x.r.status === "not_applicable");
+  if (allNa) {
+    return {
+      type,
+      status: "not_applicable",
+      detail: `\u5168\u90E8 ${results.length} \u4ED3\u514D\u68C0\uFF1A${results.map((x) => `${x.repo}\uFF08${x.r.detail}\uFF09`).join("\uFF1B")}
+${ctx.reposScanDetail}`
+    };
+  }
+  const passLines = results.filter((x) => x.r.status === "pass").map((x) => `${x.repo}: ${x.r.detail}`);
+  const naPart = results.filter((x) => x.r.status === "not_applicable").map((x) => `${x.repo}\uFF08${x.r.detail}\uFF09`);
+  return {
+    type,
+    status: "pass",
+    // 尾附扫描详情：pass 同样需可观测 R 完整性（子目录启动扫到部分仓的静默假 pass 诊断）
+    detail: `\u5168\u90E8 ${results.length} \u4ED3\u901A\u8FC7\u2014\u2014${passLines.join("\uFF1B")}${naPart.length > 0 ? `\uFF1B\u514D\u68C0\u4ED3\uFF1A${naPart.join("\uFF1B")}` : ""}
+${ctx.reposScanDetail}`
+  };
+}
 function naIfRepoUnavailable(ctx) {
   if (ctx.vcsLoadError !== void 0) {
     return { type: "", status: "fail", detail: `\u9879\u76EE vcs \u914D\u7F6E\u8BFB\u53D6\u5931\u8D25\uFF1A${ctx.vcsLoadError}\u2014\u2014\u65E0\u6CD5\u786E\u8BA4\u95E8\u7981\u542F\u7528\u72B6\u6001\uFF08\u62D2\u9759\u9ED8\u964D\u7EA7\uFF09\u3002\u4FEE\u590D\uFF1A\u786E\u8BA4 server \u53EF\u8FBE\u4E0E\u9879\u76EE\u914D\u7F6E\u540E\u91CD\u8DD1 task check` };
@@ -689,8 +727,8 @@ function naIfRepoUnavailable(ctx) {
   if (ctx.vcs.enabled === false) {
     return na("\u9879\u76EE vcs.enabled=false\uFF08\u58F0\u660E\u65E0\u5206\u652F\u6A21\u578B\uFF09\uFF0Cgit \u7C7B\u68C0\u67E5\u8C41\u514D");
   }
-  if (ctx.repoPath === null) {
-    return na(`\u4ED3\u5E93\u4E0D\u53EF\u7528\uFF1A${ctx.repoProbeDetail}`);
+  if (ctx.repos.length === 0) {
+    return na(`\u5DE5\u4F5C\u76EE\u5F55\u65E0 git \u4ED3\uFF08${ctx.reposScanDetail}\uFF09`);
   }
   return null;
 }
@@ -700,30 +738,32 @@ function na(reason) {
 function fail2(ctx, type, rootCause, fix) {
   return { type, status: "fail", detail: `${rootCause}\u3002\u4FEE\u590D\uFF1A${fix}\uFF08\u5F53\u524D nodeId=${ctx.nodeId}\uFF09` };
 }
-async function currentBranch(ctx) {
-  const r = await ctx.runGit(["rev-parse", "--abbrev-ref", "HEAD"], ctx.repoPath);
+async function currentBranch(ctx, repo) {
+  const r = await ctx.runGit(["rev-parse", "--abbrev-ref", "HEAD"], repo);
   return r.ok ? r.stdout.trim() : null;
 }
 async function checkBranchExists(ctx) {
   const type = "git-branch-exists";
   const guard = naIfRepoUnavailable(ctx);
   if (guard) return { ...guard, type };
-  const branch = await currentBranch(ctx);
-  if (branch === null) {
-    return fail2(ctx, type, "\u65E0\u6CD5\u8BFB\u53D6\u5F53\u524D\u5206\u652F\uFF08git rev-parse --abbrev-ref HEAD \u5931\u8D25\uFF09", "\u786E\u8BA4\u5728\u4EFB\u52A1\u5206\u652F\u4E0A\u6267\u884C\uFF0C\u6216\u68C0\u67E5\u4ED3\u5E93\u72B6\u6001");
-  }
-  if (branch === "HEAD") {
-    return fail2(ctx, type, "\u5904\u4E8E detached HEAD \u72B6\u6001\uFF08\u672A\u68C0\u51FA\u4EFB\u4F55\u5206\u652F\uFF09", `git checkout \u4EFB\u52A1\u5206\u652F\uFF08\u987B\u5339\u914D ${ctx.branchPattern} \u524D\u7F00\uFF09`);
-  }
-  if (!branch.startsWith(ctx.branchPattern)) {
-    return fail2(ctx, type, `\u5F53\u524D\u5206\u652F\u300C${branch}\u300D\u4E0D\u5339\u914D\u4EFB\u52A1\u5206\u652F\u89C4\u5219\u300C${ctx.branchPattern} \u524D\u7F00\u300D`, `\u5207\u5230\u4EFB\u52A1\u5206\u652F\uFF08feature/Txxxxxxxx...\uFF09\u540E\u518D\u63A8\u8FDB`);
-  }
-  return { type, status: "pass", detail: `\u5F53\u524D\u5206\u652F ${branch}` };
+  return perRepoCheck(ctx, type, async (repo) => {
+    const branch = await currentBranch(ctx, repo);
+    if (branch === null) {
+      return { status: "fail", detail: "\u65E0\u6CD5\u8BFB\u53D6\u5F53\u524D\u5206\u652F\uFF08git rev-parse --abbrev-ref HEAD \u5931\u8D25\u2014\u2014\u7591\u4F3C\u635F\u574F\u4ED3\uFF09" };
+    }
+    if (branch === "HEAD") {
+      return { status: "fail", detail: `\u5904\u4E8E detached HEAD \u72B6\u6001\uFF08\u672A\u68C0\u51FA\u4EFB\u4F55\u5206\u652F\uFF09\u2014\u2014git checkout \u4EFB\u52A1\u5206\u652F\uFF08\u987B\u5339\u914D ${ctx.branchPattern} \u524D\u7F00\uFF09` };
+    }
+    if (!branch.startsWith(ctx.branchPattern)) {
+      return { status: "fail", detail: `\u5F53\u524D\u5206\u652F\u300C${branch}\u300D\u4E0D\u5339\u914D\u4EFB\u52A1\u5206\u652F\u89C4\u5219\u300C${ctx.branchPattern} \u524D\u7F00\u300D\u2014\u2014\u5207\u5230\u4EFB\u52A1\u5206\u652F\u540E\u518D\u63A8\u8FDB` };
+    }
+    return { status: "pass", detail: `\u5F53\u524D\u5206\u652F ${branch}` };
+  });
 }
-async function baseMergedIntoHead(ctx, base) {
-  const f = await ctx.runGit(["fetch", "origin", base], ctx.repoPath);
+async function baseMergedIntoHead(ctx, base, repo) {
+  const f = await ctx.runGit(["fetch", "origin", base], repo);
   if (!f.ok) return null;
-  const r = await ctx.runGit(["merge-base", "--is-ancestor", `origin/${base}`, "HEAD"], ctx.repoPath);
+  const r = await ctx.runGit(["merge-base", "--is-ancestor", `origin/${base}`, "HEAD"], repo);
   return r.ok;
 }
 async function checkBaseMerged(ctx) {
@@ -737,14 +777,17 @@ async function checkBaseMerged(ctx) {
   if (ctx.baseBranch === null) {
     return fail2(ctx, type, "\u57FA\u7840\u5206\u652F\u672A\u77E5\uFF08ALIGN \u8BB0\u5F55\u672A\u5199 baseBranch \u4E14\u9879\u76EE\u672A\u914D\u7F6E vcs.baseBranch\uFF09", "record-set \u5199 ALIGN.baseBranch\uFF0C\u6216 siming project update --vcs-base-branch <\u5206\u652F>");
   }
-  const merged = await baseMergedIntoHead(ctx, ctx.baseBranch);
-  if (merged === null) {
-    return fail2(ctx, type, `git fetch origin ${ctx.baseBranch} \u5931\u8D25\u2014\u2014\u65E0\u6CD5\u4EE5\u8FDC\u7A0B\u6700\u65B0\u5F15\u7528\u5224\u5B9A\uFF08\u62D2\u6309\u9648\u65E7 ref \u8BEF\u5224\uFF09`, "\u68C0\u67E5\u7F51\u7EDC/\u8FDC\u7A0B\u53EF\u8FBE\u540E\u91CD\u8BD5\uFF1B\u786E\u8BA4\u5206\u652F\u5B58\u5728\u4E8E origin");
-  }
-  if (!merged) {
-    return fail2(ctx, type, `origin/${ctx.baseBranch} \u5C1A\u672A\u5408\u5165\u5F53\u524D\u5206\u652F`, `\u6309 ALIGN \u8282\u70B9\u8981\u6C42\u5408\u5E76\u57FA\u7840\u5206\u652F\u8FDC\u7A0B\u6700\u65B0\u4EE3\u7801\uFF08merge ${ctx.baseBranch} \u2192 \u5F53\u524D\u5206\u652F\uFF09\u540E\u91CD\u8BD5`);
-  }
-  return { type, status: "pass", detail: `origin/${ctx.baseBranch} \u5DF2\u5408\u5165 HEAD` };
+  const base = ctx.baseBranch;
+  return perRepoCheck(ctx, type, async (repo) => {
+    const merged = await baseMergedIntoHead(ctx, base, repo);
+    if (merged === null) {
+      return { status: "fail", detail: `git fetch origin ${base} \u5931\u8D25\u2014\u2014\u65E0\u6CD5\u4EE5\u8FDC\u7A0B\u6700\u65B0\u5F15\u7528\u5224\u5B9A\uFF08\u62D2\u6309\u9648\u65E7 ref \u8BEF\u5224\uFF09\uFF1B\u68C0\u67E5\u7F51\u7EDC/\u8FDC\u7A0B\u53EF\u8FBE\u540E\u91CD\u8BD5\uFF0C\u786E\u8BA4\u5206\u652F\u5B58\u5728\u4E8E origin` };
+    }
+    if (!merged) {
+      return { status: "fail", detail: `origin/${base} \u5C1A\u672A\u5408\u5165\u5F53\u524D\u5206\u652F\u2014\u2014\u6309 ALIGN \u8282\u70B9\u8981\u6C42\u5408\u5E76\u57FA\u7840\u5206\u652F\u8FDC\u7A0B\u6700\u65B0\u4EE3\u7801\uFF08merge ${base} \u2192 \u5F53\u524D\u5206\u652F\uFF09\u540E\u91CD\u8BD5` };
+    }
+    return { status: "pass", detail: `origin/${base} \u5DF2\u5408\u5165 HEAD` };
+  });
 }
 function findWaivedDecision(ctx, nodeId) {
   const record = ctx.nodeRecords[nodeId];
@@ -755,16 +798,18 @@ async function checkWorktreeClean(ctx) {
   const type = "git-worktree-clean";
   const guard = naIfRepoUnavailable(ctx);
   if (guard) return { ...guard, type };
-  const r = await ctx.runGit(["status", "--porcelain"], ctx.repoPath);
-  if (!r.ok) {
-    return fail2(ctx, type, `git status \u5931\u8D25\uFF1A${firstLine(r.stderr)}`, "\u68C0\u67E5\u4ED3\u5E93\u53EF\u7528\u6027");
-  }
-  if (r.stdout.trim() !== "") {
-    const count = r.stdout.trim().split("\n").length;
-    const sample = r.stdout.trim().split("\n").slice(0, 3).join("; ");
-    return fail2(ctx, type, `\u5DE5\u4F5C\u6811\u4E0D\u5E72\u51C0\uFF08${count} \u5904\u672A\u63D0\u4EA4\u53D8\u66F4\uFF1A${sample}\uFF09`, "\u5B8C\u6210\u672C\u8282\u70B9\u6210\u679C\u63D0\u4EA4\uFF08\u6216\u5199 .gitignore / \u8C41\u514D\u7559\u75D5\uFF09\u540E\u518D\u63A8\u8FDB");
-  }
-  return { type, status: "pass", detail: "\u5DE5\u4F5C\u6811\u5E72\u51C0" };
+  return perRepoCheck(ctx, type, async (repo) => {
+    const r = await ctx.runGit(["status", "--porcelain"], repo);
+    if (!r.ok) {
+      return { status: "fail", detail: `git status \u5931\u8D25\uFF1A${firstLine(r.stderr)}\u2014\u2014\u68C0\u67E5\u4ED3\u5E93\u53EF\u7528\u6027` };
+    }
+    if (r.stdout.trim() !== "") {
+      const count = r.stdout.trim().split("\n").length;
+      const sample = r.stdout.trim().split("\n").slice(0, 3).join("; ");
+      return { status: "fail", detail: `\u5DE5\u4F5C\u6811\u4E0D\u5E72\u51C0\uFF08${count} \u5904\u672A\u63D0\u4EA4\u53D8\u66F4\uFF1A${sample}\uFF09\u2014\u2014\u5B8C\u6210\u672C\u8282\u70B9\u6210\u679C\u63D0\u4EA4\uFF08\u6216\u5199 .gitignore / \u8C41\u514D\u7559\u75D5\uFF09\u540E\u518D\u63A8\u8FDB` };
+    }
+    return { status: "pass", detail: "\u5DE5\u4F5C\u6811\u5E72\u51C0" };
+  });
 }
 async function checkArchiveMerged(ctx) {
   const type = "git-archive-merged";
@@ -785,29 +830,31 @@ async function checkArchiveMerged(ctx) {
     return fail2(ctx, type, "\u57FA\u7840\u5206\u652F\u672A\u77E5\uFF08ACCEPT \u524D\u7F6E\uFF1AALIGN \u5E94\u5DF2\u843D\u76D8 baseBranch\uFF09", "record-set \u5199 ALIGN.baseBranch\uFF0C\u6216 siming project update --vcs-base-branch <\u5206\u652F>");
   }
   const base = ctx.baseBranch;
-  const count = await ctx.runGit(["rev-list", "--count", `${base}..HEAD`], ctx.repoPath);
-  if (count.ok && count.stdout.trim() === "0") {
-    return { type, status: "not_applicable", detail: `\u4EFB\u52A1\u5206\u652F\u76F8\u5BF9 ${base} \u96F6\u63D0\u4EA4\uFF08\u65E0\u4EE3\u7801\u6539\u52A8\uFF0C\u65E0\u9700\u5408\u5E76\uFF09` };
-  }
-  const fetch2 = await ctx.runGit(["fetch", "origin", base], ctx.repoPath);
-  if (!fetch2.ok) {
-    return fail2(ctx, type, `git fetch origin ${base} \u5931\u8D25\u2014\u2014\u672C\u5730\u4E0E\u8FDC\u7A0B\u4E00\u81F4\u6027\u65E0\u4ECE\u5224\u5B9A\uFF08\u62D2\u6309\u9648\u65E7 ref \u8BEF\u5224\uFF09`, "\u68C0\u67E5\u7F51\u7EDC/\u8FDC\u7A0B\u53EF\u8FBE\u540E\u91CD\u8BD5");
-  }
-  const ancestor = await ctx.runGit(["merge-base", "--is-ancestor", "HEAD", base], ctx.repoPath);
-  if (!ancestor.ok) {
-    return fail2(ctx, type, `\u57FA\u7840\u5206\u652F ${base} \u5C1A\u672A\u5305\u542B\u4EFB\u52A1\u5206\u652F HEAD\uFF08\u672A\u5408\u5E76\uFF09`, `git checkout ${base} && git merge --no-ff <\u4EFB\u52A1\u5206\u652F> && git push`);
-  }
-  const merges = await ctx.runGit(["log", "--merges", "-1", "--format=%P", base], ctx.repoPath);
-  const parents = merges.ok ? merges.stdout.trim().split(/\s+/) : [];
-  if (parents.length !== 2) {
-    return fail2(ctx, type, `\u672A\u68C0\u6D4B\u5230 --no-ff \u5408\u5E76\u63D0\u4EA4\uFF08\u6700\u8FD1\u4E00\u6B21\u5408\u5E76 parents=${parents.length}\uFF09`, "\u5408\u5E76\u5FC5\u987B\u4F7F\u7528 --no-ff\uFF08\u4FDD\u7559\u5408\u5E76\u8BB0\u5F55\uFF09\uFF1Agit merge --no-ff <\u4EFB\u52A1\u5206\u652F>");
-  }
-  const localBase = await ctx.runGit(["rev-parse", base], ctx.repoPath);
-  const remoteBase = await ctx.runGit(["rev-parse", `origin/${base}`], ctx.repoPath);
-  if (!localBase.ok || !remoteBase.ok || localBase.stdout.trim() !== remoteBase.stdout.trim()) {
-    return fail2(ctx, type, `\u672C\u5730 ${base} \u4E0E origin/${base} \u4E0D\u4E00\u81F4\uFF08\u5408\u5E76\u7ED3\u679C\u672A\u63A8\u9001\u6216\u672A\u62C9\u53D6\uFF09`, `git push origin ${base}\uFF08\u6216\u5148 pull \u5BF9\u9F50\uFF09`);
-  }
-  return { type, status: "pass", detail: `\u4EFB\u52A1\u5206\u652F\u5DF2 --no-ff \u5408\u5165 ${base} \u4E14\u5DF2\u4E0E\u8FDC\u7A0B\u4E00\u81F4` };
+  return perRepoCheck(ctx, type, async (repo) => {
+    const count = await ctx.runGit(["rev-list", "--count", `${base}..HEAD`], repo);
+    if (count.ok && count.stdout.trim() === "0") {
+      return { status: "not_applicable", detail: `\u4EFB\u52A1\u5206\u652F\u76F8\u5BF9 ${base} \u96F6\u63D0\u4EA4\uFF08\u65E0\u4EE3\u7801\u6539\u52A8\uFF0C\u65E0\u9700\u5408\u5E76\uFF09` };
+    }
+    const fetch2 = await ctx.runGit(["fetch", "origin", base], repo);
+    if (!fetch2.ok) {
+      return { status: "fail", detail: `git fetch origin ${base} \u5931\u8D25\u2014\u2014\u672C\u5730\u4E0E\u8FDC\u7A0B\u4E00\u81F4\u6027\u65E0\u4ECE\u5224\u5B9A\uFF08\u62D2\u6309\u9648\u65E7 ref \u8BEF\u5224\uFF09\uFF1B\u68C0\u67E5\u7F51\u7EDC/\u8FDC\u7A0B\u53EF\u8FBE\u540E\u91CD\u8BD5` };
+    }
+    const ancestor = await ctx.runGit(["merge-base", "--is-ancestor", "HEAD", base], repo);
+    if (!ancestor.ok) {
+      return { status: "fail", detail: `\u57FA\u7840\u5206\u652F ${base} \u5C1A\u672A\u5305\u542B\u4EFB\u52A1\u5206\u652F HEAD\uFF08\u672A\u5408\u5E76\uFF09\u2014\u2014git checkout ${base} && git merge --no-ff <\u4EFB\u52A1\u5206\u652F> && git push` };
+    }
+    const merges = await ctx.runGit(["log", "--merges", "-1", "--format=%P", base], repo);
+    const parents = merges.ok ? merges.stdout.trim().split(/\s+/) : [];
+    if (parents.length !== 2) {
+      return { status: "fail", detail: `\u672A\u68C0\u6D4B\u5230 --no-ff \u5408\u5E76\u63D0\u4EA4\uFF08\u6700\u8FD1\u4E00\u6B21\u5408\u5E76 parents=${parents.length}\uFF09\u2014\u2014\u5408\u5E76\u5FC5\u987B\u4F7F\u7528 --no-ff\uFF08\u4FDD\u7559\u5408\u5E76\u8BB0\u5F55\uFF09` };
+    }
+    const localBase = await ctx.runGit(["rev-parse", base], repo);
+    const remoteBase = await ctx.runGit(["rev-parse", `origin/${base}`], repo);
+    if (!localBase.ok || !remoteBase.ok || localBase.stdout.trim() !== remoteBase.stdout.trim()) {
+      return { status: "fail", detail: `\u672C\u5730 ${base} \u4E0E origin/${base} \u4E0D\u4E00\u81F4\uFF08\u5408\u5E76\u7ED3\u679C\u672A\u63A8\u9001\u6216\u672A\u62C9\u53D6\uFF09\u2014\u2014git push origin ${base}\uFF08\u6216\u5148 pull \u5BF9\u9F50\uFF09` };
+    }
+    return { status: "pass", detail: `\u5DF2 --no-ff \u5408\u5165 ${base} \u4E14\u4E0E\u8FDC\u7A0B\u4E00\u81F4` };
+  });
 }
 async function checkStayOnBase(ctx) {
   const type = "git-stay-on-base";
@@ -822,14 +869,17 @@ async function checkStayOnBase(ctx) {
   if (ctx.baseBranch === null) {
     return fail2(ctx, type, "\u57FA\u7840\u5206\u652F\u672A\u77E5\uFF08ARCHIVE \u524D\u7F6E\uFF1AALIGN \u5E94\u5DF2\u843D\u76D8 baseBranch\uFF09", "record-set \u5199 ALIGN.baseBranch\uFF0C\u6216 siming project update --vcs-base-branch <\u5206\u652F>");
   }
-  const branch = await currentBranch(ctx);
-  if (branch === null) {
-    return fail2(ctx, type, "\u65E0\u6CD5\u8BFB\u53D6\u5F53\u524D\u5206\u652F", "\u786E\u8BA4\u4ED3\u5E93\u72B6\u6001");
-  }
-  if (branch !== ctx.baseBranch) {
-    return fail2(ctx, type, `\u5F52\u6863\u540E\u5E94\u505C\u7559\u57FA\u7840\u5206\u652F\uFF1A\u5F53\u524D\u5728\u300C${branch}\u300D\uFF0C\u671F\u671B\u300C${ctx.baseBranch}\u300D`, `git checkout ${ctx.baseBranch}\uFF08\u7981\u6B62\u7ACB\u5373\u5F00\u59CB\u4E0B\u4E00\u4EFB\u52A1\u5206\u652F\uFF09`);
-  }
-  return { type, status: "pass", detail: `\u5F53\u524D\u505C\u7559\u5728\u57FA\u7840\u5206\u652F ${branch}` };
+  const base = ctx.baseBranch;
+  return perRepoCheck(ctx, type, async (repo) => {
+    const branch = await currentBranch(ctx, repo);
+    if (branch === null) {
+      return { status: "fail", detail: "\u65E0\u6CD5\u8BFB\u53D6\u5F53\u524D\u5206\u652F\u2014\u2014\u786E\u8BA4\u4ED3\u5E93\u72B6\u6001" };
+    }
+    if (branch !== base) {
+      return { status: "fail", detail: `\u5F52\u6863\u540E\u5E94\u505C\u7559\u57FA\u7840\u5206\u652F\uFF1A\u5F53\u524D\u5728\u300C${branch}\u300D\uFF0C\u671F\u671B\u300C${base}\u300D\u2014\u2014git checkout ${base}\uFF08\u7981\u6B62\u7ACB\u5373\u5F00\u59CB\u4E0B\u4E00\u4EFB\u52A1\u5206\u652F\uFF09` };
+    }
+    return { status: "pass", detail: `\u505C\u7559\u5728\u57FA\u7840\u5206\u652F ${branch}` };
+  });
 }
 function firstLine(text) {
   return text.trim().split("\n")[0] ?? "";
@@ -869,18 +919,21 @@ async function checkNoFakeGreen(ctx) {
   if (ctx.baseBranch === null) {
     return fail3(type, "\u57FA\u7840\u5206\u652F\u672A\u77E5\uFF08ALIGN.baseBranch \u672A\u843D\u76D8\u4E14\u9879\u76EE\u672A\u914D\u7F6E\uFF09", "record-set \u5199 ALIGN.baseBranch\uFF0C\u6216 siming project update --vcs-base-branch <\u5206\u652F>");
   }
-  const diff = await ctx.runGit(
-    ["diff", `${ctx.baseBranch}...HEAD`, "--", "**/*.test.ts", "**/*.spec.ts", "**/tests/**"],
-    ctx.repoPath
-  );
-  if (!diff.ok) {
-    return fail3(type, `\u6D4B\u8BD5\u6587\u4EF6 diff \u5931\u8D25\uFF1A${firstLine2(diff.stderr)}`, "\u68C0\u67E5\u4ED3\u5E93\u4E0E\u57FA\u7840\u5206\u652F\u53EF\u7528\u6027");
-  }
-  const violations = scanTestDiff(diff.stdout);
-  if (violations.length > 0) {
-    return fail3(type, `\u6D4B\u8BD5\u5B8C\u6574\u6027\u8FDD\u89C4\uFF1A${violations.join("\uFF1B")}`, "\u8FD8\u539F\u6D4B\u8BD5\u6539\u52A8\uFF1B\u786E\u5C5E\u5408\u6CD5\u8C03\u6574\u987B\u7ECF\u7528\u6237\u6279\u51C6\u540E record-decision-add \u5199 topic=test-adjust-approved");
-  }
-  return { type, status: "pass", detail: "\u6D4B\u8BD5\u6587\u4EF6\u65E0 skip/only \u65B0\u589E\u4E0E\u6574\u5220\uFF08\u653E\u5BBD\u65AD\u8A00\u5F62\u6001\u4E0D\u5728\u673A\u5668\u68C0\u6D4B\u9762\uFF0C\u4F9D\u8D56 test-adjust-approved \u7559\u75D5\u628A\u5173\uFF09" };
+  const base = ctx.baseBranch;
+  return perRepoCheck(ctx, type, async (repo) => {
+    const diff = await ctx.runGit(
+      ["diff", `${base}...HEAD`, "--", "**/*.test.ts", "**/*.spec.ts", "**/tests/**"],
+      repo
+    );
+    if (!diff.ok) {
+      return { status: "fail", detail: `\u6D4B\u8BD5\u6587\u4EF6 diff \u5931\u8D25\uFF1A${firstLine2(diff.stderr)}\u2014\u2014\u68C0\u67E5\u4ED3\u5E93\u4E0E\u57FA\u7840\u5206\u652F\u53EF\u7528\u6027` };
+    }
+    const violations = scanTestDiff(diff.stdout);
+    if (violations.length > 0) {
+      return { status: "fail", detail: `\u6D4B\u8BD5\u5B8C\u6574\u6027\u8FDD\u89C4\uFF1A${violations.join("\uFF1B")}\u2014\u2014\u8FD8\u539F\u6D4B\u8BD5\u6539\u52A8\uFF1B\u786E\u5C5E\u5408\u6CD5\u8C03\u6574\u987B\u7ECF\u7528\u6237\u6279\u51C6\u540E record-decision-add \u5199 topic=test-adjust-approved` };
+    }
+    return { status: "pass", detail: "\u6D4B\u8BD5\u6587\u4EF6\u65E0 skip/only \u65B0\u589E\u4E0E\u6574\u5220\uFF08\u653E\u5BBD\u65AD\u8A00\u5F62\u6001\u4E0D\u5728\u673A\u5668\u68C0\u6D4B\u9762\uFF0C\u4F9D\u8D56 test-adjust-approved \u7559\u75D5\u628A\u5173\uFF09" };
+  });
 }
 function scanTestDiff(patch) {
   const violations = [];
@@ -918,15 +971,18 @@ async function checkBaseReMerged(ctx) {
   if (ctx.baseBranch === null) {
     return fail3(type, "\u57FA\u7840\u5206\u652F\u672A\u77E5\uFF08ALIGN.baseBranch \u672A\u843D\u76D8\u4E14\u9879\u76EE\u672A\u914D\u7F6E\uFF09", "record-set \u5199 ALIGN.baseBranch\uFF0C\u6216 siming project update --vcs-base-branch <\u5206\u652F>");
   }
-  const fetch2 = await ctx.runGit(["fetch", "origin", ctx.baseBranch], ctx.repoPath);
-  if (!fetch2.ok) {
-    return fail3(type, `git fetch origin ${ctx.baseBranch} \u5931\u8D25\u2014\u2014\u65E0\u6CD5\u4EE5\u8FDC\u7A0B\u6700\u65B0\u5F15\u7528\u5224\u5B9A\uFF08\u62D2\u6309\u9648\u65E7 ref \u8BEF\u5224\uFF09`, "\u68C0\u67E5\u7F51\u7EDC/\u8FDC\u7A0B\u53EF\u8FBE\u540E\u91CD\u8BD5");
-  }
-  const r = await ctx.runGit(["merge-base", "--is-ancestor", `origin/${ctx.baseBranch}`, "HEAD"], ctx.repoPath);
-  if (!r.ok) {
-    return fail3(type, `origin/${ctx.baseBranch} \u589E\u91CF\u672A\u518D\u5408\u5165\u5F53\u524D\u5206\u652F\uFF08\u96C6\u6210\u524D\u57FA\u7840\u5206\u652F\u6709\u65B0\u63D0\u4EA4\uFF09`, `merge ${ctx.baseBranch} \u2192 \u5F53\u524D\u5206\u652F\uFF08\u6D88\u89E3\u6F02\u79FB\uFF09\u540E\u518D\u63A8\u8FDB`);
-  }
-  return { type, status: "pass", detail: `origin/${ctx.baseBranch} \u5DF2\u518D\u5408\u5165 HEAD` };
+  const base = ctx.baseBranch;
+  return perRepoCheck(ctx, type, async (repo) => {
+    const fetch2 = await ctx.runGit(["fetch", "origin", base], repo);
+    if (!fetch2.ok) {
+      return { status: "fail", detail: `git fetch origin ${base} \u5931\u8D25\u2014\u2014\u65E0\u6CD5\u4EE5\u8FDC\u7A0B\u6700\u65B0\u5F15\u7528\u5224\u5B9A\uFF08\u62D2\u6309\u9648\u65E7 ref \u8BEF\u5224\uFF09\uFF1B\u68C0\u67E5\u7F51\u7EDC/\u8FDC\u7A0B\u53EF\u8FBE\u540E\u91CD\u8BD5` };
+    }
+    const r = await ctx.runGit(["merge-base", "--is-ancestor", `origin/${base}`, "HEAD"], repo);
+    if (!r.ok) {
+      return { status: "fail", detail: `origin/${base} \u589E\u91CF\u672A\u518D\u5408\u5165\u5F53\u524D\u5206\u652F\uFF08\u96C6\u6210\u524D\u57FA\u7840\u5206\u652F\u6709\u65B0\u63D0\u4EA4\uFF09\u2014\u2014merge ${base} \u2192 \u5F53\u524D\u5206\u652F\uFF08\u6D88\u89E3\u6F02\u79FB\uFF09\u540E\u518D\u63A8\u8FDB` };
+    }
+    return { status: "pass", detail: `origin/${base} \u5DF2\u518D\u5408\u5165 HEAD` };
+  });
 }
 async function checkFixReviewPass(ctx) {
   const type = "record-fix-review-pass";
@@ -948,11 +1004,25 @@ async function checkVerifiedCommit(ctx) {
   }
   const guard = naIfRepoUnavailable(ctx);
   if (guard) return { ...guard, type };
-  const r = await ctx.runGit(["cat-file", "-e", sha], ctx.repoPath);
-  if (!r.ok) {
-    return fail3(type, `verifiedCommit\u300C${sha}\u300D\u5728\u4ED3\u5E93\u4E2D\u4E0D\u5B58\u5728\uFF08cat-file \u5931\u8D25\uFF09`, "record-set \u4FEE\u6B63 verifiedCommit \u4E3A\u771F\u5B9E\u5B58\u5728\u7684\u63D0\u4EA4\u53F7");
+  const hitRepos = [];
+  for (const repo of ctx.repos) {
+    const r = await ctx.runGit(["cat-file", "-e", sha], repo);
+    if (r.ok) hitRepos.push(repo);
+  }
+  if (hitRepos.length > 0) {
+    return {
+      type,
+      status: "pass",
+      detail: `\u9A8C\u8BC1\u7248\u672C ${sha} \u5B58\u5728\uFF08\u547D\u4E2D\u4ED3 ${hitRepos.join("\u3001")}\uFF09
+${ctx.reposScanDetail}`
+    };
   }
-  return { type, status: "pass", detail: `\u9A8C\u8BC1\u7248\u672C ${sha} \u5B58\u5728` };
+  return fail3(
+    type,
+    `verifiedCommit\u300C${sha}\u300D\u5728 R \u5168\u90E8\u4ED3\u4E2D\u4E0D\u5B58\u5728\uFF08${ctx.repos.join("\u3001")}\uFF09`,
+    `record-set \u4FEE\u6B63 verifiedCommit \u4E3A\u771F\u5B9E\u5B58\u5728\u7684\u63D0\u4EA4\u53F7
+${ctx.reposScanDetail}`
+  );
 }
 async function checkPrevNodesDone(ctx) {
   const type = "record-prev-nodes-done";
@@ -997,24 +1067,58 @@ async function checkVersionConsistent(ctx) {
   if (ctx.baseBranch === null) {
     return fail3(type, "\u57FA\u7840\u5206\u652F\u672A\u77E5\uFF08ALIGN.baseBranch \u672A\u843D\u76D8\u4E14\u9879\u76EE\u672A\u914D\u7F6E\uFF09", "record-set \u5199 ALIGN.baseBranch\uFF0C\u6216 siming project update --vcs-base-branch <\u5206\u652F>");
   }
-  const r = await ctx.runGit(["diff", "--name-only", `${sha}..${ctx.baseBranch}`], ctx.repoPath);
-  if (!r.ok) {
-    return fail3(type, `\u7248\u672C diff \u5931\u8D25\uFF1A${firstLine2(r.stderr)}`, "\u68C0\u67E5 verifiedCommit \u4E0E\u57FA\u7840\u5206\u652F\u53EF\u7528\u6027");
+  const base = ctx.baseBranch;
+  const hitRepos = [];
+  for (const repo of ctx.repos) {
+    const probe = await ctx.runGit(["cat-file", "-e", sha], repo);
+    if (probe.ok) hitRepos.push(repo);
+  }
+  if (hitRepos.length === 0) {
+    return fail3(
+      type,
+      `verifiedCommit\u300C${sha}\u300D\u5728 R \u5168\u90E8\u4ED3\u4E2D\u4E0D\u5B58\u5728\uFF08${ctx.repos.join("\u3001")}\uFF09`,
+      `\u56DE\u8865 INTEGRATE record-set verifiedCommit \u4E3A\u4EFB\u52A1\u4ED3\u771F\u5B9E\u63D0\u4EA4\u53F7\u540E\u91CD\u8BD5
+${ctx.reposScanDetail}`
+    );
   }
   const exempt = (path) => ctx.docPaths.some((p) => {
     if (p.endsWith("/")) return path.startsWith(p);
     if (p.startsWith("*")) return path.endsWith(p.slice(1));
     return path === p;
   });
-  const leaked = r.stdout.split("\n").map((l) => l.trim()).filter((l) => l !== "" && !exempt(l));
-  if (leaked.length > 0) {
+  const leakByRepo = [];
+  const errRepos = [];
+  for (const repo of hitRepos) {
+    const r = await ctx.runGit(["diff", "--name-only", `${sha}..${base}`], repo);
+    if (!r.ok) {
+      errRepos.push(repo);
+      continue;
+    }
+    const leaked = r.stdout.split("\n").map((l) => l.trim()).filter((l) => l !== "" && !exempt(l));
+    if (leaked.length > 0) leakByRepo.push({ repo, leaked });
+  }
+  if (errRepos.length > 0) {
+    return fail3(type, `\u7248\u672C diff \u5931\u8D25\uFF08\u4ED3 ${errRepos.join("\u3001")}\uFF09`, `\u68C0\u67E5 verifiedCommit \u4E0E\u57FA\u7840\u5206\u652F\u53EF\u7528\u6027
+${ctx.reposScanDetail}`);
+  }
+  if (leakByRepo.length > 0) {
+    const lines = leakByRepo.slice(0, 3).map((x) => `${x.repo}: ${x.leaked.slice(0, 5).join(", ")}${x.leaked.length > 5 ? ` \u7B49 ${x.leaked.length} \u4E2A` : ""}`);
+    const suffix = leakByRepo.length > 3 ? `\uFF08\u53E6\u6709 ${leakByRepo.length - 3} \u4ED3\u6CC4\u6F0F\u89C1\u9010\u4ED3\u91CD\u67E5\uFF09` : "";
     return fail3(
       type,
-      `verifiedCommit \u4E0E ${ctx.baseBranch} \u5B58\u5728\u975E\u6587\u6863\u5DEE\u5F02\uFF08${leaked.slice(0, 5).join(", ")}${leaked.length > 5 ? ` \u7B49 ${leaked.length} \u4E2A` : ""}\uFF09`,
-      "\u4EE3\u7801\u6539\u52A8\u987B\u5408\u5E76\u8FDB\u57FA\u7840\u5206\u652F\uFF08\u542B\u5E76\u884C\u4EFB\u52A1 base \u524D\u8FDB\u573A\u666F\uFF1A\u91CD\u8D70\u5408\u5E76\u6216\u7ECF\u7528\u6237\u660E\u793A\u540E force \u63A8\u8FDB\u5E76\u7559\u75D5\uFF09"
+      `verifiedCommit \u4E0E ${base} \u5B58\u5728\u975E\u6587\u6863\u5DEE\u5F02\u2014\u2014${lines.join("\uFF1B")}${suffix}`,
+      `\u4EE3\u7801\u6539\u52A8\u987B\u5408\u5E76\u8FDB\u57FA\u7840\u5206\u652F\uFF08\u542B\u5E76\u884C\u4EFB\u52A1 base \u524D\u8FDB\u573A\u666F\uFF1A\u91CD\u8D70\u5408\u5E76\u6216\u7ECF\u7528\u6237\u660E\u793A\u540E force \u63A8\u8FDB\u5E76\u7559\u75D5\uFF09
+${ctx.reposScanDetail}`
     );
   }
-  return { type, status: "pass", detail: `verifiedCommit ${sha} \u4E0E ${ctx.baseBranch} \u4E00\u81F4\uFF08\u6587\u6863\u8DEF\u5F84\u8C41\u514D ${ctx.docPaths.join(" ")}\uFF09` };
+  const naRepos = ctx.repos.filter((r) => !hitRepos.includes(r));
+  const naPart = naRepos.length > 0 ? `\uFF1B\u65E0\u951A\u70B9\u4ED3\uFF08\u4E0D\u542B\u8BE5 sha\uFF0C\u514D\u5224\uFF09\uFF1A${naRepos.join("\u3001")}` : "";
+  return {
+    type,
+    status: "pass",
+    detail: `verifiedCommit ${sha} \u4E0E ${base} \u4E00\u81F4\uFF08\u547D\u4E2D\u4ED3 ${hitRepos.join("\u3001")}\uFF1B\u6587\u6863\u8DEF\u5F84\u8C41\u514D ${ctx.docPaths.join(" ")}${naPart}\uFF09
+${ctx.reposScanDetail}`
+  };
 }
 async function checkDeferredIssues(ctx) {
   const type = "record-deferred-issues";
@@ -1038,17 +1142,21 @@ async function checkEvidenceFiles(ctx) {
   if (files.length === 0) {
     return fail3(type, "\u672C\u8282\u70B9\u8BB0\u5F55\u672A\u5199 evidenceFiles\uFF08\u89C6\u89C9\u9A8C\u6536\u8BC1\u636E\u7F3A\u5931\uFF09", "record-set \u5199 evidenceFiles\uFF08\u622A\u56FE/\u5F55\u5C4F\u76F8\u5BF9\u8DEF\u5F84\u6E05\u5355\uFF09");
   }
-  if (ctx.repoPath === null) {
-    return { type, status: "not_applicable", detail: `\u4ED3\u5E93\u4E0D\u53EF\u7528\uFF1A${ctx.repoProbeDetail}` };
-  }
+  const guard = naIfRepoUnavailable(ctx);
+  if (guard) return { ...guard, type };
   const missing = [];
+  const hits = [];
   for (const rel of files) {
-    if (!ctx.fileExists(`${ctx.repoPath}/${rel}`)) missing.push(rel);
+    const hit = ctx.repos.find((repo) => ctx.fileExists(`${repo}/${rel}`));
+    if (hit === void 0) missing.push(rel);
+    else hits.push({ rel, repo: hit });
   }
   if (missing.length > 0) {
-    return fail3(type, `\u8BC1\u636E\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${missing.join(", ")}`, "\u8865\u9F50\u8BC1\u636E\u6587\u4EF6\u6216 record-set \u4FEE\u6B63 evidenceFiles \u8DEF\u5F84");
+    return fail3(type, `\u8BC1\u636E\u6587\u4EF6\u4E0D\u5B58\u5728\uFF08${missing.join(", ")}\u2014\u2014R \u5168\u90E8\u4ED3\u67E5\u627E\u65E0\u679C\uFF09`, `\u8865\u9F50\u8BC1\u636E\u6587\u4EF6\u6216 record-set \u4FEE\u6B63 evidenceFiles \u8DEF\u5F84
+${ctx.reposScanDetail}`);
   }
-  return { type, status: "pass", detail: `\u8BC1\u636E\u6587\u4EF6 ${files.length} \u4E2A\u5747\u5B58\u5728` };
+  return { type, status: "pass", detail: `\u8BC1\u636E\u6587\u4EF6 ${files.length} \u4E2A\u5747\u5B58\u5728\uFF08${hits.map((h) => `${h.rel} @ ${h.repo}`).join("\uFF1B")}\uFF09
+${ctx.reposScanDetail}` };
 }
 async function checkFinalConverged(ctx) {
   const type = "record-final-converged";
@@ -1153,6 +1261,64 @@ function auditAiChecks(aiChecks, record) {
 import { DEFAULT_VCS_DOC_PATHS } from "@siming-org/core";
 import { execFile } from "child_process";
 import { promisify } from "util";
+
+// src/config/workspace-repos.ts
+import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync5 } from "fs";
+import { join as join5 } from "path";
+var EXCLUDED_DIR_NAMES = /* @__PURE__ */ new Set(["temp", "node_modules", "dist", "build"]);
+var DEFAULT_SCAN_DEPTH = 1;
+var MAX_SCAN_DEPTH = 3;
+var WORKSPACE_DIR_NAME3 = ".siming";
+var DEV_JSON_FILE2 = "dev.json";
+function normalizeScanDepth(raw) {
+  if (typeof raw !== "number" || !Number.isFinite(raw) || !Number.isInteger(raw)) {
+    return DEFAULT_SCAN_DEPTH;
+  }
+  if (raw <= 0) return DEFAULT_SCAN_DEPTH;
+  return Math.min(raw, MAX_SCAN_DEPTH);
+}
+function readScanDepth(cwd) {
+  const path = join5(cwd, WORKSPACE_DIR_NAME3, DEV_JSON_FILE2);
+  try {
+    if (!existsSync5(path)) return DEFAULT_SCAN_DEPTH;
+    const parsed = JSON.parse(readFileSync5(path, "utf-8"));
+    return normalizeScanDepth(parsed.scanDepth);
+  } catch {
+    return DEFAULT_SCAN_DEPTH;
+  }
+}
+function isGitRepo(dir) {
+  return existsSync5(join5(dir, ".git"));
+}
+function isExcludedDir(name) {
+  return EXCLUDED_DIR_NAMES.has(name) || name.startsWith(".");
+}
+function scanWorkspaceRepos(cwd, scanDepthOverride) {
+  const scanDepth = scanDepthOverride !== void 0 ? normalizeScanDepth(scanDepthOverride) : readScanDepth(cwd);
+  const repos = [];
+  let scannedDirs = 0;
+  const queue = [{ dir: cwd, depth: 0 }];
+  while (queue.length > 0) {
+    const { dir, depth } = queue.shift();
+    if (isGitRepo(dir)) repos.push(dir);
+    if (depth >= scanDepth) continue;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      scannedDirs++;
+      if (isExcludedDir(entry.name)) continue;
+      queue.push({ dir: join5(dir, entry.name), depth: depth + 1 });
+    }
+  }
+  return { repos, scannedDirs, scanDepth };
+}
+
+// src/client/checks/param-resolver.ts
 var execFileAsync = promisify(execFile);
 var defaultGitRunner = async (args, cwd) => {
   try {
@@ -1163,35 +1329,22 @@ var defaultGitRunner = async (args, cwd) => {
     return { ok: false, stdout: e.stdout ?? "", stderr: e.stderr ?? e.message ?? String(err2) };
   }
 };
-async function resolveCheckContextWithRunner(base, vcs, cwd, runGit) {
-  const probe = vcs.repoPath !== void 0 ? await probeRepo(vcs.repoPath, runGit) : await probeRepo(cwd, runGit);
+async function resolveCheckContextWithRunner(base, vcs, cwd, scan) {
+  const result = scan !== void 0 ? scan(cwd) : scanWorkspaceRepos(cwd);
   const alignRecord = base.nodeRecords["ALIGN"];
   const baseBranch = (alignRecord?.baseBranch !== void 0 && alignRecord.baseBranch !== "" ? alignRecord.baseBranch : void 0) ?? vcs.baseBranch ?? null;
   return {
     ...base,
-    repoPath: probe.repoPath,
-    repoProbeDetail: probe.detail,
+    repos: result.repos,
+    reposScanDetail: `scanned from: ${cwd}\uFF08\u5BBF\u4E3B\u542F\u52A8 cwd\u2014\u2014\u5B50\u76EE\u5F55\u542F\u52A8\u4F1A\u9759\u9ED8\u6F0F\u4ED3\uFF09\uFF1Brepos(${result.repos.length}): ${result.repos.join(", ") || "\u65E0"}\uFF1BscanDepth=${result.scanDepth}\uFF1BscannedDirs=${result.scannedDirs}`,
     baseBranch,
     branchPattern: vcs.branchPattern ?? "feature/",
     docPaths: vcs.docPaths ?? [...DEFAULT_VCS_DOC_PATHS]
   };
 }
-async function probeRepo(candidate, runGit) {
-  const r = await runGit(["rev-parse", "--show-toplevel"], candidate);
-  if (!r.ok) {
-    return {
-      repoPath: null,
-      detail: `\u4ED3\u5E93\u63A2\u6D4B\u5931\u8D25\uFF1ArepoPath \u5019\u9009\u300C${candidate}\u300D\uFF08git rev-parse --show-toplevel \u5931\u8D25\uFF1A${firstLine3(r.stderr)}\uFF09`
-    };
-  }
-  return { repoPath: firstLine3(r.stdout), detail: "" };
-}
-function firstLine3(text) {
-  return text.trim().split("\n")[0] ?? "";
-}
 
 // src/client/checks/runner.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 function gateHasFailure(report) {
   return report.toolOutcomes.some((o) => o.status === "fail") || report.aiOutcomes.some((o) => o.status === "fail");
 }
@@ -1243,11 +1396,10 @@ async function runNodeGate(client, taskId) {
         ids.delete("");
         return { ok: true, ids };
       },
-      fileExists: (p) => existsSync5(p)
+      fileExists: (p) => existsSync6(p)
     },
     vcs,
-    process.cwd(),
-    defaultGitRunner
+    process.cwd()
   );
   const toolOutcomes = [];
   for (const toolCheck of toolChecks) {
@@ -1576,7 +1728,7 @@ async function resolveArtifactBatchEntries(entries) {
     let content = inlineContent;
     if (filePath !== void 0) {
       try {
-        content = readFileSync5(filePath, "utf-8");
+        content = readFileSync6(filePath, "utf-8");
       } catch (e) {
         localFailures.push({ index, message: `\u6587\u4EF6\u8BFB\u53D6\u5931\u8D25: ${filePath}\uFF08${e instanceof Error ? e.message : String(e)}\uFF09` });
         continue;
@@ -1662,7 +1814,7 @@ async function handleArchNoteAddBatch(client, taskId, texts) {
 }
 
 // src/client/handlers/dag.ts
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 import { parse as parseYaml } from "yaml";
 import {
   BIZ_CODE_MESSAGES,
@@ -1884,13 +2036,13 @@ async function handleUpgradeApply(client, templateId, decisions) {
 
 // src/client/handlers/auth.ts
 import {
-  existsSync as existsSync6,
-  readFileSync as readFileSync7,
+  existsSync as existsSync7,
+  readFileSync as readFileSync8,
   writeFileSync as writeFileSync4,
   renameSync as renameSync3,
   mkdirSync as mkdirSync4
 } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { isAbsolute as isAbsolute2 } from "path";
 async function handleWhoami(client) {
   const res = await client.getJson("/api/auth/whoami");
@@ -1973,12 +2125,12 @@ function writeWorkspaceLayer(token, kind, opts) {
       hint: "\u5728\u9879\u76EE\u5DE5\u4F5C\u533A\u6839\u76EE\u5F55\uFF08\u542B .siming/\uFF09\u6267\u884C\uFF0C\u6216\u5148\u521B\u5EFA .siming/ \u76EE\u5F55\uFF1B\u7528\u6237\u7EA7\u5168\u5C40\u914D\u7F6E\u53EF\u52A0 --global\uFF08\u4EFB\u610F\u76EE\u5F55\u53EF\u5199\uFF09"
     });
   }
-  const devJsonPath = join5(dir, ".siming", "dev.json");
+  const devJsonPath = join6(dir, ".siming", "dev.json");
   let config = {};
   let hadIsolationKeys = false;
-  if (existsSync6(devJsonPath)) {
+  if (existsSync7(devJsonPath)) {
     try {
-      config = JSON.parse(readFileSync7(devJsonPath, "utf-8"));
+      config = JSON.parse(readFileSync8(devJsonPath, "utf-8"));
       hadIsolationKeys = "serverPort" in config || "dbPrefix" in config;
     } catch {
       return fail({
@@ -1997,7 +2149,7 @@ function writeWorkspaceLayer(token, kind, opts) {
     });
   }
   config.authToken = token;
-  mkdirSync4(join5(dir, ".siming"), { recursive: true });
+  mkdirSync4(join6(dir, ".siming"), { recursive: true });
   const tmp = `${devJsonPath}.tmp`;
   writeFileSync4(tmp, JSON.stringify(config, null, 2) + "\n", "utf-8");
   renameSync3(tmp, devJsonPath);
@@ -2739,7 +2891,7 @@ function createMcpServer() {
           let fullText = content;
           if (file) {
             try {
-              fullText = readFileSync8(file, "utf-8");
+              fullText = readFileSync9(file, "utf-8");
             } catch (e) {
               return localError(`\u6587\u4EF6\u8BFB\u53D6\u5931\u8D25: ${file}\uFF08${e instanceof Error ? e.message : String(e)}\uFF09`);
             }
@@ -2978,7 +3130,7 @@ async function mcpServeCommand() {
 
 // src/commands/task/command.ts
 import { Command as Command2 } from "commander";
-import { readFileSync as readFileSync10 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 import { z as z5 } from "zod";
 import {
   ARTIFACT_TYPES as ARTIFACT_TYPES3,
@@ -3092,7 +3244,7 @@ function renderResult(format, result, opts) {
 }
 
 // src/commands/opts.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 import "commander";
 import { z as z4 } from "zod";
 import { canonicalizeReferencePath, createReferencesSchema } from "@siming-org/core";
@@ -3147,7 +3299,7 @@ function parseRefFlags(refs, mainDocName) {
     seen.add(canonicalizeReferencePath(relPath));
     let content;
     try {
-      content = readFileSync9(localPath, "utf-8");
+      content = readFileSync10(localPath, "utf-8");
     } catch (e) {
       return fail({
         message: `--ref \u672C\u5730\u6587\u4EF6\u4E0D\u53EF\u8BFB\uFF1A"${localPath}"`,
@@ -3641,7 +3793,7 @@ function createTaskCommand() {
     let content;
     if (opts.file) {
       try {
-        content = readFileSync10(opts.file, "utf-8");
+        content = readFileSync11(opts.file, "utf-8");
       } catch (e) {
         renderResult(opts.format, fail({ message: `\u6587\u4EF6\u8BFB\u53D6\u5931\u8D25: ${opts.file}\uFF08${e instanceof Error ? e.message : String(e)}\uFF09`, httpStatus: 0 }));
         return;
@@ -3896,18 +4048,18 @@ import { Command as Command3 } from "commander";
 import { SKILL_MAIN_DOC, SkillScopeSchema } from "@siming-org/core";
 
 // src/client/scaffold-templates.ts
-import { existsSync as existsSync7, readdirSync, readFileSync as readFileSync11 } from "fs";
-import { dirname as dirname3, join as join6 } from "path";
+import { existsSync as existsSync8, readdirSync as readdirSync2, readFileSync as readFileSync12 } from "fs";
+import { dirname as dirname3, join as join7 } from "path";
 import { fileURLToPath } from "url";
-var SCAFFOLD_DIR = join6("templates", "project-skills");
+var SCAFFOLD_DIR = join7("templates", "project-skills");
 var KEBAB_CASE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
 function resolveCliPackageRoot() {
   let dir = dirname3(fileURLToPath(import.meta.url));
   for (let depth = 0; depth < 10; depth += 1) {
-    const pkgFile = join6(dir, "package.json");
-    if (existsSync7(pkgFile)) {
+    const pkgFile = join7(dir, "package.json");
+    if (existsSync8(pkgFile)) {
       try {
-        const pkg = JSON.parse(readFileSync11(pkgFile, "utf-8"));
+        const pkg = JSON.parse(readFileSync12(pkgFile, "utf-8"));
         if (pkg.name === "@siming-org/cli") return ok2(dir);
       } catch {
       }
@@ -3925,10 +4077,10 @@ function resolveCliPackageRoot() {
 function listScaffoldTemplates() {
   const root = resolveCliPackageRoot();
   if (!root.success) return root;
-  const dir = join6(root.data, SCAFFOLD_DIR);
+  const dir = join7(root.data, SCAFFOLD_DIR);
   let entries;
   try {
-    entries = readdirSync(dir);
+    entries = readdirSync2(dir);
   } catch {
     return fail({
       message: `\u9AA8\u67B6\u6A21\u677F\u76EE\u5F55\u7F3A\u5931\uFF1A${SCAFFOLD_DIR}`,
@@ -3987,7 +4139,7 @@ function loadScaffoldTemplate(name) {
   if (!root.success) return root;
   let text;
   try {
-    text = readFileSync11(join6(root.data, SCAFFOLD_DIR, `${name}.md`), "utf-8");
+    text = readFileSync12(join7(root.data, SCAFFOLD_DIR, `${name}.md`), "utf-8");
   } catch (e) {
     return fail({
       message: `\u9AA8\u67B6\u6587\u4EF6\u4E0D\u53EF\u8BFB\uFF1A${SCAFFOLD_DIR}/${name}.md`,
@@ -4809,7 +4961,7 @@ function agentFields(a) {
 }
 
 // src/commands/dag/command.ts
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync13 } from "fs";
 import { Command as Command5 } from "commander";
 function createDagCommand() {
   const dag = new Command5("dag").description("DAG template & instance management");
@@ -4867,7 +5019,7 @@ function createDagCommand() {
     const client = createClient(opts.url);
     let text;
     try {
-      text = readFileSync12(file, "utf-8");
+      text = readFileSync13(file, "utf-8");
     } catch (e) {
       renderResult("json", fail({
         message: `\u6587\u4EF6\u8BFB\u53D6\u5931\u8D25: ${file}\uFF08${e instanceof Error ? e.message : String(e)}\uFF09`,
@@ -5213,7 +5365,7 @@ function diffSummary(item) {
 }
 
 // src/commands/node/command.ts
-import { readFileSync as readFileSync13 } from "fs";
+import { readFileSync as readFileSync14 } from "fs";
 import { Command as Command6 } from "commander";
 import { SkillScopeSchema as SkillScopeSchema2 } from "@siming-org/core";
 
@@ -5451,7 +5603,7 @@ function createNodeCommand() {
     let prompt = opts.prompt ?? "";
     if (opts.promptFile !== void 0) {
       try {
-        prompt = readFileSync13(opts.promptFile, "utf-8");
+        prompt = readFileSync14(opts.promptFile, "utf-8");
       } catch (e) {
         renderResult("json", fail({
           message: `prompt \u6587\u4EF6\u8BFB\u53D6\u5931\u8D25: ${opts.promptFile}\uFF08${e instanceof Error ? e.message : String(e)}\uFF09`,
@@ -5496,7 +5648,7 @@ function createNodeCommand() {
     let prompt;
     if (opts.promptFile !== void 0) {
       try {
-        prompt = readFileSync13(opts.promptFile, "utf-8");
+        prompt = readFileSync14(opts.promptFile, "utf-8");
       } catch (e) {
         renderResult("json", fail({
           message: `prompt \u6587\u4EF6\u8BFB\u53D6\u5931\u8D25: ${opts.promptFile}\uFF08${e instanceof Error ? e.message : String(e)}\uFF09`,
@@ -5511,7 +5663,7 @@ function createNodeCommand() {
     if (opts.checksFile !== void 0) {
       let parsed;
       try {
-        parsed = JSON.parse(readFileSync13(opts.checksFile, "utf-8"));
+        parsed = JSON.parse(readFileSync14(opts.checksFile, "utf-8"));
       } catch (e) {
         renderResult("json", fail({
           message: `checks \u6587\u4EF6\u8BFB\u53D6/\u89E3\u6790\u5931\u8D25: ${opts.checksFile}\uFF08${e instanceof Error ? e.message : String(e)}\uFF09`,
@@ -5619,7 +5771,7 @@ function nodeFields2(n) {
 import { execFile as execFile2 } from "child_process";
 import { mkdtempSync, rmSync as rmSync2 } from "fs";
 import { tmpdir } from "os";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 import { promisify as promisify2 } from "util";
 import { createInterface } from "readline/promises";
 import { Command as Command7 } from "commander";
@@ -6061,7 +6213,7 @@ ${conflicts.map((item) => `  ${item.kind}:${item.key} \u2014 ${item.reason ?? "\
 async function fetchManifest(pkgSpec, registry) {
   let dir;
   try {
-    dir = mkdtempSync(join7(tmpdir(), "siming-flow-"));
+    dir = mkdtempSync(join8(tmpdir(), "siming-flow-"));
   } catch (error) {
     return fail({
       message: `\u4E34\u65F6\u76EE\u5F55\u521B\u5EFA\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`,
@@ -6098,7 +6250,7 @@ async function fetchManifest(pkgSpec, registry) {
     }
     const { stdout: manifestText } = await execFileAsync2(
       "tar",
-      ["-xOf", join7(dir, filename), "package/siming-nodes.json"],
+      ["-xOf", join8(dir, filename), "package/siming-nodes.json"],
       { maxBuffer: MANIFEST_LIMITS.maxChars * 2 + 64 * 1024 }
     );
     const parsed = parseFlowManifest(manifestText);
@@ -6969,7 +7121,7 @@ function createProjectCommand() {
     const result = await handleGetProject(client, id);
     renderResult(opts.format, result, { fields: result.success ? projectFields(result.data) : [] });
   });
-  project.command("update <id>").description("Update a project (name/description/status/vcs gate config). vcs is replaced as a whole: any --vcs-* flag replaces the entire vcs object with only the provided fields").option("--url <url>", "server base URL").option("--name <name>", "new name").option("--description <text>", "new description").option("--vcs-enabled <bool>", "gate VCS checks for this project (true/false; false=all git checks N/A)").option("--vcs-repo-path <path>", "repository absolute path (default: MCP host cwd probing)").option("--vcs-base-branch <branch>", "base branch (2nd level of the base-branch resolution chain)").option("--vcs-branch-pattern <pattern>", "task branch prefix pattern for A1").option("--vcs-worktree-mode <bool>", "worktree parallel mode (true=A6 stay-on-base N/A)").option("--vcs-archive-to-base <bool>", "project declares merge-back-to-base archive flow (false=A5 N/A)").option("--vcs-doc-paths <paths>", "B7 exemption paths, comma separated (dirs need trailing /, glob like *.md)").action(async (id, opts) => {
+  project.command("update <id>").description("Update a project (name/description/status/vcs gate config). vcs is replaced as a whole: any --vcs-* flag replaces the entire vcs object with only the provided fields").option("--url <url>", "server base URL").option("--name <name>", "new name").option("--description <text>", "new description").option("--vcs-enabled <bool>", "gate VCS checks for this project (true/false; false=all git checks N/A)").option("--vcs-repo-path <path>", "[deprecated] no longer read by gate resolution \u2014 task repos are discovered by scanning the working directory (T202610080003); flag kept writable for DB compatibility only").option("--vcs-base-branch <branch>", "base branch (2nd level of the base-branch resolution chain)").option("--vcs-branch-pattern <pattern>", "task branch prefix pattern for A1").option("--vcs-worktree-mode <bool>", "worktree parallel mode (true=A6 stay-on-base N/A)").option("--vcs-archive-to-base <bool>", "project declares merge-back-to-base archive flow (false=A5 N/A)").option("--vcs-doc-paths <paths>", "B7 exemption paths, comma separated (dirs need trailing /, glob like *.md)").action(async (id, opts) => {
     const client = createClient(opts.url);
     const parseBool = (v, flag) => {
       if (v === void 0) return void 0;
@@ -6993,6 +7145,7 @@ function createProjectCommand() {
       vcsProvided = true;
     }
     if (opts.vcsRepoPath !== void 0) {
+      console.error(`[siming] deprecated: --vcs-repo-path \u5DF2\u9000\u5F79\u2014\u2014\u95E8\u7981\u4EFB\u52A1\u4ED3\u96C6\u5408 = \u5DE5\u4F5C\u76EE\u5F55\u626B\u63CF\u5168\u91CF\uFF08cwd + \u2264scanDepth \u5B50\u76EE\u5F55\uFF09\uFF0C\u8BE5\u5B57\u6BB5\u4E0D\u518D\u5F71\u54CD\u5224\u5B9A\uFF1BscanDepth \u53EF\u7ECF <\u5DE5\u4F5C\u76EE\u5F55>/.siming/dev.json \u914D\u7F6E\uFF08\u9ED8\u8BA4 1\uFF0C\u94B3\u5236 \u22643\uFF09`);
       vcsFields.repoPath = opts.vcsRepoPath;
       vcsProvided = true;
     }
@@ -7201,7 +7354,7 @@ function createConfigCommand() {
 
 // src/commands/export/command.ts
 import { Command as Command11 } from "commander";
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync15 } from "fs";
 import { parse as parseYaml2 } from "yaml";
 
 // src/client/handlers/export.ts
@@ -7872,7 +8025,7 @@ function createExportCommand() {
 async function runExportPlan(client, filePath, typesArg) {
   let raw;
   try {
-    const text = readFileSync14(filePath, "utf-8");
+    const text = readFileSync15(filePath, "utf-8");
     raw = parseYaml2(text);
   } catch (e) {
     return fail({
@@ -7897,7 +8050,7 @@ async function runExportPlan(client, filePath, typesArg) {
 }
 function loadPlanFile(path) {
   try {
-    const text = readFileSync14(path, "utf-8");
+    const text = readFileSync15(path, "utf-8");
     const parsed = JSON.parse(text);
     if (!Array.isArray(parsed.items)) {
       return fail({ message: `\u8BA1\u5212\u6587\u4EF6\u7ED3\u6784\u65E0\u6548\uFF1A\u7F3A\u5C11 items \u6570\u7EC4`, httpStatus: 0, hint: "\u8BA1\u5212\u6587\u4EF6\u7531 `siming export plan --format json > plan.json` \u751F\u6210" });
@@ -7960,14 +8113,14 @@ function renderReport(report, format) {
 
 // src/commands/install/command.ts
 import { Command as Command12 } from "commander";
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { createInterface as createInterface2 } from "readline/promises";
-import { dirname as dirname5, join as join9 } from "path";
+import { dirname as dirname5, join as join10 } from "path";
 import { AGENT_MAIN_DOC as AGENT_MAIN_DOC5, SKILL_MAIN_DOC as SKILL_MAIN_DOC5, VERSION as VERSION3 } from "@siming-org/core";
 
 // src/commands/install/writer.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync15, renameSync as renameSync4, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname4, join as join8 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync16, renameSync as renameSync4, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname4, join as join9 } from "path";
 import { homedir as homedir4 } from "os";
 import { parse as parseYaml3, stringify as stringifyYaml } from "yaml";
 import {
@@ -7978,12 +8131,12 @@ import {
 } from "@siming-org/core";
 function agentsHomeDir() {
   const env = process.env.SIMING_AGENTS_HOME;
-  return env && env.length > 0 ? env : join8(homedir4(), ".agents");
+  return env && env.length > 0 ? env : join9(homedir4(), ".agents");
 }
 function resolveInstallTargets(scope, workspaceDir) {
   if (scope === "global") {
     const dir = agentsHomeDir();
-    return { targets: { dir, mcpConfigPath: join8(dir, "mcp.json") } };
+    return { targets: { dir, mcpConfigPath: join9(dir, "mcp.json") } };
   }
   const wd = workspaceDir ?? findWorkspaceDir();
   if (!wd) {
@@ -7991,7 +8144,7 @@ function resolveInstallTargets(scope, workspaceDir) {
       error: "scope=project \u9700\u8981\u5DE5\u4F5C\u533A\uFF08.siming/ \u76EE\u5F55\uFF09\u2014\u2014\u5148\u8FD0\u884C `siming init --project <key|id>` \u7ED1\u5B9A\u9879\u76EE\uFF0C\u6216\u5728\u9879\u76EE\u76EE\u5F55\u5185\u6267\u884C"
     };
   }
-  return { targets: { dir: join8(wd, ".agents"), mcpConfigPath: null } };
+  return { targets: { dir: join9(wd, ".agents"), mcpConfigPath: null } };
 }
 function isSafeAssetName(name) {
   if (name.length === 0 || name === "." || name === "..") return false;
@@ -8011,7 +8164,7 @@ function validateReferencesLocally(mainDocName, references) {
 function writeAssetDirectory(assetDir, files) {
   rmSync3(assetDir, { recursive: true, force: true });
   for (const file of files) {
-    const target = join8(assetDir, ...file.relPath.split("/"));
+    const target = join9(assetDir, ...file.relPath.split("/"));
     mkdirSync5(dirname4(target), { recursive: true });
     writeFileSync5(target, file.content, "utf-8");
   }
@@ -8028,7 +8181,7 @@ ${skill.content}
 `;
 }
 function skillTargetPath(dir, skill) {
-  return join8(dir, "skills", skill.name, "SKILL.md");
+  return join9(dir, "skills", skill.name, "SKILL.md");
 }
 function permissionsToMatrix(permissions) {
   const matrix = {};
@@ -8064,13 +8217,13 @@ ${agent.systemPrompt}
 `;
 }
 function agentTargetPath(dir, agent) {
-  return join8(dir, "agents", agent.name, "agent.md");
+  return join9(dir, "agents", agent.name, "agent.md");
 }
 function readSimingVersion(path) {
-  if (!existsSync8(path)) return null;
+  if (!existsSync9(path)) return null;
   let text;
   try {
-    text = readFileSync15(path, "utf-8");
+    text = readFileSync16(path, "utf-8");
   } catch {
     return null;
   }
@@ -8092,10 +8245,10 @@ function isPlainObject(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function readMcpConfig(path) {
-  if (!existsSync8(path)) return { state: "absent" };
+  if (!existsSync9(path)) return { state: "absent" };
   let text;
   try {
-    text = readFileSync15(path, "utf-8");
+    text = readFileSync16(path, "utf-8");
   } catch (e) {
     return { state: "corrupt", error: `\u8BFB\u53D6\u5931\u8D25: ${e instanceof Error ? e.message : String(e)}` };
   }
@@ -8332,7 +8485,7 @@ function compareSkill(s, dir) {
   if (!isSafeAssetName(s.name)) {
     return { ...base, action: "conflict", reason: `unsafe asset name "${s.name}"` };
   }
-  if (!existsSync9(path)) return { ...base, action: "install", reason: "not installed locally" };
+  if (!existsSync10(path)) return { ...base, action: "install", reason: "not installed locally" };
   const marked = readSimingVersion(path);
   if (marked === null) {
     return { ...base, localVersion: "unknown", action: "conflict", reason: "no siming-version marker (third-party asset; use --force to overwrite)" };
@@ -8350,7 +8503,7 @@ function compareAgent(a, dir) {
   if (!isSafeAssetName(a.name)) {
     return { ...base, action: "conflict", reason: `unsafe asset name "${a.name}"` };
   }
-  if (!existsSync9(path)) return { ...base, action: "install", reason: "not installed locally" };
+  if (!existsSync10(path)) return { ...base, action: "install", reason: "not installed locally" };
   const marked = readSimingVersion(path);
   if (marked === null) {
     return { ...base, localVersion: "unknown", action: "conflict", reason: "no siming-version marker (third-party asset; use --force to overwrite)" };
@@ -8443,7 +8596,7 @@ async function applyInstall(client, scope, projectId, items, opts) {
           results.push({ name: item.name, type: "skill", action: "failed", reason: `invalid reference doc from server: ${invalidRef}`, hint: "\u5F15\u7528\u6587\u6863\u975E\u6CD5\uFF08\u6570\u636E\u53EF\u80FD\u88AB\u7ED5\u8FC7\u6821\u9A8C\u5199\u5165\uFF09\uFF1B\u4FEE\u6B63 server \u6570\u636E\u540E\u91CD\u8BD5\uFF0C\u672C\u6761\u672A\u5199\u5165" });
           continue;
         }
-        const targetExists = existsSync9(targetPath);
+        const targetExists = existsSync10(targetPath);
         writeAssetDirectory(dirname5(targetPath), [
           { relPath: SKILL_MAIN_DOC5, content: skillToMarkdown(r.data) },
           ...(r.data.references ?? []).map((ref) => ({ relPath: ref.path, content: ref.content }))
@@ -8479,7 +8632,7 @@ async function applyInstall(client, scope, projectId, items, opts) {
           results.push({ name: item.name, type: "agent", action: "failed", reason: `invalid reference doc from server: ${invalidRef}`, hint: "\u5F15\u7528\u6587\u6863\u975E\u6CD5\uFF08\u6570\u636E\u53EF\u80FD\u88AB\u7ED5\u8FC7\u6821\u9A8C\u5199\u5165\uFF09\uFF1B\u4FEE\u6B63 server \u6570\u636E\u540E\u91CD\u8BD5\uFF0C\u672C\u6761\u672A\u5199\u5165" });
           continue;
         }
-        const targetExists = existsSync9(targetPath);
+        const targetExists = existsSync10(targetPath);
         writeAssetDirectory(dirname5(targetPath), [
           { relPath: AGENT_MAIN_DOC5, content: agentToMarkdown(r.data, realModel) },
           ...(r.data.references ?? []).map((ref) => ({ relPath: ref.path, content: ref.content }))
@@ -8503,8 +8656,8 @@ function buildInstallGuidance(scope, targets) {
   const lines = [];
   lines.push("\u2500\u2500 siming \u901A\u7528\u8D44\u4EA7\u8FC1\u79FB\u6307\u5F15\uFF08.agents \u5F00\u653E\u534F\u8BAE\u843D\u70B9\uFF09\u2500\u2500");
   lines.push(`[1] \u8D44\u4EA7\u4F4D\u7F6E\uFF08${scope === "global" ? "\u7528\u6237\u7EA7" : "\u9879\u76EE\u7EA7"} ${targets.dir}\uFF09\uFF1A`);
-  lines.push(`    - skills: ${join9(targets.dir, "skills")}\uFF08\u6BCF\u4E2A skill \u4E00\u4E2A\u5B50\u76EE\u5F55\uFF0C\u542B SKILL.md \u4E0E\u5176\u5F15\u7528\u6587\u6863\uFF09`);
-  lines.push(`    - agents: ${join9(targets.dir, "agents")}\uFF08\u6BCF\u4E2A agent \u4E00\u4E2A\u5B50\u76EE\u5F55\uFF0C\u542B agent.md \u4E0E\u5176\u5F15\u7528\u6587\u6863\uFF09`);
+  lines.push(`    - skills: ${join10(targets.dir, "skills")}\uFF08\u6BCF\u4E2A skill \u4E00\u4E2A\u5B50\u76EE\u5F55\uFF0C\u542B SKILL.md \u4E0E\u5176\u5F15\u7528\u6587\u6863\uFF09`);
+  lines.push(`    - agents: ${join10(targets.dir, "agents")}\uFF08\u6BCF\u4E2A agent \u4E00\u4E2A\u5B50\u76EE\u5F55\uFF0C\u542B agent.md \u4E0E\u5176\u5F15\u7528\u6587\u6863\uFF09`);
   if (targets.mcpConfigPath) {
     lines.push(`    - MCP \u6CE8\u518C: ${targets.mcpConfigPath}\uFF08\u9876\u5C42 mcpServers.siming \u2192 stdio \u547D\u4EE4 "siming mcp-serve"\uFF09`);
   }
@@ -8890,7 +9043,8 @@ ${ROADMAP_TEXT}
 
 \u6D41\u7A0B\u6A21\u677F\u7684\u8282\u70B9\u63D0\u793A\u8BCD\u4E2D\uFF0C\u73AF\u5883\u76F8\u5173\u4FE1\u606F\u5168\u90E8\u53C2\u6570\u5316\u4E3A\u300C\u6309\u9879\u76EE\u58F0\u660E\u300D\uFF0C
 \u58F0\u660E\u503C\u843D\u70B9 = \u9879\u76EE\u4ED3\u5E93\u7684 AI \u5165\u53E3\u6587\u4EF6\uFF08\u9879\u76EE AGENTS.md\uFF09\u3002
-\u4EE5\u4E0B 8 \u9879\u58F0\u660E\u4E0D\u9F50\u65F6\uFF0C\u6D41\u7A0B\u4F1A\u5728\u5BF9\u5E94\u73AF\u8282\u6682\u505C\u8BE2\u95EE\u6216\u964D\u7EA7\uFF1A
+\u4EE5\u4E0B 9 \u9879\u4E2D 1-8 \u4E3A\u73AF\u5883\u58F0\u660E\uFF0C\u4E0D\u9F50\u65F6\u6D41\u7A0B\u4F1A\u5728\u5BF9\u5E94\u73AF\u8282\u6682\u505C\u8BE2\u95EE\u6216\u964D\u7EA7\uFF1B
+\u7B2C 9 \u9879\u4E3A\u884C\u4E3A\u89C4\u5219\u91CD\u63D0\u793A\uFF08\u89C1\u8868\u683C\u540E\u8BF4\u660E\uFF09\uFF1A
 
 | # | \u58F0\u660E\u9879 | \u58F0\u660E\u5185\u5BB9 | \u7F3A\u5931\u540E\u679C |
 |---|--------|----------|----------|
@@ -8902,6 +9056,10 @@ ${ROADMAP_TEXT}
 | 6 | E2E \u552F\u4E00\u6267\u884C\u5165\u53E3 | E2E \u6D4B\u8BD5\u552F\u4E00\u5408\u6CD5\u7684\u6267\u884C\u547D\u4EE4/\u811A\u672C | E2E \u5F00\u53D1\u73AF\u8282\u65E0\u6CD5\u786E\u5B9A\u6267\u884C\u65B9\u5F0F\uFF0C\u6682\u505C\u8BE2\u95EE |
 | 7 | \u6D4B\u8BD5\u5B8C\u6574\u6027\u68C0\u67E5 | \u9632\u5220\u6D4B/\u7981 skip \u7684\u9759\u6001\u68C0\u67E5\u547D\u4EE4 | \u6D4B\u8BD5\u6536\u5C3E\u7F3A\u5C11\u95E8\u7981\u4F9D\u636E\uFF0C\u6682\u505C\u8BE2\u95EE |
 | 8 | \u547D\u4EE4\u65E5\u5FD7\u843D\u76D8 | \u6784\u5EFA/\u6D4B\u8BD5\u547D\u4EE4\u7684\u65E5\u5FD7\u5F52\u6863\u7EA6\u5B9A | \u547D\u4EE4\u6267\u884C\u65E0\u6CD5\u56DE\u6EAF\uFF0C\u5F52\u6863\u8282\u70B9\u8BC1\u636E\u4E0D\u8DB3 |
+| 9 | \u590D\u5BA1\u59D4\u6D3E\u89C4\u5219 | \u591A\u8F6E\u590D\u5BA1\u4F18\u5148\u540C\u4E00 reviewer \u4F1A\u8BDD\u7EED\u804A\uFF1B\u6362\u65B0\u4F1A\u8BDD\u65F6\u968F\u9644\u4E0A\u8F6E Findings \u4E0E\u5904\u7F6E\u72B6\u6001\uFF08\u8868\u8FF0\u5BF9\u9F50 workflow-discipline\u300C\u59D4\u6D3E\u7EAA\u5F8B\u300D\uFF09 | \u591A\u8F6E\u8BC4\u5BA1\u9000\u5316\u4E3A\u6BCF\u8F6E\u5168\u65B0\u5168\u91CF\u8BC4\u5BA1\uFF0C\u91CD\u590D\u6D88\u8017\u65F6\u95F4\u4E0E token |
+
+\u7B2C 9 \u9879\u4E3A\u884C\u4E3A\u89C4\u5219\u91CD\u63D0\u793A\uFF1A\u6743\u5A01\u6E90\u662F workflow-discipline \u59D4\u6D3E\u7EAA\u5F8B\uFF08\u8282\u70B9\u52A0\u8F7D\uFF09\uFF0C
+\u5728\u9879\u76EE AGENTS.md \u91CD\u590D\u5199\u5165\u53EF\u63D0\u9AD8\u8DE8\u5BBF\u4E3B\u9075\u5FAA\u7387\uFF08\u5E38\u9A7B\u5165\u53E3\u5148\u4E8E\u8282\u70B9\u52A0\u8F7D\u751F\u6548\uFF09\u3002
 
 ----------------------------------------------------------------
 \u4E8C\u3001\u6D41\u7A0B\u6A21\u677F\u83B7\u53D6\u6307\u5F15
@@ -9038,7 +9196,7 @@ async function handleUpdateEnums(client, category, body) {
 // src/commands/settings/command.ts
 function createSettingsCommand() {
   const settings = new Command16("settings").description("Settings (enum registries)");
-  withCommonOpts(settings.command("enums [category]"), "fancy").description("Show enum registry (all 7 categories, or one category)").action(async (category, opts) => {
+  withCommonOpts(settings.command("enums [category]"), "fancy").description("Show enum registry (all categories, or one category)").action(async (category, opts) => {
     const client = createClient(opts.url);
     const catR = category ? EnumRegistryCategorySchema.safeParse(category) : null;
     if (category && !catR?.success) {
@@ -9092,8 +9250,8 @@ import { VERSION as VERSION4, SIMING_CONFIG_KEYS as SIMING_CONFIG_KEYS2 } from "
 
 // src/commands/server/daemon.ts
 import { execFileSync } from "child_process";
-import { closeSync, existsSync as existsSync10, lstatSync, mkdirSync as mkdirSync6, openSync, readFileSync as readFileSync16, renameSync as renameSync5, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "fs";
-import { join as join10, resolve as resolve2 } from "path";
+import { closeSync, existsSync as existsSync11, lstatSync, mkdirSync as mkdirSync6, openSync, readFileSync as readFileSync17, renameSync as renameSync5, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "fs";
+import { join as join11, resolve as resolve2 } from "path";
 import { spawn } from "child_process";
 
 // src/commands/server/probe.ts
@@ -9110,10 +9268,10 @@ function runtimeDir() {
   return process.env.SIMING_RUNTIME_DIR ?? "/tmp/siming";
 }
 function pidfilePath() {
-  return join10(runtimeDir(), "server.pid");
+  return join11(runtimeDir(), "server.pid");
 }
 function logfilePath() {
-  return join10(runtimeDir(), "server.log");
+  return join11(runtimeDir(), "server.log");
 }
 var READY_TIMEOUT_MS = 2e4;
 var STOP_GRACE_MS = 1e4;
@@ -9146,7 +9304,7 @@ function readPidFile() {
   try {
     const st = lstatSync(pidfilePath(), { throwIfNoEntry: false });
     if (st === void 0 || st.isSymbolicLink()) return null;
-    const parsed = JSON.parse(readFileSync16(pidfilePath(), "utf-8").trim());
+    const parsed = JSON.parse(readFileSync17(pidfilePath(), "utf-8").trim());
     if (typeof parsed.pid !== "number" || typeof parsed.startedAt !== "number" || typeof parsed.port !== "number") {
       return null;
     }
@@ -9187,7 +9345,7 @@ function removePidFile(expectedPid) {
 }
 function readCmdline(pid) {
   try {
-    const raw = readFileSync16(`/proc/${pid}/cmdline`);
+    const raw = readFileSync17(`/proc/${pid}/cmdline`);
     const joined = raw.toString().split("\0").filter((s) => s.length > 0).join(" ");
     if (joined.length > 0) return joined;
   } catch {
@@ -9216,7 +9374,7 @@ function isSimingDaemonCmdline(cmdline, expectedEntry) {
 }
 function readProcessStartMs(pid) {
   try {
-    const stat = readFileSync16(`/proc/${pid}/stat`, "utf-8");
+    const stat = readFileSync17(`/proc/${pid}/stat`, "utf-8");
     const rest = stat.slice(stat.lastIndexOf(")") + 2);
     const fields = rest.split(" ");
     const starttimeJiffies = Number(fields[19]);
@@ -9245,7 +9403,7 @@ function readProcessStartMs(pid) {
 }
 function readBtimeFromProcStat() {
   try {
-    const stat = readFileSync16("/proc/stat", "utf-8");
+    const stat = readFileSync17("/proc/stat", "utf-8");
     for (const line of stat.split("\n")) {
       if (line.startsWith("btime ")) {
         const v = Number(line.slice(6).trim());
@@ -9296,14 +9454,14 @@ function sleep(ms) {
 function readLogTail(lines = 30) {
   const st = lstatSync(logfilePath(), { throwIfNoEntry: false });
   if (st === void 0 || st.isSymbolicLink()) return null;
-  const content = readFileSync16(logfilePath(), "utf-8");
+  const content = readFileSync17(logfilePath(), "utf-8");
   const all = content.split("\n");
   if (all.at(-1) === "") all.pop();
   return all.slice(-lines);
 }
 function spawnDaemon(configEnv) {
   const entry = resolve2(process.argv[1] ?? "");
-  if (entry.length === 0 || !existsSync10(entry)) {
+  if (entry.length === 0 || !existsSync11(entry)) {
     throw new Error(`\u65E0\u6CD5\u5B9A\u4F4D siming \u5165\u53E3\u811A\u672C\uFF08process.argv[1]=${process.argv[1] ?? "(\u7A7A)"}\uFF09`);
   }
   if (entry.endsWith(".ts")) {