sillyspec 3.29.0 → 3.29.2

package/src/redlines.js

@@ -0,0 +1,195 @@
+/**
+ * redlines.js —— 红线机检评估器（2026-09-20-redline-machine-check）
+ *
+ * 为什么需要（2026-09-19 双实现对撞实验核心教训）：语义级设计红线（「已结束会话
+ * 不得假运行」「用量归属不得后写覆盖」）活在历史 design/knowledge 散文里，无机器
+ * 可查形态——三层独立评审 + 352 例测试拦不住两处红线失分，靠事后人工逐文件深读
+ * 才发现。本模块把红线转成机器可查断言：消费者仓 `.sillyspec/redlines.yaml` 条目
+ * = forbid/require 正则 × scope 文件 glob × severity × origin 文档锚。
+ *
+ * 定位与边界（decisions.md D-001~D-004）：
+ *   - v1 = 模式级断言（人写正则人负责；statement/origin 保留散文溯源）；不做
+ *     AST/语义级，不做散文自动提炼。
+ *   - 机制与内容分离：清单消费者仓自持；本仓缺清单 = 不适用（零打扰）。
+ *   - fail-open 全链：坏 yaml→不适用+注记；单条求值异常→跳过+warn；任何红线面
+ *     故障不炸 verify 主链（探针 11 接线侧 try/catch fail-soft，同探针 8/9/10）。
+ *   - advisory：探针渲染 ❌/⚠️ 进 verify-result 骨架供 agent 裁定；不进 PASS
+ *     封顶（D-003：攒误报率数据后另案升硬门）。
+ *
+ * 纯函数纪律：root 注入，不读 env/时钟；fs 只经 resolveScopeFiles 的 walk。
+ * 零新增外部依赖（js-yaml 已有）。
+ */
+import { readdirSync, statSync, readFileSync } from 'fs';
+import { join, relative } from 'path';
+import jsYaml from 'js-yaml';
+
+/** scope walk 排除目录（依赖/版本库/工具自身产物——含 .sillyspec：清单/进度文件不得喂饱 require 造成假阴性，S2 审查 D1）。 */
+const SKIP_DIRS = new Set(['node_modules', '.git', '.sillyspec', '.runtime', 'dist', 'build', '.next', '__pycache__']);
+
+/** 单文件扫描上限：2MB（大产物/锁文件跳过，warn 留痕）。 */
+const MAX_FILE_BYTES = 2 * 1024 * 1024;
+
+/** glob → 正则：`**` 跨层、`*` 单段（不跨 /）；段全等不认长名（src-guide 不蹭 src）。 */
+function globToRegExp(glob) {
+  const esc = String(glob).replace(/[.+^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(
+    '^' + esc.replace(/\*\*/g, '⟦⟦DBL⟧⟧').replace(/\*/g, '⟦SGL⟧')
+      .replace(/⟦⟦DBL⟧⟧/g, '(?:.*)').replace(/⟦SGL⟧/g, '[^/]*') + '$',
+  );
+}
+
+/** 递归收集 root 下全部文件（排除 SKIP_DIRS；返回仓根相对 POSIX 路径）。 */
+function walkFiles(root) {
+  const out = [];
+  const visit = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const p = join(dir, e.name);
+      if (e.isDirectory()) {
+        if (SKIP_DIRS.has(e.name)) continue;
+        visit(p);
+      } else if (e.isFile()) {
+        out.push(relative(root, p).replace(/\\/g, '/'));
+      }
+    }
+  };
+  visit(root);
+  return out;
+}
+
+/**
+ * 解析 redlines.yaml 文本为条目数组（纯函数）。
+ * 无效条目四判据（跳过 + warnings 留痕）：缺 id / 缺 scope / forbid 与 require
+ * 全空 / 任一正则编译失败。severity 缺省 'error'。
+ * @param {string} yamlText
+ * @returns {{ entries: Array<object>, warnings: string[] }}
+ */
+export function parseRedlines(yamlText) {
+  const warnings = [];
+  const doc = jsYaml.load(yamlText);
+  const rawList = doc && Array.isArray(doc.redlines) ? doc.redlines : [];
+  const entries = [];
+  for (const raw of rawList) {
+    if (!raw || typeof raw !== 'object') {
+      warnings.push('跳过非对象条目');
+      continue;
+    }
+    const id = typeof raw.id === 'string' && raw.id.trim() !== '' ? raw.id.trim() : null;
+    if (id === null) { warnings.push('跳过缺 id 条目'); continue; }
+    const scope = Array.isArray(raw.scope) ? raw.scope.filter((s) => typeof s === 'string' && s !== '') : [];
+    if (scope.length === 0) { warnings.push(`条目 ${id} 缺 scope，跳过`); continue; }
+    const forbid = Array.isArray(raw.forbid) ? raw.forbid.filter((s) => typeof s === 'string' && s !== '') : [];
+    const require_ = Array.isArray(raw.require) ? raw.require.filter((s) => typeof s === 'string' && s !== '') : [];
+    if (forbid.length === 0 && require_.length === 0) {
+      warnings.push(`条目 ${id} 的 forbid 与 require 全空，跳过`);
+      continue;
+    }
+    const severity = raw.severity === 'warning' ? 'warning' : 'error';
+    const entry = {
+      id,
+      statement: typeof raw.statement === 'string' ? raw.statement : '',
+      scope,
+      forbid,
+      require: require_,
+      severity,
+      origin: typeof raw.origin === 'string' ? raw.origin : null,
+      _res: { forbid: [], require: [] },
+    };
+    let badRe = false;
+    for (const re of forbid) {
+      try { entry._res.forbid.push(new RegExp(re, 'm')); } catch (e) { warnings.push(`条目 ${id} forbid 正则编译失败（${re}），跳过该条`); badRe = true; }
+    }
+    for (const re of require_) {
+      try { entry._res.require.push(new RegExp(re, 'm')); } catch (e) { warnings.push(`条目 ${id} require 正则编译失败（${re}），跳过该条`); badRe = true; }
+    }
+    if (badRe) continue;
+    entries.push(entry);
+  }
+  return { entries, warnings };
+}
+
+/**
+ * scope glob 列表 → 命中文件集（root 下仓根相对 POSIX 路径，排序去重）。
+ * @param {string[]} scopeGlobs
+ * @param {string} root
+ * @returns {string[]}
+ */
+export function resolveScopeFiles(scopeGlobs, root) {
+  const all = walkFiles(root);
+  const res = (Array.isArray(scopeGlobs) ? scopeGlobs : [])
+    .filter((g) => typeof g === 'string' && g !== '')
+    .map((g) => globToRegExp(g));
+  return [...new Set(all.filter((f) => res.some((r) => r.test(f))))].sort();
+}
+
+/**
+ * 逐条评估红线：forbid 命中收集 file:line + require 缺失 + severity 透传。
+ * 单条求值异常跳过 + warnings（fail-open，D-004）。
+ * @param {object} opts
+ * @param {Array<object>} opts.entries - parseRedlines 产物
+ * @param {string} opts.root - 求值根（worktree 或仓根，绝对路径）
+ * @returns {{ applicable: boolean, entryCount: number, findings: Array<object>, warnings: string[] }}
+ */
+export function evaluateRedlines({ entries, root }) {
+  const warnings = [];
+  const findings = [];
+  const list = Array.isArray(entries) ? entries : [];
+  for (const entry of list) {
+    try {
+      const files = resolveScopeFiles(entry.scope, root);
+      const contents = new Map();
+      const readIfBig = (rel) => {
+        if (!contents.has(rel)) {
+          const abs = join(root, rel);
+          let text = '';
+          try {
+            if (statSync(abs).size > MAX_FILE_BYTES) {
+              warnings.push(`条目 ${entry.id}：${rel} 超 2MB 跳过`);
+            } else {
+              text = readFileSync(abs, 'utf8');
+            }
+          } catch (e) {
+            warnings.push(`条目 ${entry.id}：读 ${rel} 失败（${e && e.code ? e.code : 'error'}），跳过该文件`);
+          }
+          contents.set(rel, text);
+        }
+        return contents.get(rel);
+      };
+      for (const rel of files) {
+        const text = readIfBig(rel);
+        if (!text) continue;
+        const lines = text.split('\n');
+        for (const re of entry._res ? entry._res.forbid : []) {
+          for (let i = 0; i < lines.length; i++) {
+            const m = lines[i] && re.exec(lines[i]);
+            if (m) {
+              findings.push({
+                id: entry.id, severity: entry.severity, kind: 'forbid',
+                file: rel, line: i + 1, snippet: String(m[0]).slice(0, 160),
+                statement: entry.statement, origin: entry.origin,
+              });
+            }
+          }
+        }
+      }
+      for (const re of entry._res ? entry._res.require : []) {
+        const satisfied = [...contents.values()].some((text) => re.test(text));
+        if (!satisfied) {
+          findings.push({
+            id: entry.id, severity: 'warning', kind: 'require-missing',
+            statement: entry.statement, origin: entry.origin,
+            detail: `require 模式在 scope 全集（${files.length} 文件）无命中`,
+          });
+        }
+      }
+    } catch (e) {
+      warnings.push(`条目 ${entry.id} 求值异常跳过（${e && e.message ? e.message : e}）`);
+    }
+  }
+  return { applicable: true, entryCount: list.length, findings, warnings };
+}

package/src/run/command.js

@@ -1325,6 +1325,38 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
     } catch { /* claim 失败不阻断启动 */ }
   }
 
+  // ── 所有权写路径断言（2026-09-20 双写碰撞实证修复）：claim 只「不抢不拒」，写操作还须
+  // assert——今晚实证两会话并行驱动同一 change（owner=zcode-fr-l2 他人活跃中，另一会话的
+  // 三条 --done 直通落库，步骤槽混写）。拦截面=写 flag（--done/--reset/--reopen/--skip/
+  // --answer/--confirm/--files：quick 边界追加也是写）；读路径（prompt 显示/--status）不拦
+  // （index.js apply/cleanup 只读不接同款）。语义同接管类：self/no-owner 放行；
+  // takeover-stale（活跃窗外）放行并自动接管重写 owner；blocked-active-owner 拒绝（结构化
+  // 错误 + 指引）；--takeover 显式强制（逃生阀，重写留痕）。quick 会话身份=changeName 恒
+  // self 零影响；default 容器跳过（同上方 claim）。fail-open：断言异常不拦（护栏退 no-owner）。
+  if (effectiveChange && effectiveChange !== 'default') {
+    const _isWriteOp = isDone || isReset || isReopen || isSkip
+      || flags.includes('--answer') || flags.includes('--confirm') || flags.includes('--files');
+    if (_isWriteOp) {
+      try {
+        const ident = resolveSessionIdentity({
+          flagSession: getFlagValue('--session'),
+          quickChangeName: stageName === 'quick' ? effectiveChange : null,
+          cwd: dirname(specRoot),
+        })
+        const check = pm.assertChangeOwnership(cwd, effectiveChange, {
+          selfSession: ident.session, nowMs: Date.now(), forced: flags.includes('--takeover'),
+        })
+        if (check.allowed) {
+          if (check.action !== 'self') pm.setChangeOwner(cwd, effectiveChange, ident.session)
+        } else {
+          console.error(`\n🚫 变更 ${effectiveChange} 正被其他会话持有（owner: ${check.owner}，最后活跃: ${check.lastActive || '未知'}），活跃窗口 ${Math.round(check.heartbeatMs / 60000)} 分钟内拒绝写操作（--done/--reset/--reopen/--skip/--answer/--confirm/--files）`)
+          console.error(`   两个会话同时驱动同一 change 会步骤槽混写（2026-09-20 实证）。确认对方已放弃：等活跃窗过期后重试（自动接管），或本条命令加 --takeover 显式强制接管（重写 owner 留痕）；或与对方会话协调归属。`)
+          process.exit(1)
+        }
+      } catch { /* 断言异常不拦（fail-open，同 claim） */ }
+    }
+  }
+
   // --reset
   if (isReset) {
     return await resetStage(pm, progress, stageName, cwd, effectiveChange, platformOpts)

package/src/run/complete.js

@@ -588,6 +588,18 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
     }
   }
 
+  // verify 批量完成检测（P0-1 verify 尾巴瘦身，2026-09-20 对撞实验驱动）：报告产物齐
+  // （verify-result.md 结论枚举已填 + verify-facts.json 在场）且语义锚定步（step 1-2）
+  // 已过 → 剩余 step 一次性标 completed，本次 --done 直接进阶段完成分支——收尾门禁
+  // （测试对账/验收矩阵/module-impact 死信/PASS 封顶）照常全跑：批量省的是 --done
+  // 肥上下文往返，不省任何门。镜像 execute 批量模式（乐观预标戳 + 失败一并回滚）。
+  if (stageName === 'verify' && changeName) {
+    const _vb = detectVerifyBatchFinish({ changeName, specBase, steps })
+    if (_vb.batched && _vb.aligned > 0) {
+      console.log(`\n🚀 verify 批量完成：报告结论已填 + facts 在场，一次性补完 ${_vb.aligned} 个剩余 step → 进入阶段完成分支（收尾门禁照常全跑）`)
+    }
+  }
+
   const nextPendingIdx = steps.findIndex(s => s.status === 'pending' || s.status === 'in-progress')
 
   if (nextPendingIdx === -1) {
@@ -702,6 +714,13 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
     const total = steps.length
     console.log(`✅ ${stageName} 阶段已完成（${total}/${total} 步）`)
 
+    // 瘦会话交接提示（P1-5 v1，2026-09-20 对撞实验驱动）：主流程阶段完成时点提示
+    // 「下一阶段可新会话续跑」——CLI prompt 自足（进度/上下文全由进度库与注入提供），
+    // 每阶段一个瘦会话省掉肥上下文 × N 请求的重发税。advisory 一行，不强制。
+    if (['brainstorm', 'plan', 'execute', 'verify'].includes(stageName) && changeName) {
+      console.log(`💡 瘦会话模式：下一阶段可在新会话续跑（sillyspec handoff --change ${changeName} 生成交接块；保持 SILLYSPEC_SESSION_ID 不变）——省肥上下文重发税`)
+    }
+
     // 平台模式产物落点指针（platform-docs-dual-location，2026-09-15 EHS 实证）：完成时点在
     // 工作树 .sillyspec/ 刷新人类可读指针（本地模式零行为，fail-soft 内部全兜）。
     writePlatformDocsPointer(cwd, changeName, platformOpts, stageName)
@@ -1267,8 +1286,47 @@ export async function autoCheckPlanFromReviews({ stageName, changeName, cwd, pla
  * 安全门：注册表零 checkbox / 未全勾 / 代码零变更（unchanged）均不批量——信任声明但用代码核验兜底。
  * @returns {Promise<{batched:boolean, aligned:number, reason?:string, blockedTasks?:string[]}>}
  */
-async function detectExecuteBatchFinish({ pm, stageName, changeName, cwd, specBase, platformOpts, steps }) {
-  if (stageName !== 'execute' || !changeName) return { batched: false, aligned: 0 }
+/**
+ * verify 批量完成检测（P0-1，2026-09-20）：镜像 execute 的 detectExecuteBatchFinish。
+ * 条件（全部满足才批量）：verify-result.md 结论枚举已填（三态任一，非待填占位）+
+ * verify-facts.json 在场（探针跑过）+ 锚定步（step 1-2）已完成。批量只标剩余 step
+ * completed，收尾门禁由阶段完成分支照常执行（批量不绕门）。
+ */
+export function detectVerifyBatchFinish({ changeName, specBase, steps }) {
+  if (!changeName) return { batched: false, aligned: 0 }
+  try {
+    const changeDir = join(specBase, 'changes', changeName)
+    const reportPath = join(changeDir, 'verify-result.md')
+    if (!existsSync(reportPath)) return { batched: false, aligned: 0, reason: 'verify-result.md 缺席（报告未写不批量）' }
+    const report = readFileSync(reportPath, 'utf8')
+    if (!/结论枚举[：:]\s*`?\s*(PASS WITH NOTES|PASS|FAIL)/.test(report)) {
+      return { batched: false, aligned: 0, reason: '结论枚举未填（待填占位不批量）' }
+    }
+    if (!existsSync(join(changeDir, 'verify-facts.json'))) {
+      return { batched: false, aligned: 0, reason: 'verify-facts.json 缺席（探针未跑不批量）' }
+    }
+    const firstPendingIdx = steps.findIndex(s => s.status === 'pending' || s.status === 'in-progress')
+    if (firstPendingIdx === -1) return { batched: false, aligned: 0, reason: '无剩余 step' }
+    if (firstPendingIdx < 2) {
+      return { batched: false, aligned: 0, reason: '锚定步未过（step 1-2 须逐步完成，语义锚定不批量）' }
+    }
+    const now = new Date().toLocaleString('zh-CN', { hour12: false })
+    let aligned = 0
+    for (const step of steps) {
+      if (step.status === 'pending' || step.status === 'in-progress') {
+        step.status = 'completed'
+        step.completedAt = now
+        step._batchAligned = true // 乐观预标戳：gate 失败 rollback 一并回滚（execute 同款）
+        aligned++
+      }
+    }
+    return { batched: true, aligned }
+  } catch (e) {
+    return { batched: false, aligned: 0, reason: `批量完成检测异常（fail-open 单步推进）：${e && e.message ? e.message : e}` }
+  }
+}
+
+async function detectExecuteBatchFinish({ pm, stageName, changeName, cwd, specBase, platformOpts, steps }) {  if (stageName !== 'execute' || !changeName) return { batched: false, aligned: 0 }
   try {
     const changeDir = join(specBase, 'changes', changeName)
     const { total: planTotal, checked: planChecked } = pm.readPlanCheckboxStatus(changeDir)

package/src/run/gate-snapshot.js

@@ -352,7 +352,7 @@ export function applyGateSnapshotCopy(cwd, snapshotRoot) {
  * @param {{ cwd: string, files: string[] }} opts cwd=主仓根；files=本会话变更文件（仓库根相对 POSIX）
  * @returns {{ snapshotRoot: string, cleanup: () => void, reason?: string }|null} 失败返回 null（调用方回退主仓）
  */
-export function createGateSnapshot({ cwd, files, sourceRoot = null, skipImportSmoke = false }) {
+export function createGateSnapshot({ cwd, files, sourceRoot = null, skipImportSmoke = false, mergeBase = null }) {
   let snapshotRoot = null
   try {
     // 前置：主仓须是 git 仓且有 HEAD（无 git 环境回退主仓现行为）
@@ -381,10 +381,47 @@ export function createGateSnapshot({ cwd, files, sourceRoot = null, skipImportSm
     // local.yaml 由下方 cfg 段显式复制（单一来源，不经 overlay）。
     const overlayRoot = sourceRoot || cwd
     let overlaid = 0
+    // 双写一致性（2026-09-20 红线机检变更实证：主 agent 在主仓直写而 execute 已建 worktree 时，
+    // overlay 源=worktree 拿陈旧内容盖掉快照 HEAD 的新版——快照内 import 找不到新导出→门禁假红）。
+    // 祖先判据（fr-index-l2 二次实证升级）：基线优先取 merge-base 的每文件祖先内容
+    //（git show mb:file——worktree 有自家 checkpoint 提交时，快照 HEAD 不是公共祖先，
+    // wtDiff/cwdDiff 同谱不可分；祖先内容可精确分「worktree 停在分叉点=陈旧」与「真有修改」）。
+    // 两份都变于祖先且互不相等（真双写分叉）→ 显式警告 + 取 cwd（主仓直写=本会话最新编辑位约定）。
+    // 行尾归一（坑 autocrlf-byte-misjudge）：本机 autocrlf=true 时快照 checkout 是 CRLF、
+    // 工作区文件常是 LF——字节直比会误判「两边都改」。比较一律 CRLF→LF 归一后做。
+    const normalizeEol = (buf) => String(buf).replace(/\r\n/g, '\n')
+    const headFileContent = (rel) => {
+      if (mergeBase) {
+        try {
+          const anc = git(cwd, ['show', `${mergeBase}:${rel}`])
+          if (typeof anc === 'string') return normalizeEol(anc)
+        } catch { /* 祖先无此文件（新增文件）→ 落到快照 HEAD 口径 */ }
+      }
+      try { return normalizeEol(readFileSync(join(snapshotRoot, rel))) } catch { return null }
+    }
     for (const f of files) {
       const isSillyspecRuntime = typeof f === 'string' && (f.startsWith('.sillyspec/.runtime/') || f.startsWith('.sillyspec/quicklog/') || f === '.sillyspec/local.yaml' || f === '.sillyspec/.sillyspec-platform.json')
       if (typeof f !== 'string' || f.includes('..') || f.startsWith('/') || isSillyspecRuntime) continue
-      const src = join(overlayRoot, f)
+      let src = join(overlayRoot, f)
+      if (sourceRoot && sourceRoot !== cwd) {
+        const wtPath = join(sourceRoot, f), cwdPath = join(cwd, f)
+        if (existsSync(wtPath) && existsSync(cwdPath)) {
+          let wtText = null, cwdText = null
+          try { wtText = normalizeEol(readFileSync(wtPath)) } catch { /* 读失败不介入 */ }
+          try { cwdText = normalizeEol(readFileSync(cwdPath)) } catch { /* 读失败不介入 */ }
+          if (wtText !== null && cwdText !== null && wtText !== cwdText) {
+            const base = headFileContent(f)
+            const wtDiff = base === null || wtText !== base
+            const cwdDiff = base === null || cwdText !== base
+            if (cwdDiff && !wtDiff) {
+              src = cwdPath // 主仓直写新、worktree 停在基线 → 取主仓
+            } else if (!(wtDiff && !cwdDiff)) {
+              console.warn(`⚠️ 快照双写分叉：${f} 在主仓与 worktree 均有不同修改——取主仓（本会话最新编辑位），请尽快对齐两边`)
+              src = cwdPath
+            } // wtDiff && !cwdDiff → 保持 worktree（正常流零改变）
+          }
+        }
+      }
       if (!existsSync(src)) continue
       const dst = join(snapshotRoot, f)
       mkdirSync(dirname(dst), { recursive: true })
@@ -604,16 +641,30 @@ export async function createVerifyGateSnapshot({ cwd, changeName, specBase, plat
 
     // overlay 源：worktree meta 感知（native worktree 在则从 worktree 根取「本变更分支内容」）
     let sourceRoot = null
+    let snapMergeBase = null
     try {
       const { WorktreeManager } = await import('../worktree.js')
       const wm = new WorktreeManager({ cwd })
       const meta = wm.getMeta(changeName)
       if (meta && meta.worktreePath && meta.mode !== 'in-place-fallback' && existsSync(meta.worktreePath)) {
         sourceRoot = meta.worktreePath
+        // 陈旧 worktree 判定（2026-09-20 fr-index-l2 实证）：主 agent 在主仓直写并提交后，
+        // worktree 停在基线——内容三方（worktree/cwd/快照HEAD）判不出「领先」与「落后」
+        // （同谱）。精确判据 = merge-base 的每文件祖先内容（git show mb:file）：
+        // worktree 内容==祖先 → 陈旧（主仓取新）；≠ → worktree 有真修改（正常流保 worktree）。
+        // 此处只算 mergeBase 一次（拓扑级），每文件祖先内容由 createGateSnapshot 按需取。
+        try {
+          const wtTip = git(sourceRoot, ['rev-parse', 'HEAD'])
+          const mainHead = git(cwd, ['rev-parse', 'HEAD'])
+          const mb = (wtTip && mainHead && wtTip !== mainHead) ? git(cwd, ['merge-base', wtTip, mainHead]) : null
+          if (wtTip && mainHead && wtTip !== mainHead && mb) {
+            snapMergeBase = String(mb).trim()
+          }
+        } catch { /* 拓扑判定失败退快照HEAD口径（既有兜底） */ }
       }
     } catch { /* meta 读取失败 → 主仓 cwd 源（files 已含本变更 working-tree 改动） */ }
 
-    const snap = createGateSnapshot({ cwd, files: changeFiles, sourceRoot })
+    const snap = createGateSnapshot({ cwd, files: changeFiles, sourceRoot, mergeBase: snapMergeBase })
     if (!snap) return null
 
     // 变更文档随快照：module-impact.md（test_strategy=evidence-auto 消费）/tasks.md 等

package/src/run/prompt.js

@@ -1151,9 +1151,9 @@ export async function outputStep(stageName, stepIndex, steps, cwd, changeName, d
       if (entries.length === 0) {
         promptText = promptText.replace(/\{FR_INDEX_DIGEST\}/g, '（触达域暂无 active FR 索引条目——本变更大概率是这些域的首批需求，照常写作）')
       } else {
-        const lines = entries.map((e) => `- ${e.id} ${e.title}（来源 ${e.change}${e.scenarios.length ? '；场景：' + e.scenarios.slice(0, 3).join('，') : ''}）`)
+        const lines = entries.map((e) => `- ${e.id} ${e.title}（来源 ${e.change}${e.scenarios.length ? '；场景：' + e.scenarios.slice(0, 3).join('，') : ''}${(e.decisions || []).length ? '；依据：' + e.decisions.slice(0, 3).join('、') : ''}）`)
         lines.push('')
-        lines.push('> 域解析自本变更 design.md 文件清单（漏域先核对清单）。改写/取代已有行为 → 对应 FR 块加承接行；新行为 → 新 FR 块。superseded 条目默认不列（历史回溯自行读 knowledge/fr/）。')
+        lines.push('> 域解析自本变更 design.md 文件清单（漏域先核对清单）。改写/取代已有行为 → 对应 FR 块加承接行；新行为 → 新 FR 块。superseded 条目默认不列（历史回溯自行读 knowledge/fr/）。依据决策（L2）= 当年取舍锚——翻案须先读 knowledge/decisions/<域>.md 的否决理由，满足复潮条件走 D-xxx@vN+1，不得静默改行为。承接行可带退役理由：`承接: FR-<域>-NNN（退役理由：一句话）`——归档时写进被取代条目（理由内禁逗号）；条目正文是截断摘要，全文锚（全文：<归档路径>#FR-NN）由 CLI 自动落。')
         promptText = promptText.replace(/\{FR_INDEX_DIGEST\}/g, lines.join('\n'))
       }
       try {

package/src/run/quick-audit.js

@@ -145,7 +145,7 @@ export function printQuickAuditReview(review) {
     if (review.foreignSpecChurn.length > 6) console.warn(`   … 共 ${review.foreignSpecChurn.length} 个`)
   }
   if (review.eolOnlyFiles && review.eolOnlyFiles.length > 0) {
-    console.warn(`⚠️ ${review.eolOnlyFiles.length} 个文件仅行尾重写（内容零变化，gen:types/编辑器 CRLF 假 M——已剔出本会话审计）：${review.eolOnlyFiles.slice(0, 5).join('、')}${review.eolOnlyFiles.length > 5 ? ' 等' : ''}`)
+    console.warn(`⚠️ ${review.eolOnlyFiles.length} 个文件仅行尾重写（内容零变化，生成命令/编辑器 CRLF 假 M——已剔出本会话审计）：${review.eolOnlyFiles.slice(0, 5).join('、')}${review.eolOnlyFiles.length > 5 ? ' 等' : ''}`)
     console.warn(`   根治：.gitattributes 声明 text=auto eol=lf（或按文件类型钉死），生成器重写不再制造假 M`)
   }
   if (review.docsCheckHint && review.docsCheckHint.invalid > 0) {
@@ -415,7 +415,17 @@ export async function runQuickTestLintGate({ cwd, specBase, changedFiles = [], d
   // 倒推 B 模式兜底：审计口径为空时回退声明边界（文件早于会话启动被基线吸收的场景）
   const files = audited.length > 0 ? audited : (Array.isArray(declaredFiles) ? declaredFiles : [])
   const fileSource = audited.length > 0 ? '审计' : (files.length > 0 ? '声明边界兜底（倒推 B：文件早于会话启动被基线吸收）' : '无')
-  const codeFiles = files.filter(f => typeof f === 'string' && (f.startsWith('src/') || f.startsWith('test/')))
+  // 代码文件判定（2026-09-19 monorepo 子包实证修复：multi-agent-platform 回带收口 6 个
+  // sillyhub-daemon/src/**、frontend/src/** 文件被「纯 doc/配置」误判跳过实测）：旧口径只认
+  // 仓根 src/、test/ 前缀——monorepo 子包（<pkg>/src/**、backend/app/**.py）全漏。
+  // 新口径双通道，方向取「宁可多跑不可漏跑」（门禁漏跑=静默放行，多跑只是费一次实测）：
+  //   ① 路径段匹配：任意层出现 src / test / tests / __tests__ 段（src-guide 等长名不误蹭——按段全等）
+  //   ② 代码扩展名兜底：src/test 目录约定外的代码（backend/app/**.py、scripts/*.go 等）
+  const CODE_PATH_SEGMENT_RE = /(^|\/)(src|tests?|__tests__)(\/|$)/
+  const CODE_EXTENSION_RE = /\.(?:js|mjs|cjs|ts|tsx|jsx|py|pyw|go|rs|java|kt|kts|rb|php|cs|c|h|cpp|cc|hpp|swift|scala|groovy|vue|svelte)$/
+  const codeFiles = files.filter(
+    (f) => typeof f === 'string' && (CODE_PATH_SEGMENT_RE.test(f) || CODE_EXTENSION_RE.test(f)),
+  )
   if (files.length === 0) {
     return { action: 'skip', failed: [], reason: `无变更文件清单（${fileSource}口径均空——brownfield 无 guard 或空审计），跳过`, test: null, lint: null }
   }

package/src/run/verify-quality-scan.js

@@ -176,7 +176,7 @@ export async function renderVerifyTestAttribution({ cwd, changeName, specBase, r
             const { filterStaleBaselineOverlap } = await import('./gates.js')
             const actionable = filterStaleBaselineOverlap(overlap, dirtySet, foreignMap)
             if (actionable.length > 0) {
-              console.error(`   ℹ️ 归因提示②：本变更有 ${actionable.length} 个文件与主仓最近 10 条提交重叠且旧内容仍在工作区（${actionable.slice(0, 5).join(', ')}${actionable.length > 5 ? ' 等' : ''}）——若为生成产物（api-types 等），本变更可能在旧基线生成并覆盖了已合入内容；先在新基线重跑生成命令（如 gen:types）再复验。（重叠共 ${overlap.length} 个，其余未在工作区改动或属他者会话在途文件，已归提示①/无需处理）`)
+              console.error(`   ℹ️ 归因提示②：本变更有 ${actionable.length} 个文件与主仓最近 10 条提交重叠且旧内容仍在工作区（${actionable.slice(0, 5).join(', ')}${actionable.length > 5 ? ' 等' : ''}）——若为生成产物（类型生成/代码生成产物等），本变更可能在旧基线生成并覆盖了已合入内容；先在新基线重跑生成命令再复验。（重叠共 ${overlap.length} 个，其余未在工作区改动或属他者会话在途文件，已归提示①/无需处理）`)
             }
           }
         }

package/src/stages/brainstorm-auto.js

@@ -106,7 +106,7 @@ AC-002: 未修改数据库 schema
 AC-003: 未涉及鉴权/权限
 AC-004: 未扩大 allowed_paths
 AC-005: 未引入新外部依赖
-AC-006: 未修改核心模块（workflow/daemon/session/lifecycle）
+AC-006: 未修改核心模块（模块索引中被多方依赖或承担关键流程的模块）
 AC-007: 已有项目约定可复用
 AC-008: 不影响向后兼容
 AC-009: 不涉及数据迁移

package/src/stages/brainstorm.js

@@ -76,7 +76,10 @@ export const definition = {
       maxWaitRounds: 8,
       waitReason: '等待用户回答需求问题或澄清',
       waitOptions: ['回答见--answer', '信息够了，进入方案讨论'],
-      prompt: `通过对话探索需求细节、分析原型（如有）、判断拆分/批量、并对歧义点做需求澄清 Grill。本步骤合并了原有的对话探索、原型分析、需求范围评估、需求澄清 Grill 四个环节——按下方 A→D 顺序按需执行。提问遵守「一次只问一个」（见 D 节追问策略）：必须问的问题逐个问，能查代码/文档解决的不问；不要把多个歧义打包成一屏清单一次抛给用户（用户记不住、答不全，反而漏掉关键约束）；也不要为凑数把单个问题拖成多轮。
+      prompt: `### ⚡ 薄跑判定（P0-3，2026-09-20 对撞实验驱动——需求已收敛来源走全仪探索是纯税）
+**需求来源已收敛**（满足任一：--input 显式声明承接/已澄清/方案已定；fork 或关联会话已多轮澄清过本需求，你已能不问自答全部 P0 歧义；任务书/评审结论直接给定方案与边界）→ 本步可**薄跑**：A-D 节按已收敛事实直书结论（歧义零清单、范围直裁、决策若已有则引用源会话不重问），一次性完成不再多轮追问。薄跑不降质量底线：范围结论与决策落盘照常，仅省「明知故问」的交互轮。Grill（Step 7）与规范文件（Step 8）**不适用薄跑、永不省**。
+
+通过对话探索需求细节、分析原型（如有）、判断拆分/批量、并对歧义点做需求澄清 Grill。本步骤合并了原有的对话探索、原型分析、需求范围评估、需求澄清 Grill 四个环节——按下方 A→D 顺序按需执行。提问遵守「一次只问一个」（见 D 节追问策略）：必须问的问题逐个问，能查代码/文档解决的不问；不要把多个歧义打包成一屏清单一次抛给用户（用户记不住、答不全，反而漏掉关键约束）；也不要为凑数把单个问题拖成多轮。
 
 ### A. 原型/设计图分析（如用户提供）
 如果用户提供了截图、图片或 HTML 原型，先分析提取：
@@ -297,12 +300,12 @@ design.md 第一行标题必须用中文：# 设计文档（Design）— <变更
 
    **路径存在性核验（NEW: 前缀铁律，2026-09-17 用户反馈⑥-①前移）**：清单条目在「生成规范文件」步 \`--done\` 门禁会逐一核验仓内存在性——**计划新建的文件必须在路径前加 \`NEW:\` 前缀**（冒号后不加空格，\`NEW:src/foo.js\` 合法、\`NEW: src/foo.js\` 属书写错误）；未加前缀的新建路径会以 \`design_file_ref_invalid\`（幻觉路径/书写错误）在末步被拦，返工一轮。已有文件写仓根相对正斜杠路径，禁绝对路径/glob。
    **字段数据流标注**（避免新增字段到 execute 才发现没透传）：当清单含「新增/修改对外字段、接口、DTO、响应体、事件 payload、配置键」时，对应行「说明」列必须交代 producer→consumer 数据流——产出方（producer）→ 每跳流转/归一化点（序列化/反序列化/字段映射/默认值兜底）→ 消费方（consumer）。漏标 = 字段在某跳 dormant（声明了却没透传），到 execute/verify 才暴露，属设计层缺口。
-   - 示例：「修改 daemon.ts：新增 budget_tokens，producer=backend/api-types.ts → ws_hub envelope 透传 → daemon.ts normalizeUsage（snake→camel）→ consumer=runtime/lease.ts 写 lease」
+   - 示例：「修改 api/server.ts：新增 quota_remaining 字段，producer=服务端 types/api.ts → 消息 envelope 透传 → 客户端 normalize（snake→camel）→ consumer=runtime/quota.ts 写入」
    - 仅改内部实现、无对外字段变动时，说明列照常写「新增 xx 方法」即可，无需数据流。
 
    **跨仓变更写法**（本次变更涉及 local.yaml repos: 注册的其他仓时必读；纯主仓变更跳过）：
-   - 清单**按仓分段**：每个仓一个小节，标题格式固定 \`## <repo-key> 仓变更\`（如 \`## sub-grid-security 仓变更\`；可加编号前缀或（跨仓，X1-X4）这类括号备注后缀，其余后缀/写法解析不了）。plan-postcheck 文件覆盖对账按此段头解析仓归属，写成「前端仓 / backend」等其他标题 → 对账不上且会点名段头格式错误
-   - 段内路径相对**该仓根**写（\`src/routes/x.js\`）；❌ 禁止带仓库名前缀（\`sub-grid-security/src/routes/x.js\`）、❌ 禁止绝对路径/盘符路径（\`C:/repo/src/...\`）——后续 TaskCard 的 allowed_paths 与 review 对账（\`git -C <仓根> diff\` 产仓根相对路径）都用同一口径，前缀/绝对路径永不命中
+   - 清单**按仓分段**：每个仓一个小节，标题格式固定 \`## <repo-key> 仓变更\`（如 \`## user-service 仓变更\`；可加编号前缀或（跨仓，X1-X4）这类括号备注后缀，其余后缀/写法解析不了）。plan-postcheck 文件覆盖对账按此段头解析仓归属，写成「前端仓 / backend」等其他标题 → 对账不上且会点名段头格式错误
+   - 段内路径相对**该仓根**写（\`src/routes/x.js\`）；❌ 禁止带仓库名前缀（\`<repo-key>/src/routes/x.js\`）、❌ 禁止绝对路径/盘符路径（\`C:/repo/src/...\`）——后续 TaskCard 的 allowed_paths 与 review 对账（\`git -C <仓根> diff\` 产仓根相对路径）都用同一口径，前缀/绝对路径永不命中
    - 主仓文件放在第一个段头之前（无段头区域 = main），或单独写 \`## main 仓变更\` 段
    - repo-key 必须是 local.yaml repos: 段已注册的键（未注册先跑 \`sillyspec local register-repo <key> <仓根路径>\`，main 隐式不用注册）
 

package/src/stages/execute.js

@@ -886,7 +886,7 @@ export function buildWavePrompt(wave, waveIndex, changeDir, worktreePath, option
         if (relevantContracts.length > 0) {
           contractInjection = `
 ### API Contract Matrix
-本 Wave 存在前端/后端跨 task 契约：
+本 Wave 存在跨 task 契约（provider → consumer）：
 ${relevantContracts.map(c => `- **${c.consumer}** 消费 **${c.provider}** 产出的 API`).join('\n')}
 `
           for (const taskName of waveTasks) {
@@ -1236,7 +1236,7 @@ ${workdirLines}
 
 ⚠️ **铁律：spec 流程产物只写主仓 {SPEC_ROOT}，绝不写进 worktree 副本**——包括 module-impact.md / knowledge 条目 / 模块卡与 \`<module>.changelog.md\` sidecar。在 worktree 内发现 \`.sillyspec/\` 目录是 checkout 副本，写进去的任何内容都会随 worktree cleanup 整目录蒸发（2026-09-10 实证：模块文档写副本、归档被迫 checkout 补救）。子代理 prompt 中涉及此类产物时，必须原样带上主仓绝对路径。
 
-⚠️ **Python 后端导入链陷阱（venv editable install，2026-09-18 实证 gen:types 坑）**：worktree 内跑任何 \`import app\` / dump_openapi / gen:types 类命令时，若用的是主仓 venv（junction 链接或裸调主仓 python），其 editable install（\`_editable_impl_*.pth\`）指向**主仓**绝对路径——\`import app\` 会静默解析到主仓旧代码，产出旧 schema/旧行为且零报错（看似「后端没生效」）。**跑生成链前设 \`PYTHONPATH=<worktree>/backend\`**（PYTHONPATH 优先于 .pth），或用 worktree 自建 venv；\`sillyspec worktree doctor\` 的 editable-install-escape 检查可提前暴露。
+⚠️ **Python 导入链陷阱（venv editable install，2026-09-18 实证）**：worktree 内跑任何 \`import <项目包>\` / dump_openapi / 代码生成类命令时，若用的是主仓 venv（junction 链接或裸调主仓 python），其 editable install（\`_editable_impl_*.pth\`）指向**主仓**绝对路径——项目包 import 会静默解析到主仓旧代码，产出旧 schema/旧行为且零报错（看似「改动没生效」）。**跑生成链前设 \`PYTHONPATH=<worktree>/<项目源码根>\`**（PYTHONPATH 优先于 .pth），或用 worktree 自建 venv；\`sillyspec worktree doctor\` 的 editable-install-escape 检查可提前暴露。
 `
       : ''
   }

package/src/stages/plan.js

@@ -92,7 +92,7 @@ const stepClassify = {
 判定为 full（满足任一即升为 full）：
 - 预计 8 个以上 task
 - 跨 3 个以上模块
-- 涉及 CLI + 平台 + DB 联动
+- 跨技术层联动（同一变更需多层协同改造，如前端 + 服务端 + 数据库）
 - 涉及 agent 调度 / worktree / isolation 逻辑
 - 涉及复杂状态恢复（checkpoint / resume）
 - 需要并行 sub-agent 执行
@@ -387,7 +387,7 @@ execute/verify 阶段会按实际代码变更更新此文档；archive 阶段会
 // ═══════════════════════════════════════════════════════════════
 
 /**
- * 构建紧凑 TaskCard 协调器步骤（单步，子代理按 batch 并行写卡片）
+ * 构建紧凑 TaskCard 协调器步骤（默认主 agent 直填；>8 任务且跨模块/上下文紧张时按 batch 派子代理）
  * 每个 task 生成 20~40 行紧凑可执行卡片
  * 允许把多个相关 task 合并为一个 batch，由单个子代理一次生成多张卡片，
  * 在保留 plan 任务拆分完整性的同时减少子代理调用数量。
@@ -416,7 +416,7 @@ allowed_paths:                            # ⚠️ 路径相对 repo 声明的
 target_files:                             # 可选。本 task 计划要改动的文件清单（文件级意图，供对账；与 allowed_paths 语义不同——那是权限范围）。骨架已预置 [] 占位行，无明确意图保留 [] 不动
   - src/foo.js                            # ✅ 精确仓根相对路径（口径同 allowed_paths）；计划新建文件加 NEW: 前缀（NEW:src/bar.js）。❌ 禁 glob（src/**）/目录前缀（src/dir/）/绝对路径
 provides:                              # 可选。仅当本 task 给其他 task 提供接口/DTO/响应时填
-  - contract: <DTO或响应类型名>          # 如 DaemonRuntimeRead
+  - contract: <DTO或响应类型名>          # 如 UserDTO
     fields: [field_a, field_b]
 expects_from:                          # 可选。仅当本 task 消费其他 task 的契约时填
   <provider-task-id>:                  # 如 task-05（占位符，不要照抄）
@@ -439,7 +439,7 @@ constraints:
   - 边界约束 2（如：不修改传入参数）
 related_tests:                           # 可选。当本 task 改动会导致既有测试断言失效时填（共享源文件/UI文案/常量/签名变更等，判据=测试是否失败非文件是否共享）
   - path: frontend/src/lib/errors.test.ts # 因本次改动断言失效的既有测试文件
-    reason: 旧断言假设单例，改归属键后需同步
+    reason: 旧断言依赖本次要重构掉的实现细节，需同步
 ---
 
 {{include: taskcard-rules}}`
@@ -472,17 +472,21 @@ ${taskList}
    \`\`\`
    幂等，已存在的卡跳过不覆盖；骨架带 LF 行尾 + 闭合 frontmatter + 硬校验 9 字段 + depends_on 反填。**只有主 agent 跑这一次，子代理一律不再运行 taskcard CLI。**
 1. 确认 \`${changeDir}/tasks/\` 目录存在（上一步预生成会自动创建）
-2. **按 batch 分派子代理（减少总子代理数量，而不是一个 task 一个子代理）：**
+2. **默认主 agent 自己填卡（P0-2，2026-09-20 对撞实验驱动——6 个填卡子代理 6.7M token 做的是主 agent 可自完成的誊写，独立性价值为零）：**
+   - task 总数 ≤8 或变更单仓单模块 → 主 agent 逐卡 Edit 填充（骨架已预生成，誊写近乎免费），**不派子代理**
+   - 仅当 task 总数 >8 **且**跨多模块/跨仓、或主会话上下文已明显吃紧时，才按 batch 分派子代理（此时并行省墙钟有真实收益）
+3. **（分派形态时）按 batch 分派子代理（减少总子代理数量，而不是一个 task 一个子代理）：**
    - 把任务按「同一 Wave + 同一模块/相近能力 + 无跨 batch 强依赖」原则分组
    - **每个 batch 包含 2~4 个 task**；Wave 内任务数 ≤4 时整个 Wave 可作为一个 batch
    - 有提供/消费契约的 task 尽量放到同一 batch（子代理能同时看到 consumer 与 provider，避免契约字段漏配）
    - 跨 Wave 依赖的 task 不要放在同一 batch（子代理只需读 plan.md，但 batch 内 task 的 allowed_paths 不应互相阻塞）
-3. 为每个 batch 启动一个独立子代理（Agent tool），可并行启动多个 batch
-4. 每个子代理使用下方「批量 TaskCard 子代理 prompt」，一次生成该 batch 的全部 task-N.md
-5. 等待所有 batch 子代理完成
-6. 验证每个 task-N.md 文件已生成且非空
+   - batch 数量封顶 ≤3（13 任务≈3 batch 已足；再多是协调税）
+4. 为每个 batch 启动一个独立子代理（Agent tool），可并行启动多个 batch
+5. 每个子代理使用下方「批量 TaskCard 子代理 prompt」，一次生成该 batch 的全部 task-N.md
+6. 等待所有 batch 子代理完成
+7. 验证每个 task-N.md 文件已生成且非空
 
-> 设计意图：plan.md 里 task 数可以较多（能力拆分完整），但 TaskCard 生成阶段要合理合并，避免子代理数量随 task 数线性爆炸。一个子代理生成 2~4 张卡片与生成 1 张卡片的 token/时间成本接近，却能显著减少协调开销。
+> 设计意图：plan.md 里 task 数可以较多（能力拆分完整），但 TaskCard 生成阶段的**默认形态是主 agent 直填**——卡是 design/plan 的誊写不是创作，主 agent 刚写完 plan 上下文最热；子代理只在规模/上下文压力真实存在时才有净收益（每个子代理都要重读 design+plan+源码，6 个子代理 6.7M token 的实证教训）。分派时合并 batch，避免子代理数量随 task 数线性爆炸。
 
 ### 批量 TaskCard 子代理 prompt
 \`\`\`
@@ -510,7 +514,7 @@ ${taskcardTemplate}
 ## 约束
 - 每个 task 20~40 行；禁止在 TaskCard 里写实现细节之外的冗长设计
 - 同 batch 内 task 的 allowed_paths 不要互相冲突
-- **跨仓 task 路径口径（涉及 local.yaml repos: 注册仓的变更必读）**：跨仓 task frontmatter 必须填 \`repo: <repo-key>\`（local.yaml repos: 注册键，缺省=main 省略不填）；allowed_paths 相对**该仓根**写（\`src/routes/x.js\`），从 design.md「\`## <repo-key> 仓变更\`」段内路径原样搬。❌ 禁止带仓库名前缀（\`sub-grid-security/src/...\`）、❌ 禁止绝对路径/盘符（\`C:/repo/src/...\`）——review 对账按 \`git -C <仓根> diff\` 的仓根相对路径匹配 allowed_paths，带前缀/绝对路径永不命中 → task 改完却判「无归属」对账不上
+- **跨仓 task 路径口径（涉及 local.yaml repos: 注册仓的变更必读）**：跨仓 task frontmatter 必须填 \`repo: <repo-key>\`（local.yaml repos: 注册键，缺省=main 省略不填）；allowed_paths 相对**该仓根**写（\`src/routes/x.js\`），从 design.md「\`## <repo-key> 仓变更\`」段内路径原样搬。❌ 禁止带仓库名前缀（\`<repo-key>/src/...\`）、❌ 禁止绝对路径/盘符（\`C:/repo/src/...\`）——review 对账按 \`git -C <仓根> diff\` 的仓根相对路径匹配 allowed_paths，带前缀/绝对路径永不命中 → task 改完却判「无归属」对账不上
 - 若 task 之间有 provides/expects_from 契约，同 batch 生成时必须字段对齐
 - 只生成本 batch 声明的任务，不要多写或少写
 - 不要在 TaskCard 里泄露 plan.md 中未出现的实现假设
@@ -538,7 +542,7 @@ ${taskcardTemplate}
 
   return {
     id: 'generate_blueprints',
-    name: '生成 TaskCard（子代理按 batch 并行）',
+    name: '生成 TaskCard（默认主代理直填，大规模才派 batch）',
     prompt,
     outputHint: 'TaskCard 生成结果',
     optional: false

package/src/stages/scan.js

@@ -289,7 +289,7 @@ modules:
 ### 示例
 \`\`\`yaml
 schema_version: 2
-project: multi-agent-platform
+project: demo-platform
 source_commit: abc1234
 generated_at: 2026-06-02 22:00:00
 generator: sillyspec-scan