sillyspec 3.28.6 → 3.28.8

package/src/knowledge-match.js

@@ -5,6 +5,8 @@
  * 路由行发现——路由行由 decision-distill 幂等写入，本引擎只消费不写）——命中路由行的
  * 决策文件解析为 decisionHits（rejected 优先），供 brainstorm Step2 防复潮注入（task-04，FR-05）。
  * decisions 库不存在时（INDEX 无 Decisions 段/文件不存在）一切行为与无 decisions 库时一致。
+ * 另导出 matchDecisionsByFiles（task-02，FR-02）：决策条目按代码文件路径反查——条目
+ * 「文件：」字段精确命中 ∪「锚点：」路径形态 token 提取兜底（quick 语义护栏的文件键引擎）。
  */
 
 import { existsSync, readFileSync } from 'fs'
@@ -59,19 +61,57 @@ function isDecisionRoute(entry) {
 }
 
 const DECISION_HEADER_RE = /^##\s+(D-\d+@v\d+)\s*(.*)$/
-const DECISION_FIELD_RE = /^(状态|理由|否决理由|复潮条件)\s*[：:]\s*(.*)$/
+const DECISION_FIELD_RE = /^(状态|文件|理由|否决理由|复潮条件)\s*[：:]\s*(.*)$/
+// 「锚点：」单独标签精确匹配读入（仿 docs-check.js parseDecisionEntries 先例）——绝不并入
+// DECISION_FIELD_RE：其 else-if 链末尾的 reason 回填（else if (!cur.reason)）会把锚点值
+// 误吞进 reason（Grill X-002 隐性回归）。
+const DECISION_ANCHOR_RE = /^锚点\s*[：:]\s*(.*)$/
+// 变更：单独标签（变更名限定——D-xxx 是变更内局部序号，跨变更同号互不相干，去重键依赖它）
+const DECISION_CHANGE_RE = /^变更\s*[：:]\s*(.*)$/
+
+/** 「文件：」值切分 + 逐项反斜杠归一 POSIX（与 decision-distill 的 entry.files 契约对齐：
+ *  split /[,，、\s]+/ + replace(/\\/g,'/')）。 */
+function splitDecisionFiles(value) {
+  return String(value || '')
+    .split(/[,，、\s]+/)
+    .map(s => s.replace(/\\/g, '/'))
+    .filter(Boolean)
+}
+
+// 锚点路径 token 提取：路径形态 token + 扩展名白名单（扩展名按长度降序排列——
+// (js|…|jsx) 短前缀在前会把 foo.jsx 截断成 foo.js）。
+const ANCHOR_FILE_TOKEN_RE = /[\w./-]+\.(?:mjs|cjs|jsx|tsx|js|ts|py|go|java|rs)/g
+
+/**
+ * 锚点值 → 代码文件路径集（条目无「文件：」字段时的兜底命中源）。
+ * 真实先例：D-905 形态「锚点：src/quicklog.js:493」→ 提取 src/quicklog.js
+ * （token 字符类不含 : 故止于行号前，再防御性剥 :line/:line-line/:符号 后缀）。
+ * 「未记录」/无路径形态 token → []。
+ */
+function anchorFilePaths(anchor) {
+  const a = String(anchor || '').trim().replace(/\\/g, '/')
+  if (!a || a === '未记录') return []
+  const out = new Set()
+  for (const token of a.match(ANCHOR_FILE_TOKEN_RE) || []) {
+    const p = token.replace(/:(?:\d+(?:-\d+)?|[A-Za-z_$][A-Za-z0-9_$]*)$/, '')
+    if (p) out.add(p)
+  }
+  return [...out]
+}
 
 /**
  * 解析单个 decisions/<域>.md 的 D-xxx@vN 条目。
  * reason 语义：rejected 条目取「否决理由」（expects_from task-02 的 reject_reason），
  * 其余条目回退「理由」一句话；revisitWhen 仅 rejected 条目非空（复潮条件）。
+ * files =「文件：」字段切分归一（task-02，FR-02）；anchor =「锚点：」行原值（单独标签读入，
+ * 不进 reason 回填链——Grill X-002）。
  * @param {string} filePath 决策文件绝对路径
  * @param {string} file INDEX 相对路径（decisions/<域>.md），原样进 decisionHits.file
- * @returns {{ file: string, id: string, title: string, status: string, reason: string, revisitWhen: string }[]}
+ * @returns {{ file: string, id: string, title: string, status: string, reason: string, revisitWhen: string, files: string[], anchor: string }[]}
  */
 function parseDecisionFile(filePath, file) {
   let content
-  try { content = readFileSync(filePath, 'utf8') } catch { return [] }
+  try { content = readFileSync(filePath, 'utf-8') } catch { return [] }
   const hits = []
   let cur = null
   const flush = () => {
@@ -82,14 +122,22 @@ function parseDecisionFile(filePath, file) {
     const h = line.match(DECISION_HEADER_RE)
     if (h) {
       flush()
-      cur = { file, id: h[1], title: h[2].trim(), status: '', reason: '', revisitWhen: '' }
+      cur = { file, id: h[1], title: h[2].trim(), status: '', reason: '', revisitWhen: '', files: [], anchor: '', change: '' }
       continue
     }
     if (!cur) continue
+    // 锚点：单独标签先于字段链匹配（不在 DECISION_FIELD_RE 内，见常量处注释）
+    const a = line.match(DECISION_ANCHOR_RE)
+    if (a) { cur.anchor = a[1].trim(); continue }
+    // 变更：单独标签读入（坑 decision-cross-change-id-shadow，2026-09-11 语义护栏 dogfood 首跑实证：
+    // 域文件跨变更同号条目常见（D-xxx 是变更内局部序号），去重键须含变更名否则先到条目遮蔽后来者）
+    const c = line.match(DECISION_CHANGE_RE)
+    if (c) { cur.change = c[1].trim(); continue }
     const f = line.match(DECISION_FIELD_RE)
     if (!f) continue
     const value = f[2].trim()
     if (f[1] === '状态') cur.status = value.toLowerCase()
+    else if (f[1] === '文件') cur.files = splitDecisionFiles(value)
     else if (f[1] === '否决理由') cur.reason = value
     else if (f[1] === '复潮条件') cur.revisitWhen = value
     else if (!cur.reason) cur.reason = value // 理由：仅作 implemented（或否决理由缺失）时的回填
@@ -115,16 +163,52 @@ export function parseDecisionEntries(indexDir, indexEntries = null) {
     if (!existsSync(filePath)) continue // 路由行失效（域文件已删）→ 跳过不阻断
     hits.push(...parseDecisionFile(filePath, route.file))
   }
-  // 多条路由行指向同一域文件时按 file+id 去重
+  // 多条路由行指向同一域文件时按 file+id+变更 去重（完全重复折叠）；键含变更名——
+  // 跨变更同号条目（D-xxx 是变更内局部序号，域文件内同 id 不同变更常见）不再被先到者
+  // 遮蔽（坑 decision-cross-change-id-shadow，2026-09-11 dogfood 实证：runtime.md 七个
+  // D-001@v1 分属七变更，旧键只放行首个——同号 rejected 决策在 {DECISION_HITS} 防复潮
+  // 注入同样被遮蔽）。无「变更：」行的 legacy 条目 change='' 与同号 legacy 条目互折叠
+  // （维持旧行为，不放大历史条目数）。
   const seen = new Set()
   return hits.filter(h => {
-    const key = `${h.file}#${h.id}`
+    const key = `${h.file}#${h.id}#${h.change || ''}`
     if (seen.has(key)) return false
     seen.add(key)
     return true
   })
 }
 
+/**
+ * 决策条目按代码文件路径反查（task-02，FR-02）——quick 语义护栏（task-03/05/06）的
+ * 文件键引擎。条目命中源 = 「文件：」字段（cur.files）∪「锚点：」路径形态 token 提取
+ * （anchorFilePaths 兜底）；查询侧与条目侧路径统一 POSIX 归一。
+ * @param {string} indexDir knowledge 目录路径
+ * @param {string[]} files 查询代码文件路径列表
+ * @returns {{ [file: string]: Array<{ id: string, title: string, status: string, reason: string, file: string }> }}
+ *   键 = 归一后的查询路径（结果键 ⊆ 查询集）；条目 file 字段沿 parseDecisionFile 既有
+ *   口径（INDEX 相对 decisions/<域>.md 路径）；rejected 条目同样进结果（status 透传，
+ *   消费方按需过滤）；无 decisions 库 / 路由失效 / 空查询 → {}。
+ */
+export function matchDecisionsByFiles(indexDir, files) {
+  const queries = [...new Set(
+    (Array.isArray(files) ? files : [files])
+      .map(f => String(f || '').trim().replace(/\\/g, '/'))
+      .filter(Boolean)
+  )]
+  if (queries.length === 0) return {}
+  const querySet = new Set(queries)
+  const result = {}
+  for (const hit of parseDecisionEntries(indexDir)) {
+    const sources = new Set([...(hit.files || []), ...anchorFilePaths(hit.anchor)])
+    for (const src of sources) {
+      if (!querySet.has(src)) continue
+      if (!result[src]) result[src] = []
+      result[src].push({ id: hit.id, title: hit.title, status: hit.status, reason: hit.reason, file: hit.file })
+    }
+  }
+  return result
+}
+
 function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }

package/src/local-detect.js

@@ -15,26 +15,41 @@ import { join } from 'path'
 
 /**
  * 从 Makefile 文本提取 test 目标的命令（轻量正则，与 verify-postcheck 同风格）。
- * 支持两种常见写法：
- *   - 同行命令：`test: pytest`            → 'pytest'
- *   - tab 续行：`test:\n\tpytest\n`        → 'pytest'（命令在下一 tab 开头行）
+ * 支持的写法（按 make 语义）：
+ *   - tab/空格 缩行配方：`test:\n\tpytest\n`   → 'pytest'
+ *   - `;` 同行配方：`test: ; pytest`            → 'pytest'
+ *   - 行内其他非空内容是 prerequisite（`test: unit integration`），不是命令——配方照常
+ *     向下找缩行；无配方回退 'make test'（make 会先跑依赖目标，语义正确）
  * 边界：
- *   - 纯空目标（`test:` 无同行命令、无 tab 续行）→ 回退 'make test'
- *   - 命令行内 `#` 注释截断；取第一个非空命令行
+ *   - 配方行以「下一个非缩进非空行」为界——空目标后跳进后续目标的配方是旧版缺陷
+ *     （ql-20260911-029 复现：`test:\nbuild:\n\tnpm run build` 旧正则返回 'npm run build'）
+ *   - `test := x` 变量赋值不匹配 test 目标；命令行内 `#` 注释截断
  * @param {string} makefileText
  * @returns {string}
  */
-function parseMakefileTestCommand(makefileText) {
+export function parseMakefileTestCommand(makefileText) {
   if (!makefileText) return 'make test'
-  // 定位 `test:` 行；捕获 `:` 后同行内容（同行命令或空）
-  const head = makefileText.match(/^test:\s*([^\n#]*?)\s*(?:#.*)?$/m)
-  if (!head) return 'make test'
-  const inline = (head[1] || '').trim()
-  if (inline) return inline
-  // 同行为空 → 找该行之后第一个 tab 续行命令（`\tcmd` 或 `    cmd`）
-  const after = makefileText.slice(head.index + head[0].length)
-  const cont = after.match(/^[ \t]+([^\n#]+?)\s*(?:#.*)?$/m)
-  if (cont && cont[1]) return cont[1].trim()
+  const lines = String(makefileText).split(/\r?\n/)
+  // (?!=) 排除 `test :=` 变量赋值形态
+  const testIdx = lines.findIndex(l => /^test:(?!=)/.test(l))
+  if (testIdx === -1) return 'make test'
+  const inline = lines[testIdx].slice(lines[testIdx].indexOf('test:') + 'test:'.length).trim()
+  const semicolonRecipe = inline.match(/^;\s*(.+)$/)
+  if (semicolonRecipe) {
+    const cmd = semicolonRecipe[1].replace(/\s+#.*$/, '').trim()
+    if (cmd) return cmd
+  }
+  // 向下扫配方：第一条缩进行即 test 的配方（tab 或空格缩进）；遇非缩进非空行（下一
+  // 目标/变量/指令）即边界——空行与列 0 注释不构成边界
+  for (let i = testIdx + 1; i < lines.length; i++) {
+    const line = lines[i]
+    if (line.trim() === '' || line.startsWith('#')) continue
+    if (/^[ \t]+\S/.test(line)) {
+      const cmd = line.replace(/^[ \t]+/, '').replace(/\s+#.*$/, '').trim()
+      return cmd || 'make test'
+    }
+    return 'make test'
+  }
   return 'make test'
 }
 

package/src/local-register.js

@@ -16,8 +16,9 @@
  * （tmp+rename，防多会话并发写半截，与 local detect 写入口径一致）。
  */
 import { existsSync, readFileSync, mkdirSync } from 'fs'
-import { dirname } from 'path'
+import { dirname, join } from 'path'
 import { writeAtomicSync } from './fs-atomic.js'
+import { withFileLock } from './quicklog.js'
 
 function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
@@ -26,13 +27,18 @@ function escapeRe(s) {
 /**
  * 把 `<key>: <path>` 注册进 local.yaml 的 repos: 段（幂等，已有该 key 则改值）。
  *
+ * 读-改-写整段持 .local.yaml.lock（2026-09-12 审查批 C-②）：writeAtomicSync 只保证单次
+ * 写不撕裂，不串行化 RMW——多 agent 并行 register-repo（不同 key）或与 local detect /
+ * platform connect 的写入口并发时，后写者整体覆盖前写者、先注册条目静默丢失
+ * （quicklog 侧同场景用 withFileLock，此处对齐）。async 化：调用方须 await。
+ *
  * @param {string} yamlPath - local.yaml 绝对路径（不存在则新建）
  * @param {string} key - repo key（限 [A-Za-z0-9_.\-]+，'main' 隐式禁止注册）
  * @param {string} repoPath - 跨仓仓根绝对路径（写入时统一正斜杠，与示例格式一致）
- * @returns {{ fileCreated: boolean, sectionCreated: boolean, replaced: boolean }}
+ * @returns {Promise<{ fileCreated: boolean, sectionCreated: boolean, replaced: boolean }>}
  * @throws {Error} key 非法 / key='main' / repoPath 空 / 读写失败
  */
-export function registerRepoInLocalYaml(yamlPath, key, repoPath) {
+export async function registerRepoInLocalYaml(yamlPath, key, repoPath) {
   if (!yamlPath) throw new Error('registerRepoInLocalYaml: yamlPath 不能为空')
   if (!key || !/^[A-Za-z0-9_.\-]+$/.test(key)) {
     throw new Error(`repo key 非法: "${key}"（限字母数字 . _ -，与 parseRepoRegistry 读侧口径一致）`)
@@ -42,7 +48,9 @@ export function registerRepoInLocalYaml(yamlPath, key, repoPath) {
   }
   if (!repoPath) throw new Error('registerRepoInLocalYaml: repoPath 不能为空')
 
-  const existed = existsSync(yamlPath)
+  // 锁文件与 yaml 同目录（与 QUICKLOG/tasks 锁同机制；锁内读-判定-写，后写者不再覆盖前写者）
+  return await withFileLock(join(dirname(yamlPath), '.local.yaml.lock'), async () => {
+    const existed = existsSync(yamlPath)
   // CRLF 归一后按 LF 写回（同 task 卡锚点写入的 CRLF 坑；local.yaml 各 CLI 写入口径均 LF）
   const raw0 = existed ? readFileSync(yamlPath, 'utf8') : ''
   const hadCr = raw0.includes('\r') // 磁盘原文带 CRLF → 幂等路径也要落盘治愈（见下方幂等分支）
@@ -101,4 +109,5 @@ export function registerRepoInLocalYaml(yamlPath, key, repoPath) {
   lines.splice(insertAt, 0, entryLine)
   write(lines.join('\n'))
   return { fileCreated: false, sectionCreated: false, replaced: false }
+  })
 }

package/src/mcp-server.js

@@ -64,8 +64,6 @@ const TOOLS = [
 
 /** tools/call 路由：子进程 --json（stdout 纪律隔离；CLI 的 stderr 透传进 text 供诊断） */
 async function callTool(name, args) {
-  const argv = ['--meta'] // 占位防误配：--meta 是 run 的 flag，工具不走 run
-  argv.length = 0
   const specDir = args && typeof args.spec_dir === 'string' && args.spec_dir ? ['--spec-dir', args.spec_dir] : []
   switch (name) {
     case 'sillyspec_next':
@@ -81,6 +79,14 @@ async function callTool(name, args) {
   }
 }
 
+// 子进程挂死兜底（2026-09-12 审查批 A-②）：gate/derive 会真实跑测试与 git 全家，测试进程
+// 不退/git 等锁时 tools/call 若无超时则永久挂起（stdio MCP 无请求级超时，host 侧表现为工具
+// 卡死）。默认 300s（全量测试套件 ~90s 的余量），env 可调；输出封顶防 stderr 刷屏型无界累积。
+const CALL_TIMEOUT_MS = Number(process.env.SILLYSPEC_MCP_CALL_TIMEOUT_MS) > 0
+  ? Number(process.env.SILLYSPEC_MCP_CALL_TIMEOUT_MS)
+  : 300_000
+const OUTPUT_CAP_BYTES = 8 * 1024 * 1024
+
 function runCli(cliArgs) {
   return new Promise((resolve) => {
     const p = spawn(process.execPath, [CLI_ENTRY, ...cliArgs], {
@@ -90,14 +96,38 @@ function runCli(cliArgs) {
     })
     let out = ''
     let err = ''
-    p.stdout.on('data', (d) => { out += String(d) })
-    p.stderr.on('data', (d) => { err += String(d) })
+    let outTrunc = false
+    let errTrunc = false
+    let settled = false
+    const finish = (r) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      resolve(r)
+    }
+    const timer = setTimeout(() => {
+      try { p.kill() } catch { /* 已退出 */ }
+      finish({ text: `CLI 子进程超时（${CALL_TIMEOUT_MS}ms）被终止: sillyspec ${cliArgs.join(' ')}（挂死兜底；可用 SILLYSPEC_MCP_CALL_TIMEOUT_MS 调整）`, isError: true, exitCode: null })
+    }, CALL_TIMEOUT_MS)
+    p.stdout.on('data', (d) => {
+      if (out.length < OUTPUT_CAP_BYTES) out += String(d)
+      else outTrunc = true
+    })
+    p.stderr.on('data', (d) => {
+      if (err.length < OUTPUT_CAP_BYTES) err += String(d)
+      else errTrunc = true
+    })
     p.on('close', (code) => {
-      // envelope 原样透传（text = stdout JSON 全文；machine 侧自解）；stderr 仅失败时附诊断
-      const text = (out.trim() || err.trim().slice(-2000) || `（exit ${code}，无输出）`)
-      resolve({ text, isError: code !== null && code !== 0 && code !== 1, exitCode: code })
+      // envelope 原样透传（text = stdout JSON 全文；machine 侧自解）；stderr 仅失败时附诊断。
+      // isError 口径（批 E-④）：exit 0=正常；1=BLOCKED（合法裁决结果）；2=EXIT_UNKNOWN
+      // （envelope 合法、含诊断信息）——三者都是机器可解析的合法结果，不标 isError；
+      // 部分 MCP host 把 isError 当「工具执行失败」处理而不向模型展示 text，exit 2 的
+      // 诊断信息会被吞。真失败（spawn error/超时）由 error/timeout 路径标 isError。
+      const truncNote = outTrunc || errTrunc ? `\n（输出超 ${OUTPUT_CAP_BYTES} 字节封顶截断）` : ''
+      const text = (out.trim() || err.trim().slice(-2000) || `（exit ${code}，无输出）`) + truncNote
+      finish({ text, isError: code !== null && code !== 0 && code !== 1 && code !== 2, exitCode: code })
     })
-    p.on('error', (e) => resolve({ text: `CLI 子进程失败: ${e.message}`, isError: true }))
+    p.on('error', (e) => finish({ text: `CLI 子进程失败: ${e.message}`, isError: true }))
   })
 }
 

package/src/progress/change-registry.js

@@ -62,6 +62,38 @@ export class ChangeRegistry {
     } catch { return null; }
   }
 
+  /**
+   * 读某变更最近一次进度活动时刻（quick-done-autoarchive-misfire 缺陷②，D-002@v1 复潮
+   * 2026-09-11 实证：stage 阶段态区分不了「活跃在途」与「启动后弃单」——brainstorm
+   * in_progress + tasks.md 仅含他者 quick 行时「全勾」是空洞真值）。取该变更全部
+   * stages/steps completed_at 的最大值：活跃会话分钟级在推进（最近活动必新）；僵尸的
+   * 最后一步完成时刻必然陈旧。只读不抛：无变更/无完成行/读失败返回 null（调用方按
+   * 无近期活动放行，僵尸逃生通道语义不变——与 getStageCompletedAt 同族容错）。
+   */
+  getLatestActivityAt(cwd, changeName) {
+    try {
+      const db = this.pm._ensureDB(cwd);
+      const sqlDb = db.getDb();
+      const ch = sqlDb.prepare(`SELECT id FROM changes WHERE name = ?`).get(changeName);
+      if (!ch) return null;
+      const rows = sqlDb.prepare(
+        `SELECT completed_at AS ts FROM stages WHERE change_id = ? AND completed_at IS NOT NULL
+         UNION ALL
+         SELECT st.completed_at AS ts FROM steps st
+           JOIN stages s ON st.stage_id = s.id WHERE s.change_id = ? AND st.completed_at IS NOT NULL`
+      ).all(ch.id, ch.id);
+      // JS 侧按解析后的时间取最新（归一 ISO 返回）：SQL 字符串 MAX 在 zh-CN（'/'）与 ISO（'-'）
+      // 混存时恒取 zh-CN（'/'0x2F>'-'0x2D）——存量 zh-CN 陈旧值会盖过新 ISO 致时近性闸取错
+      // 时间戳（活跃变更被误归档方向，2026-09-11 审查）。不可解析串跳过。
+      let latestMs = -Infinity;
+      for (const r of rows) {
+        const ms = new Date(r.ts).getTime();
+        if (Number.isFinite(ms) && ms > latestMs) latestMs = ms;
+      }
+      return latestMs === -Infinity ? null : new Date(latestMs).toISOString();
+    } catch { return null; }
+  }
+
   /**
    * 读某变更某阶段的 started_at（2026-09-10 用户反馈②：evidence mtime 窗口锚点从
    * execute completed_at 放宽到 started_at——证据合法产自 execute 或 verify 两窗口，
@@ -283,44 +315,44 @@ export class ChangeRegistry {
     // 注：新名日期前缀门禁只在 CLI 边界强制（index.js change-rename 入口）——renameChange 是
     // 库函数，测试/平台工具合法用任意名（2026-09-11 决策）。
     const db = this.pm._ensureDB(cwd);
-    // 检查旧名是否存在
-    const existing = db.transaction(() => {
-      const sqlDb = db.getDb();
-      const row = sqlDb.prepare(`SELECT name, status FROM changes WHERE name = ?`).get(oldName);
-      if (row === undefined) return null;
-      return { name: row.name, status: row.status };
-    });
-    if (!existing) {
-      console.error(`❌ 变更 ${oldName} 不存在`);
-      return;
-    }
-    // 检查新名是否已存在
-    const conflict = db.transaction(() => {
-      const sqlDb = db.getDb();
-      const row = sqlDb.prepare(`SELECT name FROM changes WHERE name = ?`).get(newName);
-      return row !== undefined;
-    });
-    if (conflict) {
-      console.error(`❌ 变更 ${newName} 已存在`);
-      return;
-    }
-    // 先更新 DB，再重命名目录；FS 失败则回滚 DB，避免"目录已改名但 DB 旧名"的孤儿
-    // （旧实现 FS-first 无补偿：renameSync 成功后 DB transaction 抛 EPERM/EBUSY 会让
-    //  目录已是 newName、DB 仍是 oldName，read(两名) 都失联且无自动恢复）。
+    // 存在性/冲突检查与 UPDATE 收进同一事务 + 校验影响行数（坑 rename-concurrent-split，
+    // 2026-09-12 审查批 C-①）：旧三段独立事务是 check-then-act——并发重命名 X→Y 与 X→Z 时，
+    // 后者的 UPDATE 命中 0 行不报错，继续搬目录造成 DB/目录分裂（空目录假成功）。
     const oldDir = this.pm._changePath(cwd, oldName);
     const newDir = this.pm._changePath(cwd, newName);
     const now = new Date().toISOString();
+    let outcome;
     try {
-      db.transaction(() => {
+      outcome = db.transaction(() => {
         const sqlDb = db.getDb();
-        sqlDb.prepare(`UPDATE changes SET name = ?, last_active = ? WHERE name = ?`).run(newName, now, oldName);
+        const row = sqlDb.prepare(`SELECT name FROM changes WHERE name = ?`).get(oldName);
+        if (row === undefined) return 'missing';
+        if (sqlDb.prepare(`SELECT 1 FROM changes WHERE name = ?`).get(newName) !== undefined) return 'conflict';
+        const r = sqlDb.prepare(`UPDATE changes SET name = ?, last_active = ? WHERE name = ?`).run(newName, now, oldName);
+        if (r.changes !== 1) return 'stolen'; // 并发窗口：检查后他进程已把 oldName 改走
         // 本地脏度（D-013 / task-04）：重命名也是本地推进（标新名）
         this.pm._touchLocalModified(cwd, newName, now);
+        return 'ok';
       });
     } catch (e) {
       console.error(`❌ 重命名失败：更新数据库时出错（${e.message}）`);
       return;
     }
+    if (outcome === 'missing') {
+      console.error(`❌ 变更 ${oldName} 不存在`);
+      return;
+    }
+    if (outcome === 'conflict') {
+      console.error(`❌ 变更 ${newName} 已存在`);
+      return;
+    }
+    if (outcome === 'stolen') {
+      console.error(`❌ 变更 ${oldName} 刚被并发操作重命名/删除（0 行更新），本次跳过——请重查后重试`);
+      return;
+    }
+    // 先更新 DB，再重命名目录；FS 失败则回滚 DB，避免"目录已改名但 DB 旧名"的孤儿
+    // （旧实现 FS-first 无补偿：renameSync 成功后 DB transaction 抛 EPERM/EBUSY 会让
+    //  目录已是 newName、DB 仍是 oldName，read(两名) 都失联且无自动恢复）。
     let renamed = true;
     if (existsSync(oldDir)) {
       try {

package/src/progress/consistency-doctor.js

@@ -4,6 +4,7 @@
 import { appendFileSync, existsSync, readFileSync, readdirSync } from 'fs';
 import { join, resolve } from 'path';
 import { DB } from '../db.js';
+import { openDatabase } from '../db-engine.js';
 import { summarizeTaskCompletion } from '../task-review.js';
 import { STAGE_ORDER, MAIN_FLOW_ORDER } from './shared.js';
 
@@ -101,11 +102,15 @@ export class ConsistencyDoctor {
     if (!existsSync(dbPath)) return null;
     let db = null;
     try {
-      db = new DB(dbPath);
-      db.init();
-      const rows = db.getDb().prepare("SELECT name FROM changes WHERE status = 'active' ORDER BY name").all();
+      // 真只读（坑 read-active-quiet-write-open，2026-09-12 审查批 C-⑤）：旧 new DB().init()
+      // 会跑 WAL PRAGMA（创建 -wal/-shm 侧车）且 schema 戳不匹配时执行 DDL 迁移——「只读探测」
+      // 实际改写被探测库。readOnly 打开零副作用；打开失败（损坏/权限）→ unreadable 降级不变。
+      db = openDatabase(dbPath, { readOnly: true });
+      const rows = db.prepare("SELECT name FROM changes WHERE status = 'active' ORDER BY name").all();
+      db.close();
       return { activeChanges: rows.map(r => r.name) };
     } catch (e) {
+      try { if (db) db.close(); } catch { /* 已关闭/打开失败 */ }
       return { activeChanges: [], unreadable: true, error: e.message };
     }
   }
@@ -314,7 +319,9 @@ export class ConsistencyDoctor {
     const fixable = []; // { stage, action, description, apply: (data) => void }
     const manual = [...splitManual];  // string
 
-    const now = new Date().toLocaleString('zh-CN', { hour12: false });
+    // ISO（Fix d 的 reopenedAt / Fix e 的 completedAt 均落库）：zh-CN 串的 '/' 在字符串 MAX 中
+    // 恒盖过 ISO 值，会污染 getLatestActivityAt 时近性闸与平台同步（2026-09-11 审查）
+    const now = new Date().toISOString();
 
     for (const stageName of STAGE_ORDER) {
       const sd = data.stages[stageName];

package/src/progress/stage-machine.js

@@ -632,7 +632,9 @@ export class StageMachine {
     // 执行重开操作
     const newRevision = (stageData.revision || 0) + 1;
     const fromStepName = steps[fromIdx].name;
-    const now = new Date().toLocaleString('zh-CN', { hour12: false });
+    // ISO（落库字段）：toLocaleString('zh-CN') 的 '/' 在字符串 MAX 中恒大于 ISO 的 '-'，污染
+    // getLatestActivityAt 等取最大值比较与平台 pydantic 解析（2026-09-11 审查）
+    const now = new Date().toISOString();
 
     // 更新步骤状态：fromStep 之前的保持 completed，fromStep 变 pending，之后的变 stale
     for (let i = 0; i < steps.length; i++) {

package/src/progress/step-store.js

@@ -134,24 +134,21 @@ export class StepStore {
       return;
     }
 
-    // 查找 step_id：通过 changes → stages → steps JOIN 查询
-    const sqlDb = db.getDb();
-    const stepRow = sqlDb.prepare(
-      `SELECT st.id, st.status FROM steps st
-       JOIN stages sg ON st.stage_id = sg.id
-       JOIN changes c ON sg.change_id = c.id
-       WHERE c.name = ? AND sg.stage = ? AND st.name = ?`
-    ).get(cn, stage, stepName);
-    if (stepRow === undefined) {
-      console.log(`❌ 步骤不存在: ${stage}/${stepName}`);
-      return;
-    }
-    const stepId = stepRow.id;
-
-    // UPDATE steps
+    // UPDATE steps（id 查找收进同一事务：事务外查询拿到的 id，可能在 UPDATE 前被他进程 _write 的
+    // steps DELETE+重插换成新自增 id——UPDATE 命中 0 行静默丢写且照常打印成功，2026-09-11 审查 P1）
     let stageCompletionCandidateId = null;
+    let stepFound = false;
     db.transaction(() => {
       const tDb = db.getDb();
+      const stepRow = tDb.prepare(
+        `SELECT st.id FROM steps st
+         JOIN stages sg ON st.stage_id = sg.id
+         JOIN changes c ON sg.change_id = c.id
+         WHERE c.name = ? AND sg.stage = ? AND st.name = ?`
+      ).get(cn, stage, stepName);
+      if (stepRow === undefined) return;
+      stepFound = true;
+      const stepId = stepRow.id;
       const now = new Date().toISOString();
       if (status) {
         tDb.prepare('UPDATE steps SET status = ?, completed_at = ? WHERE id = ? AND name = ?').run(status, status === 'completed' ? now : null, stepId, stepName);
@@ -179,6 +176,11 @@ export class StepStore {
       this.pm._touchLocalModified(cwd, cn, now);
     });
 
+    if (!stepFound) {
+      console.log(`❌ 步骤不存在: ${stage}/${stepName}`);
+      return;
+    }
+
     if (stageCompletionCandidateId !== null) {
       const { force = false } = options;
       const validation = this.pm._validateStageArtifacts(cwd, stage, cn);
@@ -199,11 +201,22 @@ export class StepStore {
             validationErrors: validation.errors,
           });
         }
+        let stageMarkedCompleted = false;
         db.transaction(() => {
           const tDb = db.getDb();
-          tDb.prepare(`UPDATE stages SET status = 'completed', completed_at = ? WHERE id = ?`).run(new Date().toISOString(), stageCompletionCandidateId);
+          // 提交前复查：validator 窗口（execute 校验可 spawn git 最长 15s+）内他进程 addStep 新增
+          // pending 步或 reset 本阶段——按候选 id 盲写会把未完成阶段错标 completed（2026-09-11 审查）
+          const recheck = tDb.prepare("SELECT COUNT(*) AS cnt FROM steps WHERE stage_id = ? AND status NOT IN ('completed','skipped')").get(stageCompletionCandidateId);
+          if (recheck.cnt === 0) {
+            tDb.prepare(`UPDATE stages SET status = 'completed', completed_at = ? WHERE id = ?`).run(new Date().toISOString(), stageCompletionCandidateId);
+            stageMarkedCompleted = true;
+          }
         });
-        console.log(`✅ 阶段 ${stage} 所有步骤已完成，阶段已标记为 completed`);
+        if (stageMarkedCompleted) {
+          console.log(`✅ 阶段 ${stage} 所有步骤已完成，阶段已标记为 completed`);
+        } else {
+          console.log(`ℹ️  阶段 ${stage} 在校验窗口内出现新的未完成步骤，本次不标记 completed`);
+        }
       }
     }
 

package/src/progress.js

@@ -806,6 +806,22 @@ export class ProgressManager {
    *   3. 单进程内调用串行（design §9），事务窗口短（毫秒级），全量写正确性远高于 diff 的边际收益。
    * 结论：全量 UPSERT 的简单正确性 > 持锁窗口优化的边际收益，不强行改 diff。
    */
+  /** .bak 快照节流间隔（坑2②）：5 分钟——损坏回退最坏丢 5 分钟进度，换取每次写零额外负担 */
+  static SNAPSHOT_INTERVAL_MS = 5 * 60_000;
+
+  _maybeSnapshotBak(cwd) {
+    try {
+      const dbPath = this._runtimePath(cwd, 'sillyspec.db');
+      const bakPath = dbPath + '.bak';
+      const st = existsSync(bakPath) ? statSync(bakPath) : null;
+      if (st && Date.now() - st.mtimeMs < ProgressManager.SNAPSHOT_INTERVAL_MS) return;
+      const tmpPath = bakPath + '.tmp';
+      try { unlinkSync(tmpPath) } catch { /* 不存在即无事 */ }
+      this._ensureDB(cwd).getDb().exec(`VACUUM INTO '${tmpPath.replace(/'/g, "''")}'`);
+      renameSync(tmpPath, bakPath);
+    } catch { /* best-effort：快照失败只损失恢复源新鲜度，不影响写入主流程 */ }
+  }
+
   _write(cwd, data, changeName = null) {
     const cn = changeName || data.currentChange;
     if (!cn) {
@@ -813,6 +829,13 @@ export class ProgressManager {
       return;
     }
 
+    // 坑 platform-sync-progress-rollback-and-db-corruption 坑2②（2026-09-08 实证）：并发写
+    // 把主库打成 0 字节时 .bak 全空——fail-loud 有其设计正当性但无恢复出路，只能删库重放。
+    // 定期 .bak 快照（5 分钟龄控）让 db.js _openWithFallback 的既有回退链获得新鲜恢复源：
+    // 损坏最坏回退到 ≤5min 前的进度，而不是从零重放。VACUUM INTO 产出一致性快照（对 WAL
+    // 并发写安全；比裸 copyFileSync 正确），best-effort 失败不影响写入主流程。
+    this._maybeSnapshotBak(cwd);
+
     const db = this._ensureDB(cwd);
     db.transaction(() => {
       const sqlDb = db.getDb();
@@ -908,6 +931,9 @@ export class ProgressManager {
   // verifyStartAt 基准只读（2026-09-08-ir-verify-facts）：execute 行 completed_at；无行 null 走 R-05 fallback
   getStageCompletedAt(cwd, changeName, stage) { return this._changeRegistry.getStageCompletedAt(cwd, changeName, stage); }
 
+  // 最近进度活动时刻只读（D-002@v1 复潮）：quick --done 自动归档闸的时近性信号
+  getLatestActivityAt(cwd, changeName) { return this._changeRegistry.getLatestActivityAt(cwd, changeName); }
+
   // evidence mtime 窗口锚点（2026-09-10 用户反馈②）：execute 行 started_at——证据合法产自 execute
   // 或 verify 两窗口，锚「完成时刻」会把 execute 期间产的证据判旧（时序两难）；无行 null 走 completed_at → R-05
   getStageStartedAt(cwd, changeName, stage) { return this._changeRegistry.getStageStartedAt(cwd, changeName, stage); }