sillyspec 3.32.0 → 3.32.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sillyspec",
-  "version": "3.32.0",
+  "version": "3.32.1",
   "description": "SillySpec CLI — 流程状态机，让 AI 严格按步骤来",
   "icon": "logo.jpg",
   "homepage": "https://sillyspec.ppdmq.top/",

package/src/flow-parity.js

@@ -10,15 +10,21 @@
  *    厚道有轻量变更缺的审计资产；机器合成勿手改。
  * ③ harvestSlot4Decision：design 槽4（风险与死路）实质作答收割合成 decisions.md——轻量变更决策
  *    产出为零的补口（死路与风险取舍正是 decisions.md 该记的内容；已有文件不覆盖）。
+ * ④ writeCloseTraceArtifacts / buildThinSnapshotRows：双通道收尾留痕统一写
+ *    （2026-10-07-unify-close-trace）——thin flow done 与 heavy execute --done 共用一处一次
+ *    写齐四件（沉淀资产面 + 对账快照面，sha256 双套同锚），新变更两通道留痕对称。
  */
 import { existsSync, readFileSync, writeFileSync, readdirSync } from 'node:fs'
 import { join, relative } from 'node:path'
+import { createHash } from 'node:crypto'
 import { execFileSync } from 'node:child_process'
 import { splitOwnVsForeignDiffFiles, commitAttributionForChange, isForeignByCommit, parseChangeNamesFromSubject } from './foreign-declared.js'
 import { collectModuleMaps, normalizeMapPath } from './module-resolve.js'
 import { writeAtomicSync } from './fs-atomic.js'
 import { readV2SectionAnswer } from './flow-review.js'
 import { DESIGN_QUESTIONS } from './flow-draft.js'
+import { pathMatches } from './change-list.js'
+import { classifyToolScaffold, filterDeliverableFiles } from './worktree-apply.js'
 
 /**
  * 模块文档对账（advisory）+ 结构化落盘面（2026-09-27-thin-module-scope-persist）。
@@ -252,7 +258,11 @@ export function collectFreezeFiles({ cwd, specBase, change, committed, exclusive
   const deliverable = (f) => !String(f).replace(/\\/g, '/').startsWith('.sillyspec/')
   let dirty = []
   try {
-    const out = execFileSync('git', ['status', '--porcelain'], { cwd, encoding: 'utf8', timeout: 30000, windowsHide: true })
+    // -uall（2026-10-08-thin-done-dirty-gate-and-paren-attribution）：全新目录会折叠成
+    // `dir/` token（porcelain 缺省形态）——readFileSync(目录) 静默 skip，--freeze-dirty
+    // 声称并入却漏目录内交付文件（dg-freeze 夹具实证 src/ 折叠）。逐文件展开与
+    // scope-audit/flow.js 状态采集口径对齐。
+    const out = execFileSync('git', ['status', '--porcelain', '--untracked-files=all'], { cwd, encoding: 'utf8', timeout: 30000, windowsHide: true })
     for (const line of String(out).split('\n')) {
       if (!line || line.length < 4) continue
       const p = line.slice(3).trim().replace(/^"|"$/g, '')
@@ -272,6 +282,132 @@ export function collectFreezeFiles({ cwd, specBase, change, committed, exclusive
   return { files: [...committed], dirtyAdded: [], dirtyWarned: ownDirty }
 }
 
+/**
+ * thin 通道三态行构造（writeCloseTraceArtifacts 的 snapObj.rows 数据源，纯函数）：
+ * ownFiles 过 filterDeliverableFiles（与 scope-audit actual 侧同口径——治理工件目录不进
+ * 快照行）× design 清单 pathMatches 判三态（planned/unplanned；与主链路三态判定同款）；
+ * stats（collectNumstatByPath 产物 Map）缺档落 null 行数（不出伪数据）；planEntries 空/缺省
+ * → 实际侧 only 行（无 verdict，与主链路计划侧降级同语义）。清单条目未命中冻结面 →
+ * untouched 0/0 补行（跨仓条目带 crossRepo 保持 ⊘ 形态，主链路补行同语义）。
+ * @returns {{ rows: Array<object>, totals: { files: number, additions: number, deletions: number } }}
+ */
+export function buildThinSnapshotRows({ ownFiles, stats, planEntries }) {
+  const plan = Array.isArray(planEntries) ? planEntries : []
+  const statMap = stats instanceof Map ? stats : new Map()
+  const rowFiles = filterDeliverableFiles([...new Set((Array.isArray(ownFiles) ? ownFiles : [])
+    .map((f) => String(f).replace(/\\/g, '/')).filter(Boolean))]).sort()
+  const rows = []
+  const matched = new Set()
+  for (const f of rowFiles) {
+    const st = statMap.get(f) || {}
+    const row = {
+      path: f,
+      additions: Number.isFinite(st.additions) ? st.additions : null,
+      deletions: Number.isFinite(st.deletions) ? st.deletions : null,
+      kind: st.kind || 'modified',
+    }
+    if (plan.length > 0) {
+      const entry = plan.find((e) => e && pathMatches(f, e.path))
+      if (entry) {
+        matched.add(entry.path)
+        row.planned = entry.operation || null
+        row.verdict = 'planned'
+      } else {
+        row.planned = null
+        row.verdict = 'unplanned'
+        const facility = classifyToolScaffold(f)
+        if (facility) row.facility = facility
+      }
+    }
+    rows.push(row)
+  }
+  for (const e of plan) {
+    if (!e || matched.has(e.path)) continue
+    rows.push({
+      path: e.path, planned: e.operation || null, additions: 0, deletions: 0,
+      kind: 'modified', verdict: 'untouched',
+      ...(e.repo ? { crossRepo: e.repo } : {}),
+    })
+  }
+  let additions = 0
+  let deletions = 0
+  for (const r of rows) {
+    if (Number.isFinite(r.additions)) additions += r.additions
+    if (Number.isFinite(r.deletions)) deletions += r.deletions
+  }
+  return { rows, totals: { files: rows.length, additions, deletions } }
+}
+
+/**
+ * heavy 通道沉淀资产面投影（writeCloseTraceArtifacts 的 files/totals 数据源，纯函数；
+ * 2026-10-07-unify-close-trace，评审 P3 覆盖清偿抽纯函数）：rows → 主仓实改行——
+ * untouched 0/0 是声明不是改动、crossRepo 行 patch 不在主仓，均不入；verdict 缺失行
+ * （计划侧降级形态）按实改保留；null 行数不计合计（不出伪数据）。
+ * @returns {{ rows: object[], files: string[], totals: { files: number, additions: number, deletions: number } }}
+ */
+export function projectTraceFaceRows(rows) {
+  const face = (Array.isArray(rows) ? rows : [])
+    .filter((r) => r && typeof r === 'object' && !r.crossRepo && r.verdict !== 'untouched')
+  let additions = 0
+  let deletions = 0
+  for (const r of face) {
+    if (Number.isFinite(r.additions)) additions += r.additions
+    if (Number.isFinite(r.deletions)) deletions += r.deletions
+  }
+  return { rows: face, files: face.map((r) => r.path), totals: { files: face.length, additions, deletions } }
+}
+
+/**
+ * 双通道收尾留痕统一写（2026-10-07-unify-close-trace，缺陷 thin-flow-done-no-scope-
+ * audit-snapshot 修复方向③）：thin（flow done）与 heavy（execute --done）此前各写各的
+ * 留痕（沉淀资产面 change.patch/change-patch.json vs 对账快照面 scope-audit.patch/
+ * scope-audit.json），消费方各认一份致每类变更恰好一张卡失真——本函数一处写齐四件，
+ * sha256/patchStatus 双套同锚（同一 patchText 一次计算：change.patch ≡ scope-audit.patch
+ * 字节一致、两 json 同 hash，两套留痕不可能漂移）。patchText 空/null → 双套同标 failed、
+ * 不落 patch 文件（heavy 旧「空串当 ok」形态收口）。读侧兼容链（快照 > change-patch
+ * 回放 > 实时区间，2026-10-07-scope-audit-thin-patch-replay）不动——本函数让新变更两套
+ * 齐备，回退退化为存量归档兜底。
+ *
+ * @param {string} changeDir 变更目录（活跃或归档侧——归档竞态由调用方解析）
+ * @param {object} snapObj scope-audit.json 主体（mode/ok/degradedReason/baseAnchor/totals/
+ *   rows/excluded/note[/repos]；closedBy 由调用方携带标收尾通道——读侧回放按它标注，
+ *   缺省 'execute --done' 兼容旧快照）
+ * @param {object} meta change-patch.json 增量键（note/moduleScope 等，展开在 totals 后）
+ * @returns {{ patchStatus: 'ok'|'failed', patchSha256: string|null }}
+ */
+export function writeCloseTraceArtifacts({ changeDir, change, baseline, head, files, metaTotals, patchText, savedAt, snapObj, meta = {} }) {
+  const fileList = Array.isArray(files) ? files : []
+  const patchOk = typeof patchText === 'string' && patchText.length > 0
+  const patchBody = patchOk ? (patchText.endsWith('\n') ? patchText : patchText + '\n') : null
+  const patchSha256 = patchBody
+    ? createHash('sha256').update(patchBody.replace(/\r\n/g, '\n'), 'utf8').digest('hex')
+    : null
+  if (patchOk) {
+    writeFileSync(join(changeDir, 'change.patch'), patchBody)
+    writeFileSync(join(changeDir, 'scope-audit.patch'), patchBody)
+  }
+  writeFileSync(join(changeDir, 'change-patch.json'), JSON.stringify({
+    change,
+    baseline: baseline ?? null,
+    head: head ?? null,
+    files: fileList,
+    totals: metaTotals && typeof metaTotals === 'object'
+      ? metaTotals
+      : { files: fileList.length, additions: 0, deletions: 0 },
+    savedAt,
+    ...meta,
+    ...(patchSha256 ? { patchSha256 } : {}),
+    patchStatus: patchOk ? 'ok' : 'failed',
+  }, null, 2) + '\n')
+  writeFileSync(join(changeDir, 'scope-audit.json'), JSON.stringify({
+    ...snapObj,
+    ...(patchSha256 ? { patchSha256 } : {}),
+    patchStatus: patchOk ? 'ok' : 'failed',
+    savedAt,
+  }, null, 2) + '\n')
+  return { patchStatus: patchOk ? 'ok' : 'failed', patchSha256 }
+}
+
 /**
  * 实测面回填（修复③：ledger 子步断点续跑 skip 后回执不失忆）——从 verify-runs 最近
  * test-result.json（带 change 键）重建摘要；无匹配返回 null。

package/src/flow.js

@@ -26,7 +26,6 @@
  * 幂等循 task-done 先例：子步各查自身完成标记，中断半态重入断点续，中段失败精确报告。
  */
 import { existsSync, readFileSync, writeFileSync, readdirSync, appendFileSync, renameSync, statSync } from 'node:fs'
-import { createHash } from 'node:crypto'
 import { join, relative, dirname } from 'node:path'
 import yaml from 'js-yaml'
 import { git, gitQuiet } from './git-helper.js'
@@ -863,7 +862,7 @@ export function remainingSubstepsAtFail({ snapshotSubsteps = {}, doneList = [],
   return SUBSTEPS.filter((k) => k !== failed && snapshotSubsteps?.[k] !== 'done' && !doneNow.has(k))
 }
 
-export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null, confirmArchive = true, freezeDirty = false, allowBatchTick = false }) {
+export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null, confirmArchive = true, freezeDirty = false, acceptDirtyGap = false, allowBatchTick = false }) {
   const changeDir = join(specBase, 'changes', change)
   const st = readFlowState(changeDir)
   if (!st) {
@@ -1396,11 +1395,30 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
         }
         if (freeze.dirtyWarned.length > 0) {
           console.warn(`⚠️ ${freeze.dirtyWarned.length} 个未提交交付文件未入冻结面（共享主仓无法归属）——三选一：`)
-          console.warn(`   ① 本次接受缺口（审计面少这些文件）② 确认全部归属本变更：重跑 flow done --freeze-dirty 并入冻结 ③ 下次用会话专属 worktree。Git 中间提交可归档后压扁（见收口指引）`)
+          console.warn(`   ① 先提交这些文件（信息尾缀带变更名）后重跑 ② 确认全部归属本变更：重跑 flow done --freeze-dirty 并入冻结 ③ 确认接受审计缺口：重跑 flow done --accept-dirty-gap（缺口数随 change-patch.json 留痕）。Git 中间提交可归档后压扁（见收口指引）`)
           console.warn(`   ${freeze.dirtyWarned.slice(0, 3).join('、')}${freeze.dirtyWarned.length > 3 ? ' 等' : ''}`)
+          // 收口阻断门（2026-10-08-thin-done-dirty-gate-and-paren-attribution，坑①修复：
+          // multi-agent-platform docs/sillyspec/thin-done-src-commit-order-and-attribution-paren.md）
+          // ——旧行为警告后继续归档，autopilot 单跑到底把三选一变成不可达选项（归档即拒收重入）。
+          // 缺口在场且未显式处置 → 停在 patch 子步标记之前（半态可重入，与 review 中断同款
+          // exit 语义）：处置后重跑，patch 全量重建自动并入已提交 src。
+          if (!freezeDirty && !acceptDirtyGap) {
+            console.error('⛔ 未提交交付缺口未显式处置——收口阻断（不归档；处置后重跑同一条命令从断点续）：')
+            console.error(`   ① git commit 这些文件（信息尾缀带 (${change}) 或 （${change}），重跑本命令——冻结面自动并入`)
+            console.error(`   ② 全部归属本变更：flow done --change ${change} --freeze-dirty`)
+            console.error(`   ③ 接受审计缺口：flow done --change ${change} --accept-dirty-gap`)
+            reportMidFail('patch')
+            process.exit(1)
+          }
+          if (acceptDirtyGap) {
+            // 双 flag 同给时 --freeze-dirty 优先（exclusive 路径 dirtyWarned 恒空，本分支不进
+            // ——设计接口契约已披露；无告警代码即无死代码，二轮评审 P3 清偿）
+            console.warn(`⚠️ --accept-dirty-gap：显式接受 ${freeze.dirtyWarned.length} 个未提交交付文件不进冻结面（缺口数随 change-patch.json acceptedDirtyGap 留痕）`)
+          }
         }
         const ownFiles = [...new Set([...freeze.files, ...changeDirFiles])]
-          .filter((f) => f && !f.endsWith('change.patch') && !f.endsWith('change-patch.json'))
+          .filter((f) => f && !f.endsWith('change.patch') && !f.endsWith('change-patch.json')
+            && !f.endsWith('scope-audit.json') && !f.endsWith('scope-audit.patch'))
         if (ownFiles.length === 0) {
           console.log('📦 patch 留档跳过：本变更可归属文件面为空')
           patchOk = true
@@ -1416,7 +1434,8 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
           // diff 能捕捉提交后编辑）∪ 独占树未提交交付（dirtyAdded）；其余交付面走提交区间。
           // 排除项与 ownFiles 同款（change.patch/change-patch.json）——否则上一轮冻结件作为
           // untracked 新文件被全文自嵌入（自引用循环：旧 patch 内容混进新 patch，三评 P1 根因）。
-          const dirFilesForPatch = changeDirFiles.filter((f) => !f.endsWith('change.patch') && !f.endsWith('change-patch.json'))
+          const dirFilesForPatch = changeDirFiles.filter((f) => !f.endsWith('change.patch') && !f.endsWith('change-patch.json')
+            && !f.endsWith('scope-audit.json') && !f.endsWith('scope-audit.patch'))
           const worktreeSet = new Set([...dirFilesForPatch, ...((freeze.dirtyAdded) || [])].map(toPosix))
           const committedFace = freeze.files.map(toPosix).filter((f) => !worktreeSet.has(f))
           const frozenCommitted = buildFrozenPatch(cwd, committedFace, { baseRef: st.baseline_commit, headRef: headCommit })
@@ -1445,28 +1464,46 @@ export async function cmdFlowDone({ change, cwd, specBase, runtimeRootOpt = null
             if (rec.lines.length > 0) for (const l of rec.lines) console.log(l)
             moduleScope = { modules: rec.modules, uncoveredDirs: rec.uncoveredDirs, moduleMaps: rec.moduleMaps }
           } catch { /* 对账 best-effort（三键空数组兜底） */ }
-          const meta = {
+          // 双通道收尾留痕统一（2026-10-07-unify-close-trace）：共用 writeCloseTraceArtifacts
+          // 一次写齐四件——沉淀资产面（change.patch + change-patch.json，键结构/口径不变）+
+          // 对账快照面（scope-audit.json + scope-audit.patch，thin 通道新增）：同点同锚
+          // （同一 patchText 一次 sha256），新变更两条通道留痕对称，读侧回退退化为存量兜底。
+          let planEntries = []
+          try {
+            const { parseFileChangeListDetailed } = await import('./change-list.js')
+            planEntries = parseFileChangeListDetailed(join(changeDir, 'design.md'), { keepSillyspecDocs: true })
+          } catch { /* 清单缺失/不可解析 → 实际侧 only 快照行（无 verdict，与主链路降级同语义） */ }
+          const { buildThinSnapshotRows, writeCloseTraceArtifacts } = await import('./flow-parity.js')
+          const { rows: snapRows, totals: snapTotals } = buildThinSnapshotRows({ ownFiles, stats, planEntries })
+          const closeTrace = writeCloseTraceArtifacts({
+            changeDir,
             change,
             baseline: st.baseline_commit,
             head: typeof head === 'string' ? head.trim() : null,
             files: ownFiles,
-            totals: { files: ownFiles.length, additions, deletions },
+            metaTotals: { files: ownFiles.length, additions, deletions },
+            patchText: typeof frozen === 'string' && frozen ? frozen : null,
             savedAt: new Date().toISOString(),
-            note: 'flow done 时点冻结（本变更可归属面：baseline..HEAD 提交面过滤 .sillyspec/ 非本变更目录但保留 .sillyspec/docs/ 交付文档 + 本变更目录工作树件；含未提交与 untracked，排除 flow-state.yaml 运行态）',
-            // 模块对账结构化面（2026-09-27-thin-module-scope-persist）：done 时点口径（与 files[]
-            // 同时点语义，不随模块图后续变更回写）；modules[] 空≠无影响（可能未登记——看 uncoveredDirs）
-            ...moduleScope,
-          }
-          if (typeof frozen === 'string' && frozen) {
-            const patchText = frozen.endsWith('\n') ? frozen : frozen + '\n'
-            writeFileSync(join(changeDir, 'change.patch'), patchText)
-            meta.patchSha256 = createHash('sha256').update(patchText.replace(/\r\n/g, '\n'), 'utf8').digest('hex')
-            meta.patchStatus = 'ok'
-          } else {
-            meta.patchStatus = 'failed'
-          }
-          writeFileSync(join(changeDir, 'change-patch.json'), JSON.stringify(meta, null, 2) + '\n')
-          console.log(`📦 变更 patch 留档：change.patch + change-patch.json（${ownFiles.length} 文件，+${additions}/-${deletions}${meta.patchStatus === 'ok' ? '，sha256 已锚' : '——patch 采集失败已留痕'}）`)
+            snapObj: {
+              mode: 'full-flow', ok: true, degradedReason: null,
+              baseAnchor: st.baseline_commit || null,
+              totals: snapTotals,
+              rows: snapRows,
+              excluded: { foreignDeclared: [] },
+              note: 'flow done 时点冻结（本文件落盘时采集）',
+              closedBy: 'flow done',
+            },
+            meta: {
+              note: 'flow done 时点冻结（本变更可归属面：baseline..HEAD 提交面过滤 .sillyspec/ 非本变更目录但保留 .sillyspec/docs/ 交付文档 + 本变更目录工作树件；含未提交与 untracked，排除 flow-state.yaml 运行态）',
+              // 模块对账结构化面（2026-09-27-thin-module-scope-persist）：done 时点口径
+              // （与 files[] 同时点语义，不随模块图后续变更回写）；modules[] 空≠无影响
+              ...moduleScope,
+              // dirty 缺口显式接受留痕（2026-10-08-thin-done-dirty-gate-and-paren-attribution）：
+              // --accept-dirty-gap 放行时缺口数入档（审计面可见，非只 console）
+              ...(acceptDirtyGap && freeze.dirtyWarned.length > 0 ? { acceptedDirtyGap: freeze.dirtyWarned.length } : {}),
+            },
+          })
+          console.log(`📦 变更 patch 留档（双轨统一）：change.patch + change-patch.json（${ownFiles.length} 文件，+${additions}/-${deletions}）+ scope-audit.json + scope-audit.patch（对账快照同点冻结）${closeTrace.patchStatus === 'ok' ? '，sha256 已锚' : '——patch 采集失败已留痕'}`)
           // design 声明面自证（2026-09-25-platform-feedback-batch2 E）：design.md 文件变更清单
           // 声明的交付文件是否都在冻结面——不在=承诺改了但没交付（承诺未兑现面，advisory 不
           // 阻断——可能是范围裁剪了但 design 没同步更新）
@@ -2051,7 +2088,7 @@ export async function cmdFlow(args, cwd, specDir = null, opts = {}) {
         console.log('🔄 --refreeze：patch 子步标记已重置，本次 done 将重新冻结（change.patch 按 baseline..HEAD 最新面重建）')
       }
     }
-    return cmdFlowDone({ change, cwd, specBase, runtimeRootOpt, freezeDirty: hasFlag('--freeze-dirty'), allowBatchTick: hasFlag('--allow-batch-tick') })
+    return cmdFlowDone({ change, cwd, specBase, runtimeRootOpt, freezeDirty: hasFlag('--freeze-dirty'), acceptDirtyGap: hasFlag('--accept-dirty-gap'), allowBatchTick: hasFlag('--allow-batch-tick') })
   }
   if (sub === 'amend-draft') {
     // 机器稿唯一留痕修改通道（R7 切片三 / FR-08）：重锚哈希 + ledger amendment 审计；

package/src/foreign-declared.js

@@ -204,12 +204,16 @@ function loadOwnDeclaredSet(specBase, runtimeRoot, currentChangeName) {
 
 /**
  * 提交标题 → 变更名数组（2026-10-05-diff-commit-attribution）：项目提交惯例 message 尾部
- * 携带 "(2026-MM-DD-名)" 后缀（多变更并列各自提取；归档提交 chore(archive): <名> 的标题
- * 首部同名形态不提取——归档提交触碰的是治理面移动，交付文件归属看交付提交）。
+ * 携带变更名括号后缀（多变更并列各自提取；归档提交 chore(archive): <名> 的标题首部同名
+ * 形态不提取——归档提交触碰的是治理面移动，交付文件归属看交付提交）。
+ * 括号形态双收（2026-10-08-thin-done-dirty-gate-and-paren-attribution，坑
+ * thin-done-src-commit-order-and-attribution-paren：中文输入法惯例写全角
+ * `（thin <名>；…）`，旧正则只认半角 → drift 归因静默失灵）：开/闭括号半全角任意组合，
+ * 括号内允许 `thin ` 前缀与名字后附注文本；变更名本体模式（日期前缀 + 白名单字符）不放宽。
  */
 export function parseChangeNamesFromSubject(subject) {
   const out = []
-  const re = /\((\d{4}-\d{2}-\d{2}-[A-Za-z0-9._-]+)\)/g
+  const re = /[（(]\s*(?:thin\s+)?(\d{4}-\d{2}-\d{2}-[A-Za-z0-9._-]+)[^()（）]*[)）]/g
   let m
   while ((m = re.exec(String(subject || '')))) out.push(m[1])
   return out

package/src/knowledge-stats.js

@@ -299,6 +299,45 @@ export async function cmdKnowledgeStats(dir, args, opts = {}) {
   const result = buildHitMatrix(knowledgeDir, runtimeDir, { sinceDays })
   const frIndex = buildFrIndexStats(knowledgeDir, runtimeDir, { sinceDays })
 
+  // --fr-only（2026-10-08-knowledge-stats-fr-only）：输出层过滤——仅保留 FR 索引段/键。
+  // 计算层保持全量（buildHitMatrix/buildFrIndexStats 签名与共用面零改动），flag 只影响渲染。
+  const frOnly = args.includes('--fr-only')
+  if (frOnly) {
+    if (asJson) {
+      // envelope 顶层键集与不带 --fr-only 时完全一致（outputJson 的外壳 schema_version/ok 不动），
+      // data 仅含 frIndex——跳过 matrix/conventions/neverHit/totalInjects/totalClassifies
+      outputJson(true, { sinceDays, hasTelemetry, lastEventAt, frIndex })
+      return
+    }
+    // 人类模式：仅渲染 FR 索引段（标题到承接引用率/裁决候选——不加遥测计数行和矩阵段）
+    const lines = []
+    if (frIndex.present) {
+      const e = frIndex.events
+      const i = frIndex.index
+      lines.push(`🔬 FR 索引实验（窗口内事件 / 索引面全量——L3 裁决指标，证伪条款见 2026-09-18-fr-index-l1 design）`)
+      lines.push(`  注入 fr-inject ${e.frInject} 次（${e.frInjectChanges} 变更） | 取代链 fr-supersede ${e.frSupersede} 次（${e.frSupersedeChanges} 变更） | 重复拦截 fr-duplicate-warning ${e.frDuplicateWarning} 次（${e.frDuplicateWarningCandidates || e.frDuplicateCandidates || 0} 候选）`)
+      lines.push(`  腐烂 suspect fr-rot-suspect ${e.frRotSuspect || 0} 次（${e.frRotSuspectChanges || 0} 变更${e.frRotSuspectByDomain && e.frRotSuspectByDomain.length > 0 ? `，按域 ${e.frRotSuspectByDomain.map(d => `${d.domain}×${d.count}`).join('，')}` : ''}）`)
+      if (e.frUnreferenced.length > 0) {
+        const top = e.frUnreferenced.slice(0, 5).map((u) => `${u.domain}×${u.count}`).join('，')
+        lines.push(`  删除缺口信号 fr-unreferenced：${top}${e.frUnreferenced.length > 5 ? ' …' : ''}（观察信号·不算 L3 门禁）`)
+      }
+      lines.push(`  索引面：${i.entries} 条（active ${i.active} / superseded ${i.superseded}）| 来源变更 ${i.sourceChanges} 个 | 域 ${i.domains.join(', ') || '—'}`)
+      lines.push(`  承接引用率：${frIndex.supersedeRate === null ? '—（索引空）' : `${(frIndex.supersedeRate * 100).toFixed(0)}%（${e.frSupersedeChanges}/${i.sourceChanges}，分子窗口内/分母全量——裁决用大窗口）`}`)
+      const cand = frIndex.adjudicationCandidates || []
+      if (cand.length > 0) {
+        lines.push('  裁决候选 Top-10（suspect×unref 条目级聚合——候选非裁决，确认无人承接→承接翻链或人工退休）：')
+        for (const c of cand.slice(0, 10)) {
+          lines.push(`    - ${c.id} suspect×${c.suspect} unref×${c.unreferenced}${c.change ? `（来源 ${c.change}）` : ''}`)
+        }
+      }
+    } else {
+      lines.push('（FR 索引面不存在——knowledge/fr/ 目录缺失或无条目；归档完整流程变更后此处可查）')
+    }
+    console.log(lines.join('\n'))
+    return
+  }
+  const asJsonBak = asJson // fr-only 已在上方 return 短路，此处原路径零改动
+  void asJsonBak
   if (asJson) {
     outputJson(true, { sinceDays, hasTelemetry, lastEventAt, ...result, frIndex })
     return

package/src/run/complete.js

@@ -18,9 +18,9 @@
  */
 import { join, isAbsolute, resolve } from 'node:path'
 import { existsSync, readFileSync, mkdirSync, writeFileSync, appendFileSync } from 'node:fs'
-import { createHash } from 'node:crypto'
 import { writeAtomicSync } from '../fs-atomic.js'
 import { gitQuiet } from '../git-helper.js'
+import { writeCloseTraceArtifacts, projectTraceFaceRows } from '../flow-parity.js'
 import { withFileLock } from '../quicklog.js'
 import { triggerSync, WAIT_MARKER_RE, getStageSteps, formatWaitOptions, resolveRuntimeRoot, getOrCreateMultiRepoContext, resolveChangeDir, writePlatformDocsPointer } from './shared.js'
 import { isExplicitReviewWrite, collectWorktreeChangedFiles } from '../task-review.js'
@@ -1109,16 +1109,27 @@ async function printExecuteScopeAudit({ cwd, changeName, specBase, platformOpts,
     mkdirSync(changeDir, { recursive: true })
     const { frozenPatch, ...snap } = result
     snap.note = 'execute --done 时点冻结（本文件落盘时采集）'
-    if (typeof frozenPatch === 'string') {
-      const patchText = frozenPatch.endsWith('\n') ? frozenPatch : frozenPatch + '\n'
-      writeFileSync(join(changeDir, 'scope-audit.patch'), patchText)
-      snap.patchSha256 = createHash('sha256').update(patchText.replace(/\r\n/g, '\n'), 'utf8').digest('hex')
-      snap.patchStatus = 'ok'
-    } else if (frozenPatch === null) {
-      snap.patchStatus = 'failed'
-    }
-    writeFileSync(join(changeDir, 'scope-audit.json'), JSON.stringify({ ...snap, savedAt: new Date().toISOString() }, null, 2) + '\n')
-    console.log(`   📦 范围快照已落变更目录（scope-audit.json${snap.patchStatus === 'ok' ? ' + scope-audit.patch（收尾时点冻结，sha256 已锚）' : snap.patchStatus === 'failed' ? '——patch 采集失败已留痕' : ''}）`)
+    snap.closedBy = 'execute --done'
+    // 沉淀资产面投影（2026-10-07-unify-close-trace）：files/totals = 主仓实改行（planned+
+    // unplanned；untouched 0/0 是声明不是改动、crossRepo 行 patch 不在主仓——均不入）。
+    // 经共用 writeCloseTraceArtifacts 与 thin flow done 同一处写四件（sha256 双套同锚）；
+    // 投影口径抽 flow-parity.projectTraceFaceRows 纯函数（排除路径有单测钉住）。
+    const face = projectTraceFaceRows(snap.rows)
+    const closeTrace = writeCloseTraceArtifacts({
+      changeDir,
+      change: changeName,
+      baseline: typeof snap.baseAnchor === 'string' ? snap.baseAnchor : null,
+      head: String(gitQuiet(cwd, ['rev-parse', 'HEAD']) || '').trim() || null,
+      files: face.files,
+      metaTotals: face.totals,
+      patchText: typeof frozenPatch === 'string' && frozenPatch ? frozenPatch : null,
+      savedAt: new Date().toISOString(),
+      snapObj: snap,
+      meta: {
+        note: 'execute --done 时点冻结（沉淀资产面：主仓实改行投影——thin flow done 对等；治理工件目录与其后 verify/archive 演进不在内）',
+      },
+    })
+    console.log(`   📦 范围快照 + 沉淀资产双轨落盘（scope-audit.json${closeTrace.patchStatus === 'ok' ? ' + scope-audit.patch' : ''} + change-patch.json${closeTrace.patchStatus === 'ok' ? ' + change.patch' : ''}${closeTrace.patchStatus === 'ok' ? '——收尾时点冻结，sha256 同锚' : '——patch 采集失败已留痕'}）`)
   } catch (e) {
     console.warn(`   ⚠️ 范围对账快照写入失败（不阻断，verify 漂移对比将按无快照降级）：${e && e.message ? String(e.message).split('\n')[0] : e}`)
   }

package/src/scope-audit.js

@@ -267,6 +267,72 @@ function readFrozenPatch(changeDir) {
   } catch { return null }
 }
 
+/**
+ * flow done 冻结记录读取（2026-10-07-scope-audit-thin-patch-replay）：change-patch.json 是
+ * thin 轻量变更 flow done 时点冻结的归属面（files/baseline/head/totals/patchSha256）——thin
+ * 通道不落 execute --done 快照，本件即其对账级冻结记录。缺 json / files 非数组 → null
+ * （调用方回退实时开放区间，不出伪数据）。
+ */
+function readChangePatchMeta(changeDir) {
+  if (!changeDir) return null
+  try {
+    const meta = JSON.parse(readFileSync(join(changeDir, 'change-patch.json'), 'utf8'))
+    if (meta && typeof meta === 'object' && Array.isArray(meta.files)) return meta
+  } catch { /* 缺失/损坏 → null */ }
+  return null
+}
+
+/**
+ * 冻结 patch 正文读取（thin 回放数据源）：变更目录 change.patch；缺失/空 → null。
+ * @returns {string|null}
+ */
+function readChangePatchText(changeDir) {
+  if (!changeDir) return null
+  try {
+    const text = readFileSync(join(changeDir, 'change.patch'), 'utf8')
+    return text && text.trim() ? text : null
+  } catch { return null }
+}
+
+/**
+ * 冻结 patch 按段行数统计（thin 回放数据源）：`diff --git a/<old> b/<new>` 段头切分
+ * （正则与 filterPatchForFiles/slicePatchForFile 同款，取 b/ 新路径），段内 +/− 前缀行计数
+ * （+++ / --- 文件头与 \ 续行标记不计）；`new file mode` → new、`deleted file mode` →
+ * deleted、Binary/GIT binary patch → null 档——三档与 collectNumstatByPath 口径对齐。
+ * 自包含解析（不采 git numstat）：冻结面含 done 时点工作树件（治理工件/untracked），且不
+ * 依赖 git 对象库存活。
+ * @returns {Map<string, {additions: number|null, deletions: number|null, kind: 'binary'|'new'|'modified'|'deleted'}>}
+ */
+function parseFrozenPatchStats(patchText) {
+  const stats = new Map()
+  if (!patchText) return stats
+  let cur = null
+  const flush = () => {
+    if (cur && cur.path) {
+      stats.set(cur.path, cur.binary
+        ? { additions: null, deletions: null, kind: 'binary' }
+        : { additions: cur.additions, deletions: cur.deletions, kind: cur.kind })
+    }
+    cur = null
+  }
+  for (const line of String(patchText).split('\n')) {
+    if (line.startsWith('diff --git ')) {
+      flush()
+      const m = line.match(/^diff --git a\/(.+) b\/(.+)$/)
+      cur = m ? { path: toPosix(m[2]), additions: 0, deletions: 0, kind: 'modified', binary: false } : null
+      continue
+    }
+    if (!cur) continue
+    if (line.startsWith('new file mode')) cur.kind = 'new'
+    else if (line.startsWith('deleted file mode')) cur.kind = 'deleted'
+    else if (line.startsWith('Binary') || line.startsWith('GIT binary patch')) cur.binary = true
+    else if (line.startsWith('+') && !line.startsWith('+++')) cur.additions++
+    else if (line.startsWith('-') && !line.startsWith('---')) cur.deletions++
+  }
+  flush()
+  return stats
+}
+
 /**
  * patch 段过滤（quick-90015473）：全量 diff 按 `diff --git a/<old> b/<new>` 段头切分，
  * 只保留 files 集合内的段——json rows（退栈归属集）与 patch 同口径，多会话仓不把并行
@@ -972,6 +1038,9 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
       // execute --done 落盘，complete.js `...snap` 展开零改动自动携带）原样回放；旧快照无该键
       // → undefined（JSON.stringify 自动省略——单仓/旧快照零新增字段，additive 契约）。
       const snapRepos = Array.isArray(snap.repos) ? snap.repos : undefined
+      // 通道标注（2026-10-07-unify-close-trace）：新快照带 closedBy（flow done / execute --done）
+      // ——thin 快照回放不再误标 execute --done；旧快照无键缺省兼容。
+      const closeChannel = typeof snap.closedBy === 'string' && snap.closedBy ? snap.closedBy : 'execute --done'
       // 旧快照跨仓注记（R-07）：快照冻结于跨仓对账上线前（跨仓行恒 untouched 的 v1 ⊘ 形态、
       // 无 repos 键）——照旧回放不重算（「快照说什么是什么」契约不破），注记指明人工渠道
       // （该仓锚点锡点冻结在 execute-runs reviews，可人工 git diff 核实）。
@@ -1015,7 +1084,7 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
             : { foreignDeclared: [] },
           patchSha256: snap.patchSha256 || null,
           patchStatus: snap.patchStatus || null,
-          note: `${settleLabel}——execute --done 时点冻结快照${snap.savedAt ? '（' + String(snap.savedAt).replace('T', ' ').slice(0, 19) + ' 落盘）' : ''}：文件集封闭在 apply 时点，主仓后续新文件不进表；行数按锚 ${actual.baseAnchor.slice(0, 7)}→当前工作树 补采（同文件后续演进会计入）${legacyCrossNote}`,
+          note: `${settleLabel}——${closeChannel} 时点冻结快照${snap.savedAt ? '（' + String(snap.savedAt).replace('T', ' ').slice(0, 19) + ' 落盘）' : ''}：文件集封闭在收尾时点，主仓后续新文件不进表；行数按锚 ${actual.baseAnchor.slice(0, 7)}→当前工作树 补采（同文件后续演进会计入）${legacyCrossNote}`,
         }
       }
       return {
@@ -1033,7 +1102,64 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
           : { foreignDeclared: [] },
         patchSha256: snap.patchSha256 || null,
         patchStatus: snap.patchStatus || null,
-        note: `${settleLabel}——execute --done 时点冻结快照${snap.savedAt ? '（' + String(snap.savedAt).replace('T', ' ').slice(0, 19) + ' 落盘）' : ''}：范围封闭在 apply 时点，主仓后续改动不反映到本表；需要看当前工作区实时状态请跑 git status${legacyCrossNote}`,
+        note: `${settleLabel}——${closeChannel} 时点冻结快照${snap.savedAt ? '（' + String(snap.savedAt).replace('T', ' ').slice(0, 19) + ' 落盘）' : ''}：范围封闭在收尾时点，主仓后续改动不反映到本表；需要看当前工作区实时状态请跑 git status${legacyCrossNote}`,
+      }
+    }
+    // —— thin flow done 冻结记录回放（2026-10-07-scope-audit-thin-patch-replay）：thin 轻量变更
+    // flow done 只冻 change-patch.json + change.patch、不落 execute 快照——快照缺失时回读冻结件
+    // 出真实三态（存量归档立即受益），不再落「实时开放区间 → 干净树空 → 清单全行计划未动
+    // +0/−0」的失真链。文件集 = meta.files 过 filterDeliverableFiles（与 actual 侧同口径，
+    // 治理工件不进表）；行数自冻结 patch 按段统计（parseFrozenPatchStats，自包含）；三态按
+    // design 清单 pathMatches 判定（与主链路三态判定同款）；跨仓条目维持 v1 ⊘ untouched 形态
+    // （thin 冻结件只有主仓 patch，不假装对账过）。
+    const doneMeta = readChangePatchMeta(changeDirInfo.dir)
+    if (doneMeta && doneMeta.files.length > 0) {
+      const frozenFiles = filterDeliverableFiles([...new Set(doneMeta.files.map(toPosix).filter(Boolean))]).sort()
+      const patchOk = doneMeta.patchStatus === 'ok'
+      const segStats = patchOk ? parseFrozenPatchStats(readChangePatchText(changeDirInfo.dir)) : new Map()
+      const doneRows = []
+      const doneMatched = new Set()
+      for (const f of frozenFiles) {
+        // 段缺失（冻结面零 diff 文件）/ patch 采集失败 → 行数 null 档（—），不出伪数据
+        const st = segStats.get(f) || { additions: null, deletions: null, kind: 'modified' }
+        const row = { path: f, additions: st.additions, deletions: st.deletions, kind: st.kind }
+        if (!planDegraded) {
+          const entry = plannedEntries.find(e => pathMatches(f, e.path))
+          if (entry) {
+            doneMatched.add(entry.path)
+            row.planned = entry.operation || null
+            row.verdict = 'planned'
+          } else {
+            row.planned = null
+            row.verdict = 'unplanned'
+            const facility = classifyToolScaffold(f)
+            if (facility) row.facility = facility
+          }
+        }
+        doneRows.push(row)
+      }
+      // 计划未动补行：清单文件不在冻结面 → untouched 0/0（与主链路补行同款语义）
+      for (const e of plannedEntries) {
+        if (doneMatched.has(e.path)) continue
+        doneRows.push(e.repo
+          ? { path: e.path, planned: e.operation || null, additions: 0, deletions: 0, kind: 'modified', verdict: 'untouched', crossRepo: e.repo }
+          : { path: e.path, planned: e.operation || null, additions: 0, deletions: 0, kind: 'modified', verdict: 'untouched' })
+      }
+      const doneSettleLabel = changeDirInfo.archived ? '已归档' : 'execute 已收尾（分支已清理，待 verify/archive）'
+      const doneSavedAt = doneMeta.savedAt ? '，' + String(doneMeta.savedAt).replace('T', ' ').slice(0, 19) + ' 落盘' : ''
+      return {
+        ...base,
+        ok: true,
+        degradedReason: planDegraded,
+        baseAnchor: typeof doneMeta.baseline === 'string' && /^[0-9a-f]{7,40}$/.test(doneMeta.baseline) ? doneMeta.baseline : null,
+        totals: { files: doneRows.length, ...sumTotals(doneRows) },
+        rows: doneRows,
+        excluded: { foreignDeclared: [] },
+        patchSha256: doneMeta.patchSha256 || null,
+        patchStatus: doneMeta.patchStatus || null,
+        // --file 冻结切片消费（getFileDiff 唯一读取方）：指向 change.patch，sha256 校验 A-F01 同款
+        ...(patchOk ? { frozenPatchPath: join(changeDirInfo.dir, 'change.patch') } : {}),
+        note: `${doneSettleLabel}——flow done 时点冻结 patch 记录（change-patch.json + change.patch${doneSavedAt}）：文件集与行数封闭在 done 时点（thin 轻量变更无 execute 快照），主仓后续改动不反映到本表${patchOk ? '' : '；冻结 patch 当时采集失败——行数列不可得（—），文件集仍为 done 时点冻结面'}；需要看当前工作区实时状态请跑 git status`,
       }
     }
     // 快照缺失 → 实时开放区间兜底（下方主链路），note 追加漂移警告
@@ -1047,7 +1173,7 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
   // 已收尾但快照缺失（上方分支置位）：实时开放区间兜底，明示漂移语义——快照机制上线
   // （2026-09-10）前收尾的旧变更冻结记录无法重建，如实告知替代渠道。
   if (noSnapshotDrift) {
-    notes.push('快照缺失（变更已收尾——已归档或 execute 分支已清理；快照机制上线前收尾的变更无法重建冻结记录）——下表为实时开放区间（基点→当前工作树，含并行会话与后续演进，随主仓改动漂移），非本变更冻结范围；记录态参考 verify-result.md / git log')
+    notes.push('快照缺失（变更已收尾——已归档或 execute 分支已清理；快照与 flow done 冻结 patch 记录（change-patch.json）均无，无法重建冻结记录——快照机制与冻结件留档上线前收尾的变更即此形态）——下表为实时开放区间（基点→当前工作树，含并行会话与后续演进，随主仓改动漂移），非本变更冻结范围；记录态参考 verify-result.md / git log')
   }
 
   // —— 行数采集根与基点 ——

package/src/verify-postcheck.js

@@ -2773,8 +2773,15 @@ function buildDepsBatches({ deps, changedFiles = [], hits = [], cwd = null, prio
   const prio = (f) => (changedSet.has(norm(f)) || prioritySet.has(norm(f))) ? 0 : 1 // 变更/FR 回归测试文件优先
   const py = deps.filter(f => f.endsWith('.py')).sort((a, b) => (prio(a) > prio(b) ? 1 : prio(a) < prio(b) ? -1 : a.localeCompare(b)))
   const js = deps.filter(f => !f.endsWith('.py')).sort((a, b) => (prio(a) > prio(b) ? 1 : prio(a) < prio(b) ? -1 : a.localeCompare(b)))
+  // 套件编排器过滤（2026-10-08-thin-done-dirty-gate-and-paren-attribution，坑：FR 绑定把
+  // run-tests.mjs 收进 deps 批 → 内嵌执行=递归全量套件——嵌套 runner 污染 + 15-20 分钟窗口，
+  // 实测 not ok 假败阻断收口）。run-tests.mjs 是 npm test 的组卷入口不是单测文件：执行面剔除
+  // 并 loud 披露；全量门由收口实测与 CI 层的 npm test 承担（本就覆盖该文件的全部语义）。
+  const SUITE_META_RE = /(^|\/)run-tests\.mjs$/
+  const jsMeta = js.filter(f => SUITE_META_RE.test(norm(f)))
+  const jsList = js.filter(f => !SUITE_META_RE.test(norm(f)))
   const CAP = 30
-  const pyCap = py.length === 0 ? 0 : js.length === 0 ? CAP : Math.max(5, Math.min(CAP - 5, Math.round(CAP * py.length / (py.length + js.length))))
+  const pyCap = py.length === 0 ? 0 : jsList.length === 0 ? CAP : Math.max(5, Math.min(CAP - 5, Math.round(CAP * py.length / (py.length + jsList.length))))
   const jsCap = CAP - pyCap
   // 配额制组卷（2026-10-06-fr-regress-cap-drop）：优先面整跑豁免帽，普通依赖填剩余席位；
   // dropped 只计普通依赖弃置（优先面零弃置是构造保证），组内序保持「优先前缀+字母序」。
@@ -2785,7 +2792,7 @@ function buildDepsBatches({ deps, changedFiles = [], hits = [], cwd = null, prio
     return { run: [...prioInGroup, ...ordinaryRun], prioCount: prioInGroup.length, dropped: ordinary.length - ordinaryRun.length, prioDropped: 0 }
   }
   const pyQ = quotaFill(py, pyCap)
-  const jsQ = quotaFill(js, jsCap)
+  const jsQ = quotaFill(jsList, jsCap)
   const pyRun = pyQ.run
   const jsRun = jsQ.run
   // .py 运行器推断双源（2026-09-26-dynamic-test-inference）：① 命中模块命令串（旧路径，兼容期）；
@@ -2855,7 +2862,8 @@ function buildDepsBatches({ deps, changedFiles = [], hits = [], cwd = null, prio
   // dropped 只计普通依赖弃置、prioDropped=防御路径计数（构造上恒 0——quotaFill 保证优先面零弃置，
   // >0 即组卷逻辑被破坏，消费面 loud 披露）。js 批经 jsNative/jsProject 内容分流后计数随分流面。
   if (pyRun.length > 0) batches.push({ name: 'deps(auto-py)', short: 'py', command: `${pyRunner} ${pyRun.map(rebase).join(' ')}`, count: pyRun.length, prioCount: pyQ.prioCount, dropped: pyQ.dropped, prioDropped: pyQ.prioDropped, files: pyRun })
-  if (jsNative.length > 0) batches.push({ name: 'deps(auto-js)', short: 'js', command: `node --test --test-reporter=spec --test-reporter-destination=stderr --test-reporter=tap --test-reporter-destination=stdout ${jsNative.join(' ')}`, count: jsNative.length, prioCount: jsNative.filter(f => prio(f) === 0).length, dropped: js.length - jsRun.length, prioDropped: jsQ.prioDropped, tap: true, files: jsNative })
+  if (jsNative.length > 0) batches.push({ name: 'deps(auto-js)', short: 'js', command: `node --test --test-reporter=spec --test-reporter-destination=stderr --test-reporter=tap --test-reporter-destination=stdout ${jsNative.join(' ')}`, count: jsNative.length, prioCount: jsNative.filter(f => prio(f) === 0).length, dropped: jsList.length - jsRun.length, prioDropped: jsQ.prioDropped, tap: true, files: jsNative })
+  if (jsMeta.length > 0) batches.push({ name: 'deps(auto-js-meta-skip)', short: 'js-meta-skip', command: null, count: jsMeta.length, dropped: 0, skip: true, files: jsMeta, reason: '套件编排器（run-tests.mjs=npm test 组卷入口）非单测文件——内嵌执行=递归全量套件（嵌套 runner 污染假败）；全量门由收口实测/CI 的 npm test 承担' })
   if (jsProjectRun.length > 0) {
     if (jsxRunner) {
       const isVitest = /vitest/.test(jsxRunner)