sillyspec 3.28.7 → 3.28.9

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

@@ -1,7 +1,45 @@
 // W6 Step9b: 变更注册表（changes 表生命周期）—— 注册/注销/重命名/隔离状态/平台同步戳/审批状态。
 // 从 src/progress.js 单体 ProgressManager 抽出。持有 pm 引用（构造注入），调 pm._ensureDB /
 // pm._changePath（persistence-core 留 facade 本体）。无共享常量依赖。
-import { existsSync, mkdirSync, renameSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, renameSync } from 'fs';
+import { join } from 'path';
+
+// 所有权活跃心跳窗缺省（2026-09-14-change-ownership-guards task-02 / FR-01）：owner 非本会话
+// 且 now-last_active < 窗口 → 拒绝接管；窗口外 → 自动接管。local.yaml change-ownership.
+// heartbeat_minutes 可调（resolveHeartbeatMs），缺省 15 分钟（config-schema 已登记 live 读者=本文件）。
+const DEFAULT_HEARTBEAT_MINUTES = 15;
+
+/**
+ * 读 local.yaml 的 change-ownership.heartbeat_minutes → 毫秒窗（2026-09-14-change-ownership-guards
+ * task-02）。路径口径与 sync.js readLocalYaml / worktree-cross.js 一致：cwd/.sillyspec/local.yaml。
+ * 定向行扫描（只找 change-ownership: 顶层段下的 heartbeat_minutes），不引 YAML 解析依赖、
+ * 字节级容错（CRLF 去 \r、注释行天然不匹配）。缺文件/缺段/缺键/值非正整数（含 0——误配把
+ * 活跃窗清零会让护栏形同虚设）→ 缺省 15 分钟。纯读不抛。模块私有（唯一消费者=
+ * assertChangeOwnership 心跳窗缺省解析；config-schema 登记的读者即本文件）。
+ * @param {string} cwd - 项目根目录
+ * @returns {number} 心跳窗口毫秒
+ */
+function resolveHeartbeatMs(cwd) {
+  try {
+    const p = join(cwd || process.cwd(), '.sillyspec', 'local.yaml');
+    if (!existsSync(p)) return DEFAULT_HEARTBEAT_MINUTES * 60 * 1000;
+    let inSection = false;
+    for (const rawLine of readFileSync(p, 'utf8').split('\n')) {
+      const line = rawLine.replace(/\r$/, ''); // CRLF 兼容（CLAUDE.md #13）
+      if (/^\S/.test(line)) { // 顶层 key 行：进/出 change-ownership 段
+        inSection = line.startsWith('change-ownership:');
+        continue;
+      }
+      if (!inSection) continue;
+      const m = line.match(/^\s*heartbeat_minutes\s*:\s*(\d+)\s*$/);
+      if (m) {
+        const minutes = parseInt(m[1], 10);
+        return (Number.isFinite(minutes) && minutes >= 1) ? minutes * 60 * 1000 : DEFAULT_HEARTBEAT_MINUTES * 60 * 1000;
+      }
+    }
+  } catch { /* 读失败 → 缺省（缺省是安全下界，不是语义分支） */ }
+  return DEFAULT_HEARTBEAT_MINUTES * 60 * 1000;
+}
 
 export class ChangeRegistry {
   constructor(pm) {
@@ -76,15 +114,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; }
   }
 
@@ -132,8 +176,13 @@ export class ChangeRegistry {
   /**
    * 注册变更到活跃列表
    * SQL: INSERT OR IGNORE → 若已 archived 则 UPDATE status='active'
+   * @param {string} cwd
+   * @param {string} changeName
+   * @param {{ ownerSession?: string|null }} [opts] - owner_session（2026-09-14-change-ownership-guards
+   *   task-01：首建者获得所有权；INSERT OR IGNORE 语义天然「已有行不覆盖」——已存在行（含他人
+   *   活跃 change）owner 不动。会话标识三级方案的接线在 task-02，缺省 undefined=不写（列默认 NULL=无主））
    */
-  registerChange(cwd, changeName) {
+  registerChange(cwd, changeName, opts = {}) {
     if (!changeName) {
       console.warn('⚠️  registerChange: changeName 为空，跳过');
       return;
@@ -142,11 +191,11 @@ export class ChangeRegistry {
     db.transaction(() => {
       const sqlDb = db.getDb();
       const now = new Date().toISOString();
-      // 尝试插入新行
+      // 尝试插入新行（带 owner_session——首次创建者获得所有权，已有值不覆盖）
       const ins = sqlDb.prepare(
-        `INSERT OR IGNORE INTO changes (name, created_at, last_active)
-         VALUES (?, ?, ?)`
-      ).run(changeName, now, now);
+        `INSERT OR IGNORE INTO changes (name, created_at, last_active, owner_session)
+         VALUES (?, ?, ?, ?)`
+      ).run(changeName, now, now, opts.ownerSession || null);
       // 只在真正创建 change 时标脏（D-013/task-04）；已存在行不标（读路径/重复调用不误判脏）
       if (ins.changes > 0) this.pm._touchLocalModified(cwd, changeName, now);
       // 注意：不复活已归档的变更——归档是不可逆操作
@@ -154,6 +203,131 @@ export class ChangeRegistry {
     });
   }
 
+  /**
+   * 读变更所有者会话标识（2026-09-14-change-ownership-guards task-01 数据载体，D-001/D-005@v1）。
+   * 只读不抛（与 getQuicklogId 同族容错）：行缺失/未登记/读取失败 → null。
+   * NULL=无主（存量行 v6 迁移后即此态，任何会话可接管——判定/接管语义在 assertChangeOwnership，task-02）。
+   * @param {string} cwd
+   * @param {string} changeName
+   * @returns {string|null} owner 会话标识，无主/无行/读失败返回 null
+   */
+  getChangeOwner(cwd, changeName) {
+    if (!changeName) return null;
+    try {
+      const db = this.pm._ensureDB(cwd);
+      const row = db.getDb().prepare('SELECT owner_session FROM changes WHERE name = ?').get(changeName);
+      return (row && typeof row.owner_session === 'string' && row.owner_session) || null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * 认领变更所有权（2026-09-14-change-ownership-guards task-01 数据载体）：
+   * - 行不存在 → 创建并写 owner=session（首建者获得）；
+   * - 行存在且 owner 非空 → 不覆盖，返回既有 owner（调用方对比可知认领未成功）；
+   * - 行存在且 owner 为 NULL（存量无主行）→ 认领写入。
+   * 单事务内「INSERT OR IGNORE + 守卫 UPDATE + 读回」，并发两个会话同时首认领时靠
+   * SQLite 单写者串行化——后者命中守卫（owner 已非 NULL）不覆盖，返回先到者。
+   * 实际变更（首建/认领）标本地脏度（owner 随同步 payload 上行，D-013 同族）。
+   * @param {string} cwd
+   * @param {string} changeName
+   * @param {string|null} session - 本会话标识（空值视为无主认领，只建行不写 owner）
+   * @returns {string|null} 实际 owner（首建/认领成功=session；他人已持有=其值；行刚建未写=null）
+   */
+  claimChangeOwner(cwd, changeName, session) {
+    if (!changeName) return null;
+    const db = this.pm._ensureDB(cwd);
+    const now = new Date().toISOString();
+    return db.transaction(() => {
+      const sqlDb = db.getDb();
+      // 1) 首建：INSERT OR IGNORE 写 own（行已存在则零行、既有 owner 不动）
+      const ins = sqlDb.prepare(
+        `INSERT OR IGNORE INTO changes (name, created_at, last_active, owner_session)
+         VALUES (?, ?, ?, ?)`
+      ).run(changeName, now, now, session || null);
+      // 2) 存量无主行（owner NULL/空串）补认领；WHERE 守卫保证已有值（他人）绝不覆盖
+      let claimed = 0;
+      if (session) {
+        claimed = sqlDb.prepare(
+          `UPDATE changes SET owner_session = ? WHERE name = ? AND (owner_session IS NULL OR owner_session = '')`
+        ).run(session, changeName).changes;
+      }
+      // 3) 实际变更（首建/认领命中）才标脏；纯读回（他人持有）不扰动同步脏度
+      if (ins.changes > 0 || claimed > 0) this.pm._touchLocalModified(cwd, changeName, now);
+      // 4) 读回实际 owner
+      const row = sqlDb.prepare('SELECT owner_session FROM changes WHERE name = ?').get(changeName);
+      return (row && row.owner_session) || null;
+    });
+  }
+
+  /**
+   * 所有权判定（2026-09-14-change-ownership-guards task-02，FR-01 / D-001@v1）：
+   * **读 changes 行不写库**——接管写库归调用方（setChangeOwner / claimChangeOwner），
+   * 判定与写分离让接线点可在锁内先判后写（判定-执行无 TOCTOU 由调用方锁保证）。
+   * 分支（self 判定 = 精确字符串等值）：
+   *   - opts.forced（--takeover）            → takeover-forced       放行（无条件接管，调用方重写 owner 留痕）
+   *   - owner 为空（无行/NULL）               → no-owner              放行（存量无主行，任何会话可接管）
+   *   - owner === selfSession                 → self                  放行（本会话自有 change 零路径变化）
+   *   - owner 他人 且 now-last_active ≥ 窗口  → takeover-stale        放行（窗口外自动接管重写）
+   *   - owner 他人 且活跃窗内                 → blocked-active-owner  拒绝（allowed:false，调用方打结构化错误）
+   * last_active 缺失/不可解析按陈旧处理：无法证明新鲜即不拦——护栏拦「可证活跃」，不因时间戳
+   * 损坏把 change 锁死到无人能接管（逃生通道优先，与 getLatestActivityAt 族 fail-open 同哲学）。
+   * 心跳即 last_active：每次 CLI 写操作既有刷新（updateChangeIsolation/registerChange 等族）。
+   * @param {string} cwd
+   * @param {string} changeName
+   * @param {{ selfSession?: string|null, nowMs?: number, heartbeatMs?: number, forced?: boolean }} [opts]
+   * @returns {{allowed: boolean, action: 'self'|'takeover-stale'|'takeover-forced'|'no-owner'|'blocked-active-owner', owner: string|null, lastActive: string|null, heartbeatMs: number}}
+   */
+  assertChangeOwnership(cwd, changeName, opts = {}) {
+    const heartbeatMs = (Number.isFinite(opts.heartbeatMs) && opts.heartbeatMs > 0)
+      ? opts.heartbeatMs
+      : resolveHeartbeatMs(cwd);
+    const deny = (action, owner, lastActive) => ({ allowed: false, action, owner, lastActive, heartbeatMs });
+    if (!changeName) return { allowed: true, action: 'no-owner', owner: null, lastActive: null, heartbeatMs };
+    const row = this.pm._ensureDB(cwd).getDb()
+      .prepare('SELECT owner_session, last_active FROM changes WHERE name = ?').get(changeName);
+    const owner = (row && typeof row.owner_session === 'string' && row.owner_session) || null;
+    const lastActive = (row && typeof row.last_active === 'string' && row.last_active) || null;
+    if (opts.forced) return { allowed: true, action: 'takeover-forced', owner, lastActive, heartbeatMs };
+    if (owner === null) return { allowed: true, action: 'no-owner', owner: null, lastActive, heartbeatMs };
+    if (owner === opts.selfSession) return { allowed: true, action: 'self', owner, lastActive, heartbeatMs };
+    // owner 他人：新鲜度决定拒绝 / 自动接管
+    const lastMs = lastActive ? new Date(lastActive).getTime() : NaN;
+    const nowMs = Number.isFinite(opts.nowMs) ? opts.nowMs : Date.now();
+    const stale = !Number.isFinite(lastMs) || (nowMs - lastMs) >= heartbeatMs;
+    return stale
+      ? { allowed: true, action: 'takeover-stale', owner, lastActive, heartbeatMs }
+      : deny('blocked-active-owner', owner, lastActive);
+  }
+
+  /**
+   * 强制重写所有者（task-02 接管写库侧；claimChangeOwner 的对照——那把守卫「已有值不覆盖」，
+   * 本方法无条件写）：assertChangeOwnership 放行 no-owner/takeover-stale/takeover-forced 后由
+   * 接线调用。同事务刷新 last_active——新 owner 的心跳从接管时刻起算，否则下次校验仍读到
+   * 旧 owner 的陈旧时间戳，接管形同没发生（立刻又可被他人 takeover-stale 抢走）。行缺失先建
+   * （INSERT OR IGNORE）。实际变更标本地脏度（owner_session 随同步 payload 上行，D-013 同族）。
+   * @param {string} cwd
+   * @param {string} changeName
+   * @param {string|null} session - 接管者的会话标识
+   */
+  setChangeOwner(cwd, changeName, session) {
+    if (!changeName) return;
+    const db = this.pm._ensureDB(cwd);
+    const now = new Date().toISOString();
+    db.transaction(() => {
+      const sqlDb = db.getDb();
+      const ins = sqlDb.prepare(
+        `INSERT OR IGNORE INTO changes (name, created_at, last_active, owner_session)
+         VALUES (?, ?, ?, ?)`
+      ).run(changeName, now, now, session || null);
+      const upd = sqlDb.prepare(
+        'UPDATE changes SET owner_session = ?, last_active = ? WHERE name = ?'
+      ).run(session || null, now, changeName);
+      if (ins.changes > 0 || upd.changes > 0) this.pm._touchLocalModified(cwd, changeName, now);
+    });
+  }
+
   /**
    * 更新变更的隔离状态
    * @param {string} cwd - 项目根目录
@@ -257,9 +431,16 @@ export class ChangeRegistry {
       // 永不携带（乐观锁失效）、本地脏度恒 false、platform status behind 恒跳过。值优先
       // 平台回执 last_pushed_at，缺省回退本次 X-SillySpec-Pushed-At（后端 _apply 存的就是
       // 该 header 原值，回写与服务器精确一致）。COALESCE 保旧值：无 syncedTs 只推进展示列。
+      // ql-20260914-001：COALESCE 直写改 MAX 单调推进（坑 sync-base-ts-out-of-order-backfill）——
+      // 同机多进程（CLI 会话 ×N + 步进链）并发推送时，A(t1)/B(t2) 乱序回填会让迟到的旧回执
+      // 覆盖已推进的 base（multi-agent-platform 实证：6 个假冲突的 base 全部停在上一轮值），
+      // 回声窗重开 → 下次 push 409/pull 假冲突。MAX 只升不降：base ≥ 回执恒安全（平台 409
+      // 判据是 stored > base，base 偏高只会让推送被接受，绝不产生假 409）；仅当回执比现存
+      // base 旧（乱序/平台侧回退）时改变行为——正是要防的覆写。与 resolve/自愈路径的
+      // MAX 写法（sync.js 四处）对齐，消除本仓最后一个直写点。
       sqlDb.prepare(
-        'UPDATE changes SET platform_last_sync = ?, platform_sync_enabled = 1, last_synced_platform_ts = COALESCE(?, last_synced_platform_ts) WHERE name = ?'
-      ).run(new Date().toISOString(), syncedTs, changeName);
+        'UPDATE changes SET platform_last_sync = ?, platform_sync_enabled = 1, last_synced_platform_ts = MAX(COALESCE(?, last_synced_platform_ts), COALESCE(last_synced_platform_ts, ?)) WHERE name = ?'
+      ).run(new Date().toISOString(), syncedTs, syncedTs, changeName);
     });
   }
 
@@ -309,44 +490,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/shared.js

@@ -26,8 +26,9 @@ export const STAGE_ORDER = ['scan', 'brainstorm', 'plan', 'execute', 'verify', '
 // （consistency-doctor 坑 + prompt-control-debt plan-c 同根因）。
 export const MAIN_FLOW_ORDER = ['brainstorm', 'plan', 'execute', 'verify', 'archive'];
 
-// progress 数据版本（v3 = SQLite；v4 = changes 加 base_ts / 本地脏度两列，platform-sync §8）
-export const CURRENT_VERSION = 5;
+// progress 数据版本（v3 = SQLite；v4 = changes 加 base_ts / 本地脏度两列，platform-sync §8；
+// v6 = changes 加 owner_session 所有权列，2026-09-14-change-ownership-guards D-005@v1）
+export const CURRENT_VERSION = 6;
 
 // 滞留提示阈值（天，2026-08-30 用户反馈②：7 个「代码全落地但流程没收口」的变更挂 38 天
 // 无人发现）：活跃变更 last_active 距今超该天数且流程未收口（archive 未完成）时，progress

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`);
+        }
       }
     }