sillyspec 3.28.9 → 3.28.10

package/src/run/prompt.js

@@ -316,6 +316,68 @@ export function buildKnowledgeInjection({ knowledgeDir, runtimeDir, change, quer
 
 // parseModuleMapSimple 复用 modules.js 的 canonical 实现（合并历史 copy-paste 副本，2026-08-07；
 // 无循环依赖：modules.js 仅 import fs/path/db.js，prompt.js → modules.js 单向）。
+
+/**
+ * 等效验证先例库（坑 verify-precedent-only-in-prose，2026-09-15 EHS 生产实证：mvn test 被
+ * 公司框架 parent pom pluginManagement 硬编码 surefire skip=true、-D 覆盖无效——等效口径
+ * dependency:build-classpath+javac+JUnitCore 第二次复用靠 agent 翻旧 verify-result.md 正文
+ * 续命；先例只活在散文里 = 换个 agent/换个变更就断档）。结构化登记进 local.yaml
+ * verify_precedents 段，verify prompt 时点注入提示（与 test_strategy 预检提示同挂点）。
+ *
+ * 对象数组形态（行扫描，同 extractKnownFailures 免 YAML 依赖口径——注释/空行/块界容错）：
+ *   verify_precedents:
+ *     - id: mvn-test-surefire-skip
+ *       standard_command: mvn test
+ *       reason: <标准命令为何不可用>
+ *       equivalent: <已验证的等效口径>
+ *       established_by: <确立该口径的变更名>
+ *       notes: <可选补充>
+ * 残项（standard_command 与 equivalent 双缺）过滤——登记不完整的先例没有可执行口径。
+ * @param {string|null} yamlText local.yaml 全文
+ * @returns {Array<object>} 先例对象数组
+ */
+export function parseVerifyPrecedents(yamlText) {
+  const lines = String(yamlText || '').split(/\r?\n/)
+  const headIdx = lines.findIndex(l => /^verify_precedents:\s*(?:#.*)?$/.test(l))
+  if (headIdx < 0) return []
+  const items = []
+  let cur = null
+  const clean = (v) => String(v || '').replace(/\s+#.*$/, '').trim()
+  for (let i = headIdx + 1; i < lines.length; i++) {
+    const l = lines[i]
+    if (/^\S/.test(l)) break // 下一个顶层键 → 块结束
+    if (!l.trim() || /^\s*#/.test(l)) continue
+    const item = l.match(/^\s*-\s+([A-Za-z_][\w-]*):\s*(.*)$/)
+    if (item) {
+      cur = {}
+      items.push(cur)
+      cur[item[1]] = clean(item[2])
+      continue
+    }
+    const kv = l.match(/^\s*([A-Za-z_][\w-]*):\s*(.*)$/)
+    if (kv && cur) cur[kv[1]] = clean(kv[2])
+  }
+  return items.filter(x => x && (x.standard_command || x.equivalent))
+}
+
+/**
+ * 先例提示渲染（verify prompt 注入用；空输入 → ''，调用方零输出）。
+ * 行动指引刻意指向「把等效命令配进 commands.test 照常全量实测对账」而非 test_strategy: skip
+ * 放行——EHS 实证里被环境阻断 deferred 的集成测试正是 P1 缺陷藏身处，能实测就实测。
+ * @param {Array<object>|null} precedents
+ * @returns {string}
+ */
+export function renderVerifyPrecedentHint(precedents) {
+  if (!Array.isArray(precedents) || precedents.length === 0) return ''
+  const L = [`【验证先例提示】本仓已登记 ${precedents.length} 条等效验证先例（标准命令不可用时的既有替代口径）：`]
+  for (const p of precedents.slice(0, 5)) {
+    L.push(`- ${p.id || '（无 id）'}：\`${p.standard_command || '?'}\` 不可用（${p.reason || '原因未注'}）→ 等效口径 \`${p.equivalent || '?'}\`（确立于 ${p.established_by || '?'}${p.notes ? `；${p.notes}` : ''}）`)
+  }
+  if (precedents.length > 5) L.push(`- …另有 ${precedents.length - 5} 条未展开（读 local.yaml verify_precedents 段看全量）`)
+  L.push('适用时把等效命令配进 local.yaml commands.test（或 modules.<m>.test）后照常全量实测对账，而不是只靠 test_strategy: skip 放行；先例不适用（环境已变/口径失效）可忽略并在 verify-result 注记。')
+  return L.join('\n')
+}
+
 /**
  * 提示词路径根的单一解析：specRoot(平台) > specDriftAnchor(worktree 漂移锚定主仓) > cwd/.sillyspec(本地)。
  * 治 execute review.json 提示路径写 worktree 副本、--done 校验读主仓的分裂（坑 execute-prompt-spec-drift）：
@@ -1129,13 +1191,14 @@ export async function outputStep(stageName, stepIndex, steps, cwd, changeName, d
   // 推荐组合、无从否决——故在 prompt 时点经 {EVIDENCE_AUTO_RECOMMENDATION} 把 task-11
   // resolveTestStrategy 的 evidence_auto_recommendation.summary 渲染进 step prompt（含推荐
   // 理由、降级注记与「可在 verify-result.md 否决并改跑全量」路径），供用户否决（FR-11）。
-  // 仅 test_strategy=evidence-auto 且 recommendation 非空时渲染；full/module/skip/未配置
-  // （recommendation=null）替换为空串零输出。fail-soft：读取/解析异常降级单行说明不抛，
+  // 仅 test_strategy=evidence-auto 且 recommendation 非空时渲染推荐；full/module/skip/已配置
+  // 替换为空串零输出；**未配置**且 commands.test 已配时渲染 test_strategy 预检提示（2026-09-15
+  // 复盘：环境硬伤的全量实测打回返工，提前在 prompt 时点给配置指引）。fail-soft：读取/解析异常降级单行说明不抛，
   // 绝不阻断 verify prompt 输出（对齐上方 {WORKTREE_BASELINE_INFO} 注入先例）。
   if (stageName === 'verify' && promptText.includes('{EVIDENCE_AUTO_RECOMMENDATION}')) {
     let eaInjected = ''
     try {
-      const { resolveTestStrategy } = await import('../verify-postcheck.js')
+      const { resolveTestStrategy, extractTestCommand, extractTestStrategy } = await import('../verify-postcheck.js')
       const eaSpecBase = resolvePromptSpecBase(platformOpts, cwd)
       // 信任边界：local.yaml 只读 specBase（平台 specRoot / 漂移锚定主仓 / cwd 本地），与
       // runVerifyTestCheck 的 specBase 来源同口径，不读 agent 可写的 worktree 副本。
@@ -1144,7 +1207,20 @@ export async function outputStep(stageName, stepIndex, steps, cwd, changeName, d
       const eaChangeDir = changeName ? join(eaSpecBase, 'changes', changeName) : null
       const resolution = resolveTestStrategy({ yamlText: eaYamlText, changeDir: eaChangeDir })
       const rec = resolution.evidence_auto_recommendation
-      if (rec && rec.summary) eaInjected = rec.summary
+      if (rec && rec.summary) {
+        eaInjected = rec.summary
+      } else if (eaYamlText && extractTestCommand(eaYamlText) && !extractTestStrategy(eaYamlText)) {
+        // test_strategy 预检提示（2026-09-15 复盘教训「test_strategy 该在进 verify 前配好，
+        // 而不是被 verify-test gate 打回后才补」）：已配 commands.test 但顶层 test_strategy
+        // 未设（缺省=全量实测对账），prompt 时点先给配置指引——环境注定跑不了全量时省一轮
+        // 「--done 实测打回 → 补配置 → 重跑」返工
+        eaInjected = '【test_strategy 预检提示】local.yaml 已配置 commands.test 但未设顶层 test_strategy（缺省=全量实测对账）。若该命令在当前环境无法真实执行（框架/环境硬伤，如测试框架硬编码 skip、依赖外部服务），先在 local.yaml 显式配 `test_strategy: skip`（或 `module` + modules 映射收窄）并注释理由再继续——避免 verify --done 实测对账打回后返工。'
+      }
+      // 等效验证先例注入（verify-precedent-only-in-prose，2026-09-15 EHS 实证）：先例与
+      // 预检提示同挂点追加——标准命令不可用但已有验证过的等效口径时，指引优先配进
+      // commands.test 实测对账而非 skip 放行。
+      const _precHint = renderVerifyPrecedentHint(parseVerifyPrecedents(eaYamlText))
+      if (_precHint) eaInjected = eaInjected ? `${eaInjected}\n\n${_precHint}` : _precHint
     } catch (e) {
       eaInjected = `（evidence-auto 推荐注入失败：${e.message}——请读 .sillyspec/local.yaml 确认 test_strategy；--done 时 CLI 仍会按 resolveTestStrategy 实测对账，推荐不可用时可显式设 test_strategy: full/module）`
     }
@@ -1352,10 +1428,15 @@ export async function outputStep(stageName, stepIndex, steps, cwd, changeName, d
   // archive-batch-31-tool-notes ②：通用 --done 模板不带该 flag，agent 照抄执行撞
   // 「请添加 --confirm」确认门，误以为参数没带。
   const confirmFlag = step.requiresConfirm === true ? ' --confirm' : ''
-  // auto driver（2026-09-08-auto-driver D-002/P1-③）：auto 模式下命令一律 run auto 形态——
+  // auto driver（2026-09-08-auto-driver D-002/P1-Ⅲ）：auto 模式下命令一律 run auto 形态——
   // 与 SS-META 的 doneCommand 同源（同一 cmdStage 变量），消灭「正文 run <stage> / 元数据 run auto」双命令
   const cmdStage = autoMeta ? 'auto' : stageName
-  const doneCommand = `sillyspec run ${cmdStage} --done${confirmFlag}${changeFlag} --output "你的摘要"`
+  // 意图断言（坑 execute-concurrent-done-skips-next-wave 终解）：execute 的 Wave 步骤是动态
+  // 步骤表，并发 --done 会落到错误 Wave 且用旧摘要静默完成——完成命令带 --step "<本步名>"
+  //（CLI 校验一致才放行），照抄命令即得并发防护。仅 execute 注入（quick/静态阶段测试断言
+  // 提示格式，且静态步骤名稳定无漂移风险）。
+  const stepAssertFlag = (stageName === 'execute' && step?.name) ? ` --step "${step.name}"` : ''
+  const doneCommand = `sillyspec run ${cmdStage} --done${confirmFlag}${stepAssertFlag}${changeFlag} --output "你的摘要"`
   if (requiresWait) {
     console.log(`本步骤必须等待用户输入，不能直接 --done：`)
     console.log(`sillyspec run ${cmdStage} --wait --reason "${step.waitReason || '等待用户输入'}" --options "${(step.waitOptions || ['确认']).join(',')}"${changeFlag} --output "你的问题/方案摘要"`)

package/src/run/shared.js

@@ -635,6 +635,71 @@ export function checkPlatformManaged(cwd) {
   }
 }
 
+/**
+ * 平台模式产物落点指针（坑 platform-docs-dual-location，2026-09-15 EHS 生产实证：
+ * 变更 9 文档落 daemon specs 目录，工作树 .sillyspec/ 只剩旧变更残留、worktree 无
+ * .sillyspec——人类在工作树里找变更文档扑空，只有平台 changes files API 能读，双位置
+ * 造成「文件去哪了」困惑）。阶段 --done 完成时在工作树 .sillyspec/ 落一份人类可读指针
+ * PLATFORM-DOCS-POINTER.md：specRoot/runtimeRoot 物理路径 + workspaceId + 本变更文档
+ * 清单（.md 文件名+mtime + tasks/ 计数）+ 获取方式提示。
+ *
+ * 口径与 writePlatformPointer 三写同款豁免：本地模式（无 specRoot/runtimeRoot）零行为；
+ * 自指回环（repo-native junction 指回 cwd/.sillyspec）不写；temp 残留形态（specRoot 在
+ * 系统 temp 而项目不在）不写。fail-soft：任何写失败只 warn 不抛（对齐 user-inputs.md
+ * 追加先例）——指针是便利件，绝不阻断阶段完成。
+ *
+ * @param {string} cwd 项目根（指针落 cwd/.sillyspec/）
+ * @param {string|null} changeName 变更名（可空——无变更上下文时只写根路径头部）
+ * @param {{specRoot?: string|null, runtimeRoot?: string|null, workspaceId?: string|null}} [platformOpts]
+ * @param {string|null} [stageName] 触发阶段（展示用）
+ * @returns {{written: boolean, reason?: string, path?: string, error?: string}}
+ */
+export function writePlatformDocsPointer(cwd, changeName, platformOpts = {}, stageName = null) {
+  try {
+    const specRoot = platformOpts?.specRoot || null
+    const runtimeRoot = platformOpts?.runtimeRoot || null
+    if (!specRoot && !runtimeRoot) return { written: false, reason: 'local-mode' }
+    if (specRoot && isSelfReferentialSpecRoot(cwd, specRoot)) return { written: false, reason: 'self-referential' }
+    if (isTempResidueSpecRoot(cwd, specRoot)) return { written: false, reason: 'temp-residue' }
+    const localSpecDir = join(cwd, '.sillyspec')
+    mkdirSync(localSpecDir, { recursive: true })
+    const ts = new Date().toLocaleString('zh-CN', { hour12: false })
+    const lines = [
+      '<!-- sillyspec 平台模式产物落点指针（CLI 在阶段 --done 完成时自动维护；本地模式不生成本文件） -->',
+      '# 变更文档实际落点（工作树 .sillyspec/ 不是本仓权威数据面）',
+      '',
+      `- 平台 spec 根（proposal/design/verify-result 等变更文档）: ${specRoot || '（未指定）'}`,
+      `- 运行时根（worktrees/contract-artifacts/verify-logs）: ${runtimeRoot || '（未指定）'}`,
+      platformOpts?.workspaceId ? `- 工作区 ID: ${platformOpts.workspaceId}` : null,
+      `- 最近更新: ${stageName || '?'} 阶段完成 @ ${ts}${changeName ? `（change: ${changeName}）` : ''}`,
+    ].filter(Boolean)
+    const changeDir = (specRoot && changeName) ? join(specRoot, 'changes', changeName) : null
+    if (changeDir && existsSync(changeDir)) {
+      const docs = []
+      for (const f of readdirSync(changeDir)) {
+        if (!f.endsWith('.md')) continue
+        try {
+          const mtime = statSync(join(changeDir, f)).mtime.toLocaleString('zh-CN', { hour12: false })
+          docs.push(`- ${f}（mtime ${mtime}）`)
+        } catch { docs.push(`- ${f}`) }
+      }
+      const tasksDir = join(changeDir, 'tasks')
+      if (existsSync(tasksDir)) {
+        const cards = readdirSync(tasksDir).filter(f => f.endsWith('.md'))
+        if (cards.length > 0) docs.push(`- tasks/（${cards.length} 张任务卡）`)
+      }
+      if (docs.length > 0) lines.push('', `## 本变更文档（${changeName}）`, ...docs)
+    }
+    lines.push('', '获取方式：直接读上行物理路径，或经平台 changes files API（/changes/{id}/files/raw?path=...）逐文件下载。')
+    const pointerPath = join(localSpecDir, 'PLATFORM-DOCS-POINTER.md')
+    writeFileSync(pointerPath, lines.join('\n') + '\n')
+    return { written: true, path: pointerPath }
+  } catch (e) {
+    console.warn('⚠️ 平台产物落点指针写入失败（不阻断）:', e && e.message ? e.message : e)
+    return { written: false, reason: 'error', error: e && e.message }
+  }
+}
+
 /**
  * 自指 specRoot 判定（repo-native junction 回环检测，变更 2026-08-23-repo-native-spec-backfill）。
  *
@@ -1035,7 +1100,12 @@ export function isQuickMetadata(p, linkedChanges = []) {
   const file = normalizeGitPath(p)
   if (file.startsWith('.sillyspec/quicklog/')
     || file.startsWith('.sillyspec/.runtime/')
-    || file === '.sillyspec/knowledge/uncategorized.md'
+    // 知识库整体白名单（2026-09-15 用户实测反馈：登记知识条目是 quick 收尾常规动作，此前
+    // INDEX/known-issues/patterns/conventions/decisions 非元数据 → 危险门 blocked 只能 --force-baseline，
+    // 且 perFileNotes 强制 --file-notes 覆盖）：knowledge/ 是 CLI 自管面（classify append-only +
+    // validate 守门），与 quicklog 同级。可追溯性靠 quicklog 结构化条目 + git diff，不靠文件行。
+    // 前缀带尾斜杠：knowledge-base/ 等相近目录不命中。
+    || file.startsWith('.sillyspec/knowledge/')
     || (/^\.sillyspec\/docs\/[^/]+\/modules\/[^/]+\.md$/.test(file))
     || (/^\.sillyspec\/docs\/[^/]+\/modules\/_module-map\.yaml$/.test(file))) return true
   if (file.startsWith('.sillyspec/changes/')) {

package/src/scope-audit.js

@@ -31,6 +31,9 @@ import { locateQuickSessionGuard, auditQuickCompletion, resolveRuntimeRoot, coll
 import { computeGateProfile, resolveGateThresholds } from './quick-gate-profile.js'
 import { safeGit } from './git-helper.js'
 import { parseFileChangeListDetailed, pathMatches } from './change-list.js'
+import { classifyToolScaffold } from './worktree-apply.js'
+import { parseRepoRegistry } from './stages/plan-postcheck.js'
+import { _readWorktreeMeta } from './contract-matrix.js'
 
 /** quick 会话 id 形态（与 run/command.js :652 QUICK_SID_RE 同款——crypto.randomUUID 前 8 hex） */
 const QUICK_SID_RE = /^quick-[0-9a-f]{8}$/
@@ -211,10 +214,11 @@ function resolveChangeDir(sb, changeName) {
 function resolveDiffRoot(sb, changeName, form, cwd) {
   if (form === 'worktree') {
     try {
-      const meta = JSON.parse(readFileSync(join(sb, '.runtime', 'worktrees', changeName, 'meta.json'), 'utf8'))
-      if (meta.worktreePath && meta.mode !== 'in-place-fallback' && existsSync(meta.worktreePath)) {
-        return meta.worktreePath
-      }
+      // 双根读取（坑 platform-dual-root-form-misjudge）：平台模式 sb=specRoot 时项目侧
+      // .sillyspec 的 meta 读不到 → worktree 根错落 cwd。_readWorktreeMeta 双候选（contract-matrix
+      // 既有样板，gitDir 已含 worktreePath/mode 判定）。
+      const found = _readWorktreeMeta(sb || null, cwd, changeName)
+      if (found) return found.gitDir
     } catch { /* 读失败 → cwd 兜底（advisory） */ }
   }
   return cwd
@@ -376,6 +380,22 @@ function findQuickPatchRecord(cwd, sessionId) {
 /** QUICKLOG 条目号形态（ql-20260914-001-abcd：日期-序号-短 hash，短 hash 4 hex） */
 const QL_ID_RE = /^ql-\d{8}-\d{3}-[0-9a-f]{4}$/
 
+/**
+ * 注册仓 key 清单（scope-audit-cross-repo-blindness 改进点 2）：读 <specBase>/local.yaml 的
+ * repos 段（parseRepoRegistry 同源，D-003 不另造解析）——design 清单跨仓子段 / `cross-repo:`
+ * 前缀只认注册 key（fail-closed，防普通路径误判）。local.yaml 缺失/坏 → 空清单（全部按主仓
+ * 解析，行为同改进前）。
+ * @param {string} specBase .sillyspec 根
+ * @returns {string[]} repoKey 清单
+ */
+function loadRegisteredRepoKeys(specBase) {
+  try {
+    const p = join(specBase || '', 'local.yaml')
+    if (!specBase || !existsSync(p)) return []
+    return [...parseRepoRegistry(readFileSync(p, 'utf8')).keys()]
+  } catch { /* 读取/解析失败 → 空清单（主仓口径兜底） */ return [] }
+}
+
 /**
  * ql-xxx → quick-xxx 反查（用户「为什么不直接用 ql-xxx 查」根治，ql-20260910-014 设计：
  * 映射只在本机 guard，会话结束即清；patches 记录按 qlId 命名且 json 冗余 sessionId——
@@ -704,7 +724,8 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
   // 审计 tag）全无 = 尚未进入 execute——实际侧不存在（B2 会吞整个工作区脏文件误归属本变更，
   // 2026-09-11-cross-change-decision-guard 实证 28 个「计划外」全是并行在途）。出计划清单
   // 视图：rows=design 清单 untouched（待实现），工作区改动归属各自会话不进表。
-  const hasWorktreeMeta = existsSync(join(sb, '.runtime', 'worktrees', changeName, 'meta.json'))
+  // 双根（坑 platform-dual-root-form-misjudge）：平台模式 sb=specRoot 时项目侧 meta 单路径读不到
+  const hasWorktreeMeta = !!_readWorktreeMeta(sb || null, cwd, changeName)
   const hasBranch = !!safeGit(cwd, ['rev-parse', '--verify', '--quiet', `sillyspec/${changeName}^{commit}`], { timeout: 15 * 1000 }).value
   const hasAuditTag = !!safeGit(cwd, ['rev-parse', '--verify', '--quiet', `sillyspec-audit/sillyspec/${changeName}^{commit}`], { timeout: 15 * 1000 }).value
   // 审查 C-F02：预执行判定必须排除归档（归档=流程走完，58/77 归档变更三信号全缺被误判
@@ -740,11 +761,12 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
     try {
       prePlanned = parseFileChangeListDetailed(
         join(changeDirInfo ? changeDirInfo.dir : join(sb, 'changes', changeName), 'design.md'),
-        { keepSillyspecDocs: true })
+        { keepSillyspecDocs: true, repoKeys: loadRegisteredRepoKeys(sb) })
     } catch { /* 清单解析失败 → 空清单 + 说明 */ }
     const preRows = prePlanned.map(e => ({
       path: e.path, planned: e.operation || null, additions: 0, deletions: 0,
       kind: 'modified', verdict: 'untouched',
+      ...(e.repo ? { crossRepo: e.repo } : {}),
     }))
     return {
       ...emptyBase,
@@ -762,8 +784,9 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
   let planDegraded = null
   try {
     // keepSillyspecDocs=true：与 actual 侧 filterDeliverableFiles 保留 .sillyspec/docs/** 交付物
-    // 的口径对齐（dogfood 模块文档=交付物）
-    plannedEntries = parseFileChangeListDetailed(designMdPath, { keepSillyspecDocs: true })
+    // 的口径对齐（dogfood 模块文档=交付物）；repoKeys=注册仓清单——跨仓子段/`cross-repo:` 前缀
+    // 条目带 repo 字段（改进点 2，标注「跨仓（本表不含）」的数据源）
+    plannedEntries = parseFileChangeListDetailed(designMdPath, { keepSillyspecDocs: true, repoKeys: loadRegisteredRepoKeys(sb) })
   } catch (e) {
     planDegraded = `design.md 清单解析异常: ${e && e.message ? String(e.message).split('\n')[0] : e}`
   }
@@ -783,13 +806,10 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
   let actual = null
   let actualFailure = null
   try {
-    const metaPath = join(sb, '.runtime', 'worktrees', changeName, 'meta.json')
-    if (existsSync(metaPath)) {
-      const meta = JSON.parse(readFileSync(metaPath, 'utf8'))
-      const wtRoot = (meta.worktreePath && meta.mode !== 'in-place-fallback' && existsSync(meta.worktreePath))
-        ? meta.worktreePath
-        : cwd
-      const anchor = meta.baselineCommit || meta.actualBaseHash || meta.baseHash || null
+    const found = _readWorktreeMeta(sb || null, cwd, changeName)
+    if (found) {
+      const wtRoot = found.gitDir
+      const anchor = found.meta.baselineCommit || found.meta.actualBaseHash || found.meta.baseHash || null
       if (anchor) {
         const diffOut = safeGit(wtRoot, ['diff', '--name-only', anchor], { timeout: 30 * 1000 })
         if (!diffOut.error && typeof diffOut.value === 'string') {
@@ -811,9 +831,9 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
               if (wtFilter(p) && !files.includes(p)) files.push(p)
             }
           }
-          actual = { ok: true, form: 'worktree', files, sources: ['worktree:diff-anchor..worktree', 'worktree:status-untracked'], foreignExcluded: 0, degradedReason: null, baseAnchor: anchor }
+          actual = { ok: true, form: 'worktree', files, sources: ['worktree:diff-anchor..worktree', 'worktree:status-untracked'], foreignExcluded: 0, foreignExcludedFiles: [], degradedReason: null, baseAnchor: anchor }
         } else {
-          actual = { ok: false, form: 'worktree', files: [], sources: [], foreignExcluded: 0, degradedReason: 'worktree 锚定 diff 失败', baseAnchor: null }
+          actual = { ok: false, form: 'worktree', files: [], sources: [], foreignExcluded: 0, foreignExcludedFiles: [], degradedReason: 'worktree 锚定 diff 失败', baseAnchor: null }
         }
       } else {
         // 无锚 meta（baseHash 等字段缺失）：退 HEAD 未提交窗口口径——文件集=status 全量
@@ -829,7 +849,7 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
               && !p.startsWith('.sillyspec/quicklog/')) files.push(p)
           }
         }
-        actual = { ok: true, form: 'worktree', files, sources: ['worktree:status-porcelain(HEAD-window)'], foreignExcluded: 0, degradedReason: null, baseAnchor: null }
+        actual = { ok: true, form: 'worktree', files, sources: ['worktree:status-porcelain(HEAD-window)'], foreignExcluded: 0, foreignExcludedFiles: [], degradedReason: null, baseAnchor: null }
       }
     } else {
       const mod = await import('./verify-postcheck.js')
@@ -983,10 +1003,20 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
     notes.push('baseAnchor 缺失——行数按 HEAD 未提交窗口采集（不含已提交改动，quick 模式同口径；numstat 采集失败时行列为 —）')
   }
 
-  // 他者声明排除面可见（R-04 同精神）：resolveReconcileActualFiles 只回计数不回名单，退栈的
-  // 计划内文件会误显「计划未动」——note 点破归属重叠可能性，让 ⚠️ 行可解释。
+  // 他者声明排除面可见（R-04 同精神）+ 退栈名单消费（scope-audit-cross-repo-blindness 改进点 3）：
+  // planned 文件被退栈排除但已写盘 → 该行标 suspectedForeignDone「疑似他者已实现·已退栈」，
+  // 与真未动区分（名单来自 resolveReconcileActualFiles 新增的 foreignExcludedFiles）。
+  const foreignExcludedSet = new Set((Array.isArray(actual.foreignExcludedFiles) ? actual.foreignExcludedFiles : []).map(toPosix))
   if (actual.foreignExcluded > 0) {
-    notes.push(`实际侧另有 ${actual.foreignExcluded} 个文件按他者会话声明退栈未进本表——「计划未动」行先怀疑归属重叠（声明即归属，git diff 核实）`)
+    notes.push(`实际侧另有 ${actual.foreignExcluded} 个文件按他者会话声明退栈未进本表——「计划未动」行标注「疑似他者已实现·已退栈」者即此类（声明即归属，git diff 核实）`)
+  }
+
+  // 计划侧跨仓段汇总（改进点 2）：跨仓条目不进本仓对账（actual 只采主仓 git），行级标
+  // crossRepo + note 交代去对应仓对账。
+  const crossRepoKeys = [...new Set(plannedEntries.map(e => e.repo).filter(Boolean))]
+  if (crossRepoKeys.length > 0) {
+    const crossCount = plannedEntries.filter(e => e.repo).length
+    notes.push(`计划侧含 ${crossCount} 个跨仓文件（repo：${crossRepoKeys.join('、')}）——⊘ 行不在本仓对账面（实际侧只采主仓 git），请到对应仓跑 scope-audit 对账`)
   }
 
   // —— 三态判定 ——
@@ -1006,6 +1036,12 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
       } else {
         row.planned = null
         row.verdict = 'unplanned'
+        // 工具/平台脚手架（改进点 1 软桶）：CLI/平台自装文件不占「计划外」——硬排档
+        // （.worktrees//.sillyspec-platform*/knowledge/local.yaml）已被 filterDeliverableFiles
+        // 滤出不进 actual；此处打标的是可能正当交付的软档（.claude/skills/、CLAUDE.md、
+        // attachments/），范围视图归入「工具/平台设施」桶。
+        const facility = classifyToolScaffold(path)
+        if (facility) row.facility = facility
       }
     }
     rows.push(row)
@@ -1013,7 +1049,16 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
   // 计划未动：清单文件无实际改动 → 补行（行数 0/0）；计划侧降级时不产（plannedEntries 为空天然不跑）
   for (const e of plannedEntries) {
     if (matchedPlanned.has(e.path)) continue
-    rows.push({ path: e.path, planned: e.operation || null, additions: 0, deletions: 0, kind: 'modified', verdict: 'untouched' })
+    const row = { path: e.path, planned: e.operation || null, additions: 0, deletions: 0, kind: 'modified', verdict: 'untouched' }
+    if (e.repo) {
+      // 跨仓条目（改进点 2）：不是「未动」是「本表不含」
+      row.crossRepo = e.repo
+    } else {
+      // 退栈排除 + 盘面已存在 → 他者会话已写盘（改进点 3）；NEW: 前缀剥除后比对（pathMatches 同款口径）
+      const norm = toPosix(e.path).replace(/^NEW:/, '')
+      if (foreignExcludedSet.has(norm) && existsSync(join(numstatRoot, norm))) row.suspectedForeignDone = true
+    }
+    rows.push(row)
   }
 
   // 冻结 patch（collectPatch，execute --done 落盘方消费）：与行数同根同锚（numstatRoot +
@@ -1054,7 +1099,11 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
  *   rows: Array<{ path: string, planned?: string|null, declared?: boolean,
  *                 additions: number|null, deletions: number|null,
  *                 kind: 'binary'|'new'|'modified'|'deleted',
- *                 verdict?: 'planned'|'unplanned'|'untouched', attribution?: 'declared'|'soft'|'undeclared' }>,
+ *                 verdict?: 'planned'|'unplanned'|'untouched', attribution?: 'declared'|'soft'|'undeclared',
+ *                 crossRepo?: string, suspectedForeignDone?: boolean, facility?: 'tool'|'platform' }>,
+ *   （crossRepo/suspectedForeignDone/facility 为 scope-audit-cross-repo-blindness 改进点 1/2/3
+ *     增量字段：跨仓条目标 repoKey / 退栈排除但已写盘的 planned 文件 / 计划外行里的工具平台
+ *     脚手架桶——均为按存在性读取，缺省无字段零回归）
  *   excluded: { foreignDeclared: Array<{ file: string, sessions: string[] }> },
  *   note?: string|null,
  *   gateProfile?: object|null }>}
@@ -1187,7 +1236,7 @@ export async function getFileDiff({ cwd, specBase, changeName, platformOpts, fil
       const located = locateQuickSessionGuard(cwd, changeName)
       if (located) root = dirname(located.specBase)
     } else {
-      const form = existsSync(join(sb, '.runtime', 'worktrees', changeName, 'meta.json')) ? 'worktree' : 'post-apply'
+      const form = _readWorktreeMeta(sb || null, cwd, changeName) ? 'worktree' : 'post-apply'
       root = resolveDiffRoot(sb, changeName, form, cwd)
     }
 
@@ -1210,12 +1259,16 @@ export async function getFileDiff({ cwd, specBase, changeName, platformOpts, fil
   }
 }
 
-/** verdict / attribution → 展示标记（人类可读面；BIN 为 binary 行数占位，— 为降级占位） */
+/** verdict / attribution → 展示标记（人类可读面；BIN 为 binary 行数占位，— 为降级占位）。
+ *  行级标注优先（scope-audit-cross-repo-blindness 改进点 1/2/3）：跨仓 > 疑似他者已实现 > 设施桶 */
 const VERDICT_LABEL = {
   planned: '✓ 计划内',
   unplanned: '⚠️ 计划外',
   untouched: '⚠️ 计划未动',
 }
+const CROSS_REPO_LABEL = '⊘ 跨仓（本表不含）'
+const SUSPECTED_FOREIGN_LABEL = '⚠️ 计划未动（疑似他者已实现·已退栈）'
+const FACILITY_LABEL = '⚠️ 计划外（工具/平台设施）'
 const ATTRIBUTION_LABEL = {
   declared: '✓ 已声明',
   soft: '🔍 软归属',
@@ -1278,7 +1331,10 @@ export function renderScopeAuditTable(result, opts = {}) {
     const stat = row.kind === 'binary'
       ? { a: 'BIN', d: 'BIN' }
       : { a: fmtCount(row.additions) ?? '—', d: fmtCount(row.deletions) ?? '—' }
-    const label = VERDICT_LABEL[row.verdict] || ATTRIBUTION_LABEL[row.attribution] || ''
+    const label = row.crossRepo ? CROSS_REPO_LABEL
+      : row.suspectedForeignDone ? SUSPECTED_FOREIGN_LABEL
+      : row.facility ? FACILITY_LABEL
+      : VERDICT_LABEL[row.verdict] || ATTRIBUTION_LABEL[row.attribution] || ''
     lines.push(`   ${row.path || '(未知路径)'}${' '.repeat(Math.max(1, 40 - String(row.path || '').length))}${label}${' '.repeat(Math.max(1, 12 - label.length))}${String(stat.a).padStart(5)} ${String(stat.d).padStart(5)}   ${row.kind || ''}`)
   }
   if (rows.length > shown.length) {
@@ -1287,15 +1343,29 @@ export function renderScopeAuditTable(result, opts = {}) {
 
   lines.push(`   合计：${totals.files ?? rows.length} 文件  +${totals.additions ?? 0} / -${totals.deletions ?? 0}`)
 
-  // ⚠️ 出口指引（full-flow 三态面）：计划外补声明、计划未动确认遗漏
-  const unplanned = rows.filter(x => x && x.verdict === 'unplanned').length
-  const untouched = rows.filter(x => x && x.verdict === 'untouched').length
-  if (unplanned > 0 || untouched > 0) {
+  // ⚠️ 出口指引（full-flow 三态面）：计划外补声明、计划未动确认遗漏。
+  // 行级标注三分（scope-audit-cross-repo-blindness 改进点 1/2/3）：跨仓行/疑似他者已实现行/
+  // 工具设施桶各有去向说明，不混入笼统的「计划外/计划未动」计数逼用户排查噪音。
+  const unplanned = rows.filter(x => x && x.verdict === 'unplanned' && !x.facility).length
+  const facility = rows.filter(x => x && x.verdict === 'unplanned' && x.facility).length
+  const untouchedReal = rows.filter(x => x && x.verdict === 'untouched' && !x.suspectedForeignDone && !x.crossRepo).length
+  const suspectedForeign = rows.filter(x => x && x.suspectedForeignDone).length
+  const crossRepo = rows.filter(x => x && x.crossRepo).length
+  if (unplanned > 0 || untouchedReal > 0) {
     const parts = []
     if (unplanned > 0) parts.push(`计划外 ${unplanned} 文件`)
-    if (untouched > 0) parts.push(`计划未动 ${untouched} 文件`)
+    if (untouchedReal > 0) parts.push(`计划未动 ${untouchedReal} 文件`)
     lines.push(`   ⚠️ ${parts.join('、')}——计划外请补 design.md 声明或 --output 注明原因；计划未动请确认是否遗漏`)
   }
+  if (suspectedForeign > 0) {
+    lines.push(`   ℹ️ 疑似他者已实现 ${suspectedForeign} 文件（已写盘但被退栈——他者会话声明归属，本表不计未动；git diff 核实归属）`)
+  }
+  if (facility > 0) {
+    lines.push(`   ℹ️ 工具/平台设施 ${facility} 文件（CLI/平台自装脚手架，非本变更改动，不占计划外）`)
+  }
+  if (crossRepo > 0) {
+    lines.push(`   ℹ️ 跨仓 ${crossRepo} 文件（⊘ 行——本表不含，请到对应仓跑 scope-audit 对账）`)
+  }
   const undeclared = rows.filter(x => x && x.attribution === 'undeclared').length
   if (undeclared > 0) lines.push(`   ⚠️ 未声明 ${undeclared} 文件——超出 allowedFiles 声明面，补 --files 声明或注明原因`)
 

package/src/stages/cmd-existence.js

@@ -13,7 +13,7 @@
  */
 
 import { existsSync, readFileSync } from 'fs'
-import { join } from 'path'
+import { join, isAbsolute } from 'path'
 
 // 提取 `npm|pnpm|yarn run <script>` 命令。
 // 对齐 scan-postcheck:136 的 `/npm run (\S+)/g`，扩展包管理器 + 容忍多空白。
@@ -50,7 +50,12 @@ function readScripts(pkgPath) {
  * 为单条命令计算候选 package.json 路径列表。
  *
  * 规则（blueprint task-02 + design §5 H2）：
- *   - 有 `cd <subdir> &&` 前缀 → 仅查 `<projectRoot>/<subdir>/package.json`（cd 锁定子目录，不回退根）
+ *   - 有 `cd <subdir> &&` 前缀 → 仅查 `<subdir>/package.json`（cd 锁定子目录，不回退根）。
+ *     subdir 为绝对路径（win 盘符 / posix 根）时不再拼 projectRoot——坑
+ *     verify-cmd-absolute-cd-path（2026-09-15 wp 会话实证）：跨仓 task 卡 verify 写
+ *     `cd E:/PZwangge/sub-grid-security && npm run lint`，join(主仓根, 'E:/...') 拼出
+ *     病态路径 → package.json 恒 missing → 真实命令被误判死命令，agent 只能改写成
+ *     ../ 相对路径绕过
  *   - 无前缀 + modules 块提供 → 查每个 module.path 的子包 + 根 package.json（多候选任一命中即视为存在）
  *   - 无前缀 + 无 modules → 仅查 `<projectRoot>/package.json`
  *
@@ -65,7 +70,8 @@ function resolveCandidates(text, matchIndex, projectRoot, modules) {
   const cdMatch = before.match(CD_PREFIX_RE)
   if (cdMatch) {
     const subdir = cdMatch[1].replace(/^["']|["']$/g, '')
-    return [join(projectRoot, subdir, 'package.json')]
+    const base = isAbsolute(subdir) ? subdir : join(projectRoot, subdir)
+    return [join(base, 'package.json')]
   }
   if (modules && typeof modules === 'object') {
     const candidates = []

package/src/stages/knowledge.js

@@ -76,10 +76,15 @@ function extractTitle(content) {
 
 export async function cmdSearch(dir, args, opts = {}) {
   const knowledgeDir = resolveKnowledgeDir(dir, opts.specDir)
+  // flag-as-value 防护（坑 knowledge-flag-as-value）：值以 '--' 开头视为漏传（只读命令，
+  // 按缺参处理落入既有 required 校验/默认值，不静默拿 flag 字面量当查询词）
   const queryIdx = args.indexOf('--query')
-  const query = queryIdx >= 0 && args[queryIdx + 1] ? args[queryIdx + 1] : ''
+  const queryRaw = queryIdx >= 0 ? args[queryIdx + 1] : ''
+  const query = queryRaw && !queryRaw.startsWith('--') ? queryRaw : ''
   const limitIdx = args.indexOf('--limit')
-  const limit = limitIdx >= 0 && args[limitIdx + 1] ? parseInt(args[limitIdx + 1]) : 10
+  const limitRaw = limitIdx >= 0 ? args[limitIdx + 1] : ''
+  const parsedLimit = limitRaw && !limitRaw.startsWith('--') ? parseInt(limitRaw, 10) : NaN
+  const limit = Number.isInteger(parsedLimit) && parsedLimit > 0 ? parsedLimit : 10
 
   if (!query) {
     output(false, {}, '--query is required')
@@ -130,8 +135,10 @@ export async function cmdSearch(dir, args, opts = {}) {
 
 export async function cmdInspect(dir, args, opts = {}) {
   const knowledgeDir = resolveKnowledgeDir(dir, opts.specDir)
+  // flag-as-value 防护同 cmdSearch（坑 knowledge-flag-as-value）
   const idIdx = args.indexOf('--id')
-  const id = idIdx >= 0 && args[idIdx + 1] ? args[idIdx + 1] : ''
+  const idRaw = idIdx >= 0 ? args[idIdx + 1] : ''
+  const id = idRaw && !idRaw.startsWith('--') ? idRaw : ''
 
   if (!id) {
     output(false, {}, '--id is required')
@@ -215,6 +222,20 @@ export async function cmdValidate(dir, args, opts = {}) {
         })
       }
     }
+
+    // 2b. flag 形态关键词（坑 knowledge-flag-as-value）：classify 曾把 flag-as-value 的
+    // 字面量 '--file' 写进路由行——目标文件存在、行格式合法，既有检查放行，此处补侦测
+    for (const entry of entries) {
+      const flagKw = entry.keywords.find(kw => kw.startsWith('--'))
+      if (flagKw) {
+        warnings.push({
+          code: 'flag_like_keyword',
+          path: 'knowledge/INDEX.md',
+          display: entry.display,
+          keyword: flagKw,
+        })
+      }
+    }
   }
 
   // 3. 扫描所有 .md 文件，检查是否在 INDEX 中注册