sillyspec 3.28.7 → 3.28.8

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

@@ -76,15 +76,21 @@ export class ChangeRegistry {
       const sqlDb = db.getDb();
       const ch = sqlDb.prepare(`SELECT id FROM changes WHERE name = ?`).get(changeName);
       if (!ch) return null;
-      const row = sqlDb.prepare(
-        `SELECT MAX(ts) AS latest FROM (
-           SELECT MAX(completed_at) AS ts FROM stages WHERE change_id = ?
-           UNION ALL
-           SELECT MAX(st.completed_at) AS ts FROM steps st
-             JOIN stages s ON st.stage_id = s.id WHERE s.change_id = ?
-         )`
-      ).get(ch.id, ch.id);
-      return row && row.latest ? row.latest : 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; }
   }
 
@@ -309,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();

package/src/quicklog.js

@@ -67,6 +67,13 @@ export async function withFileLock(lockPath, fn, opts = {}) {
               if (!restored) { try { unlinkSync(claim) } catch {} }
             }
           } catch {}
+          // 偷锁重试前同样受超时与退避约束（坑 quicklog-lock-steal-spin，2026-09-12 审查批 A-③）：
+          // 旧版 continue 直接跳过下方检查——锁文件被 AV/索引器长期占用、renameSync 持续失败
+          // （每次被外层 catch 吞掉）时忙等自旋：不检查 timeoutMs、不让出 CPU，命令挂死 + 100% CPU。
+          if (Date.now() - start > timeoutMs) {
+            throw new Error(`文件锁超时（${timeoutMs}ms）: ${lockPath}`)
+          }
+          await sleep(retryMs)
           continue
         }
       } catch {}
@@ -80,7 +87,13 @@ export async function withFileLock(lockPath, fn, opts = {}) {
     return await fn()
   } finally {
     try { closeSync(fd) } catch {}
-    try { unlinkSync(lockPath) } catch {} // 释放（容忍已不存在）
+    // 释放前校验持有者身份（坑 quicklog-lock-release-mismatch，2026-09-12 审查批 A-③）：
+    // 本进程临界区超 staleMs 被他进程偷锁后，lockPath 上可能是**他人新建**的锁——无条件
+    // unlink 误删它会让第三方抢锁成功，形成双进程并发临界区。仅内容仍为本会话 myId 才删
+    // （读失败=锁已不在/被偷，容忍——偷锁路径自会回收旧 claim）。
+    try {
+      if (readFileSync(lockPath, 'utf8') === myId) unlinkSync(lockPath)
+    } catch {}
   }
 }
 
@@ -718,7 +731,12 @@ export async function allocateQuicklogEntry(specBase, gitUser, { description, li
   const files = Array.isArray(allowedFiles) ? allowedFiles : []
   const today = todayStamp()
 
-  return await withFileLock(lockPath, async () => {
+  // 平台推送在锁外执行（2026-09-11 审查性能包①）：锁内 5s 网络推送 + 逐变更 tasks 锁
+  // （最坏各 10s）可使临界区突破 30s stale 偷锁阈值——他进程偷锁后双写者并发，正是本模块
+  // 头声明要根治的并发丢更新被重新打开。推送 best-effort 不回写本地，锁外语义等同（原注释
+  // 自证），仅放弃「分配即推送」的顺序一致性（平台为 best-effort 面板，乱序窗口极小）。
+  let pushPayload = null
+  const { qlId } = await withFileLock(lockPath, async () => {
     const { maxSeq, usedSuffix } = scanExisting(quicklogDir, today)
     const nextSeq = maxSeq + 1
     // XXXX 4 位 hex 随机后缀（消歧；NNN 已在锁内顺序分配保证唯一，此处仅 belt-and-suspenders）
@@ -744,9 +762,7 @@ export async function allocateQuicklogEntry(specBase, gitUser, { description, li
 
     for (const c of linked) await appendTaskCheckbox(specBase, c, qlId, desc)
 
-    // 平台推送（task-06 / FR-02 / D-003）：锁外语义等同（推送不回写本地），但放锁内
-    // 保证「分配即推送」顺序一致；best-effort 失败不影响返回。
-    await pushQuicklogEntryToPlatform(specBase, {
+    pushPayload = {
       ql_id: qlId,
       timestamp: nowDatetime(),
       title: desc,
@@ -758,10 +774,13 @@ export async function allocateQuicklogEntry(specBase, gitUser, { description, li
       files: files.map(f => ({ path: f, note: null })),
       body_sections: {},
       raw_block: entry,
-    }).catch(() => {}) // pushQuicklogEntryToPlatform 自身已吞错；双保险防未来改动破坏 best-effort 契约
-
+    }
     return { qlId }
   })
+  if (pushPayload) {
+    await pushQuicklogEntryToPlatform(specBase, pushPayload).catch(() => {}) // 自身已吞错；双保险防未来改动破坏 best-effort 契约
+  }
+  return { qlId }
 }
 
 /**
@@ -785,9 +804,11 @@ export async function appendQuicklogEntryWithId(specBase, gitUser, qlId, { descr
   const linked = Array.isArray(linkedChanges) ? linkedChanges : []
   const files = Array.isArray(allowedFiles) ? allowedFiles : []
 
-  return await withFileLock(lockPath, async () => {
+  // 推送出锁（同 allocateQuicklogEntry 性能包①：临界区只留本地写 + tasks 挂载）
+  let pushPayload = null
+  const { existed } = await withFileLock(lockPath, async () => {
     // 双检（锁内）：并发兜底同 ID 只落一条
-    if (findQuicklogEntry(specBase, gitUser, qlId)) return { qlId, existed: true }
+    if (findQuicklogEntry(specBase, gitUser, qlId)) return { existed: true }
     await rotateIfNeeded(userFile, user)
     const entry = [
       '',
@@ -799,7 +820,7 @@ export async function appendQuicklogEntryWithId(specBase, gitUser, qlId, { descr
     ].join('\n')
     appendFileSync(userFile, entry)
     for (const c of linked) await appendTaskCheckbox(specBase, c, qlId, desc)
-    await pushQuicklogEntryToPlatform(specBase, {
+    pushPayload = {
       ql_id: qlId,
       timestamp: nowDatetime(),
       title: desc,
@@ -810,9 +831,13 @@ export async function appendQuicklogEntryWithId(specBase, gitUser, qlId, { descr
       files: files.map(f => ({ path: f, note: null })),
       body_sections: {},
       raw_block: entry,
-    }).catch(() => {})
-    return { qlId, existed: false }
+    }
+    return { existed: false }
   })
+  if (pushPayload && !existed) {
+    await pushQuicklogEntryToPlatform(specBase, pushPayload).catch(() => {})
+  }
+  return { qlId, existed }
 }
 
 /**
@@ -837,10 +862,12 @@ export async function completeQuicklogEntry(specBase, gitUser, qlId, { resultTex
     ? softFiles.filter(Boolean).map((f) => String(f).replace(/\\/g, '/'))
     : []
 
+  // 推送出锁（性能包①）：终态 payload 以锁内落盘结果组装，锁外 best-effort 推送 + sidecar 持久化
+  // （sidecar 与推送同源同解析器，同移锁外不改变「以落盘终态为准」语义）
+  let finalPayload = null
   await withFileLock(lockPath, async () => {
     // 条目可能在主文件或轮转归档中
     let updatedContent = null
-    let updatedFile = null
     for (const f of listQuicklogFiles(quicklogDir)) {
       const filePath = join(quicklogDir, f)
       let content = ''
@@ -850,7 +877,6 @@ export async function completeQuicklogEntry(specBase, gitUser, qlId, { resultTex
       if (updated !== null) {
         await writeAtomic(filePath, updated) // 命中处原子落盘（只改含目标条目的那一个文件）
         updatedContent = updated
-        updatedFile = filePath
         break
       }
     }
@@ -860,16 +886,16 @@ export async function completeQuicklogEntry(specBase, gitUser, qlId, { resultTex
     // （design §5.3：翻完成时标题行被 extractTitleFromResult 刷新，推送须与落盘一致，
     // 不能用入参拼——标题/结果块/文件行都会在 flipEntryInContent 中重写）。
     const rawBlock = extractRawBlock(updatedContent, qlId)
-    const finalPayload = buildPushPayloadFromRaw(rawBlock, {
+    finalPayload = buildPushPayloadFromRaw(rawBlock, {
       ql_id: qlId,
       author_raw: user,
       status: 'completed',
       linked_changes: linked,
     })
-    // P1-4：终态结构 sidecar 持久化（同一解析器产出，md/sidecar 恒一致；fail-soft）
-    writeQuicklogSidecar(specBase, finalPayload)
-    await pushQuicklogEntryToPlatform(specBase, finalPayload).catch(() => {})
   })
+  // P1-4：终态结构 sidecar 持久化（同一解析器产出，md/sidecar 恒一致；fail-soft）
+  writeQuicklogSidecar(specBase, finalPayload)
+  await pushQuicklogEntryToPlatform(specBase, finalPayload).catch(() => {})
 }
 
 /**