sillyspec 3.28.8 → 3.28.10

package/src/probe7-anchor-check.js

@@ -0,0 +1,69 @@
+/**
+ * probe7-anchor-check.js — verify-result.md 探针7 矩阵 covered 行证据锚点校验（零环新模块）。
+ *
+ * 坑 probe7-covered-anchor-missing（2026-09-15 复盘实证：探针7 矩阵第一轮 7 行 covered 判定的
+ * 证据列缺 file:line 锚点被审查打回——预填说明写着「证据列给首命中 file:line 锚点」但模板要求
+ * 没细读就交，人工往返一轮）。本模块把该口径机器化：verify --done 时点解析正文探针7 段，
+ * 判定列=covered 的行必须含 `path:line` 形态锚点，缺则 advisory 提示回补。
+ *
+ * 定位与边界：
+ * - **advisory 不阻断**：covered 行缺锚点只 warn（证据可以是合法的人工核验形态，但 covered=
+ *   有归属测试命中，锚点理应存在——缺锚点大概率是 agent 改写预填时丢了，回补成本低）。
+ * - 只查 covered：partial/uncovered/non-testable 的证据形态多样（人工核验提示/理由），不做
+ *   锚点要求（误报面大于收益）。
+ * - 独立模块而非长在 verify-probes.js：后者是多会话高频冲突面（探针3/5 家族改动多发），
+ *   本校验只消费 verify-result.md 文本，零依赖单文件最稳。
+ * - 表格列序与 renderProbe7Lines 骨架同源锚定：| acceptance | 归属测试 | 关键词命中 | 判定 | 证据 |
+ *   → split('|') 后 cells[4]=判定、cells[5]=证据（首尾空串偏移）。
+ */
+
+// file:line 锚点：冒号后跟数字（`test/x.test.mjs:42`、`src/a.py:12-18` 均命中）
+const ANCHOR_RE = /:\d+\b/
+
+// 判定枚举纯值（骨架四枚举；容忍反引号包裹——门禁层 extractAcceptanceMatrixSlots 另有纯值校验）
+function normalizeVerdict(cell) {
+  return String(cell || '').trim().replace(/^`|`$/g, '').toLowerCase()
+}
+
+/**
+ * 校验探针7 矩阵 covered 行的证据锚点。
+ * @param {string} reportText verify-result.md 全文
+ * @returns {{applicable:boolean, rowsChecked:number, coveredRows:number,
+ *   missingAnchors:Array<{task:string, acceptance:string, evidence:string}>}}
+ *   applicable=false：正文无「#### 探针 7」段（quick/存量报告）——调用方零输出。
+ */
+export function checkProbe7AnchorCoverage(reportText) {
+  const out = { applicable: false, rowsChecked: 0, coveredRows: 0, missingAnchors: [] }
+  if (!reportText) return out
+  const lines = String(reportText).replace(/\r\n/g, '\n').split('\n')
+  const start = lines.findIndex(l => /^####\s*探针\s*7/.test(l))
+  if (start === -1) return out
+  let end = lines.length
+  for (let i = start + 1; i < lines.length; i++) {
+    if (/^####\s/.test(lines[i])) { end = i; break }
+  }
+  out.applicable = true
+  let task = null
+  for (let i = start + 1; i < end; i++) {
+    const line = lines[i]
+    const tm = line.match(/^\*\*(.+?)\*\*\s*$/)
+    if (tm) { task = tm[1].trim(); continue }
+    if (!line.startsWith('|')) continue
+    const cells = line.split('|').map(c => c.trim())
+    if (cells.length < 6) continue // 表头/分隔行之外的畸形行不参与（表头 6 列含首尾空串）
+    const verdict = normalizeVerdict(cells[4])
+    if (!['covered', 'partial', 'uncovered', 'non-testable'].includes(verdict)) continue
+    out.rowsChecked++
+    if (verdict !== 'covered') continue
+    out.coveredRows++
+    const evidence = cells[5] || ''
+    if (!ANCHOR_RE.test(evidence)) {
+      out.missingAnchors.push({
+        task: task || '(未知 task)',
+        acceptance: (cells[1] || '').slice(0, 80),
+        evidence: evidence.slice(0, 80),
+      })
+    }
+  }
+  return out
+}

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) {
@@ -138,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;
@@ -148,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);
       // 注意：不复活已归档的变更——归档是不可逆操作
@@ -160,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 - 项目根目录
@@ -263,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);
     });
   }
 

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.js

@@ -12,7 +12,7 @@
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, unlinkSync, appendFileSync, copyFileSync, readdirSync, statSync, realpathSync } from 'fs';
 import { join, basename, dirname, resolve, sep } from 'path';
-import { tmpdir } from 'os';
+import { tmpdir, hostname } from 'os';
 import { writeAtomicSync } from './fs-atomic.js';
 import { DB } from './db.js';
 import { checkExecuteCodeEvidence } from './stage-contract.js';
@@ -81,6 +81,61 @@ export class PlatformManagedError extends PointerUnreachableError {
   }
 }
 
+// ── 会话标识三级解析（2026-09-14-change-ownership-guards task-02，FR-01 / D-001@v1）──
+// 优先级：--session flag > env SILLYSPEC_SESSION_ID > quick 场景 changeName（quick-<8hex>，
+// 既有 sessionId 机制——guard 按 change 名落盘天然跨进程）> anon@<hostname> 机器级降级。
+// 降级时打一次性教学 warning：指引 export SILLYSPEC_SESSION_ID=<唯一标识> 或 --session，
+// 明示无标识时同机并行不设防（R-01 明示局限，防线=显式标识铁律+归档收口+--takeover 摩擦）。
+// 「一次性」双层降频：进程内 memo（同进程多次解析只报一次）+ 跨进程 marker 文件窗口
+// （warnSelfRefPointerOnce 同款模式；CLI 每次调用即新进程，纯进程 memo 会退化成每命令必报）。
+const ANON_SESSION_WARN_MARKER = 'anon-session-warn.json';
+const ANON_SESSION_WARN_WINDOW_MS = 24 * 60 * 60 * 1000; // 教学指引 24h 窗口（非告警，不设短窗）
+const QUICK_SID_PATTERN_FOR_IDENTITY = /^quick-[0-9a-f]{8}$/;
+let _anonSessionWarnedThisProcess = false;
+
+/**
+ * 解析本会话的所有权标识（纯函数 + 降级侧的一次性教学 warn）。
+ * @param {{ flagSession?: string|null, quickChangeName?: string|null, cwd?: string|null, warn?: boolean }} [opts]
+ *   - flagSession：--session flag 值（最高优先级；空串/空白视为未提供）
+ *   - quickChangeName：quick 场景的 changeName（匹配 quick-<8hex> 才启用第三级）
+ *   - cwd：教学 warning marker 落盘根（不提供则跳过跨进程降频，仅进程内 memo）
+ *   - warn：false 关闭教学 warning（机器消费路径）
+ * @returns {{session: string, source: 'flag'|'env'|'quick-session'|'anon-host'}}
+ */
+export function resolveSessionIdentity({ flagSession = null, quickChangeName = null, cwd = null, warn = true } = {}) {
+  const flag = typeof flagSession === 'string' ? flagSession.trim() : '';
+  if (flag) return { session: flag, source: 'flag' };
+  const env = typeof process.env.SILLYSPEC_SESSION_ID === 'string' ? process.env.SILLYSPEC_SESSION_ID.trim() : '';
+  if (env) return { session: env, source: 'env' };
+  if (quickChangeName && QUICK_SID_PATTERN_FOR_IDENTITY.test(quickChangeName)) {
+    return { session: quickChangeName, source: 'quick-session' };
+  }
+  const session = `anon@${hostname()}`;
+  if (warn && !_anonSessionWarnedThisProcess) {
+    let suppressed = false;
+    if (cwd) {
+      try {
+        const markerDir = join(cwd, SPEC_DIR_NAME, RUNTIME_SUBDIR);
+        mkdirSync(markerDir, { recursive: true });
+        const markerPath = join(markerDir, ANON_SESSION_WARN_MARKER);
+        const now = Date.now();
+        try {
+          const m = JSON.parse(readFileSync(markerPath, 'utf8'));
+          if (m && Number.isFinite(m.at) && now - m.at < ANON_SESSION_WARN_WINDOW_MS) suppressed = true;
+        } catch { /* 无 marker / 损坏 → 首报 */ }
+        if (!suppressed) writeFileSync(markerPath, JSON.stringify({ at: now }) + '\n');
+      } catch { /* marker 落盘失败 → 照常 warn（降频是优化不是语义） */ }
+    }
+    if (!suppressed) {
+      _anonSessionWarnedThisProcess = true;
+      console.warn(`⚠️ 未显式配置会话标识，所有权护栏已降级为机器级标识 ${session}（只拦他机，同机并行会话不设防）`);
+      console.warn(`   指引：会话启动时 export SILLYSPEC_SESSION_ID=<唯一标识>（如 agent 名+任务名），或在接管类命令上带 --session <唯一标识>（三级解析最高优先级）`);
+      console.warn(`   （24 小时内不重复提示）`);
+    }
+  }
+  return { session, source: 'anon-host' };
+}
+
 /**
  * 平台感知的 specDir 解析（fail-closed，所有 CLI 子命令统一入口）。
  *
@@ -435,7 +490,7 @@ export class ProgressManager {
     }
 
     const result = {
-      _version: 5,
+      _version: 6,
       project: projectName,
       currentChange: cName,
       currentStage: currentStage || '',
@@ -460,7 +515,9 @@ export class ProgressManager {
    * 输出契约（字段名 = DB 列名 snake_case，import 直接对列写回，round-trip 无映射损耗）：
    *   project        { name, schema_version }                                        —— 全局单行稳定字段（id/created_at/updated_at 本地元数据不同步）
    *   changes        [{ name, current_stage, status, last_active,
-   *                      last_synced_platform_ts, last_local_modified_ts }]           —— 只投影流程进度列；
+   *                      last_synced_platform_ts, last_local_modified_ts, owner_session }] —— 只投影流程进度列
+   *                     + 所有权列 owner_session（v6，2026-09-14-change-ownership-guards D-005@v1；
+   *                     NULL=无主随 payload 带出，平台消费端不强制）；
    *                     排除 isolation_* 系列 与 platform_* 系列（platform_change_id/workspace_id/last_sync/sync_enabled）
    *                     以及 created_at（本地强相关，不同步，B2）
    *   stages         [{ change_name, stage, status, started_at, completed_at,
@@ -490,9 +547,9 @@ export class ProgressManager {
     const db = this._ensureDB(cwd);
     const sqlDb = db.getDb();
 
-    // 1. changes 行（投影流程进度列 + name 标识）
+    // 1. changes 行（投影流程进度列 + name 标识 + 所有权列 owner_session）
     const changeRow = sqlDb.prepare(
-      `SELECT id, name, current_stage, status, last_active, last_synced_platform_ts, last_local_modified_ts
+      `SELECT id, name, current_stage, status, last_active, last_synced_platform_ts, last_local_modified_ts, owner_session
        FROM changes WHERE name = ?`
     ).get(changeName);
     if (changeRow === undefined) return null;
@@ -504,6 +561,7 @@ export class ProgressManager {
       last_active: changeRow.last_active,
       last_synced_platform_ts: changeRow.last_synced_platform_ts ?? null,
       last_local_modified_ts: changeRow.last_local_modified_ts ?? null,
+      owner_session: changeRow.owner_session ?? null,
     };
 
     // 2. project 全局单行（只投影稳定字段 name/schema_version；created_at/updated_at 是本地库元数据，
@@ -600,7 +658,8 @@ export class ProgressManager {
    *
    * 语义：
    * - 单个 DB.transaction() 包裹，原子重建 stages/steps/batch_progress/approvals 四表（任一失败整体回滚）
-   * - changes 行用 UPDATE 选择投影列（current_stage/status/last_active/last_synced_platform_ts/last_local_modified_ts），
+   * - changes 行用 UPDATE 选择投影列（current_stage/status/last_active/last_synced_platform_ts/last_local_modified_ts
+   *   + owner_session 容错回写——payload 含该列才写），
    *   保留 isolation_* / platform_* / created_at（本地强相关状态不被覆盖，B2；change 不存在时 INSERT 兜底平台新增）
    * - import 后 last_synced_platform_ts 与 last_local_modified_ts 均置为 progressObj.pushed_at（D-013 例外：
    *   不更新 now()——否则 now()>base_ts 下次 pull 误判冲突；pushed_at 由 sync.js pull() 从响应 header attach）
@@ -673,6 +732,12 @@ export class ProgressManager {
           ch && ch.last_active != null ? ch.last_active : now,
           pushedAt, pushedAt, cn
         );
+        // owner_session 回写容错（v6，2026-09-14-change-ownership-guards task-01）：payload 含
+        // 该列（非 null）才写——他端旧版本快照无此列 → 跳过不报错，且本地已有 owner 不被置空
+        // （平台权威态随 payload 往返；serializeForSync↔import 互逆在非 null 值上成立）。
+        if (ch && ch.owner_session != null) {
+          sqlDb.prepare('UPDATE changes SET owner_session = ? WHERE name = ?').run(ch.owner_session, cn);
+        }
         const changeRow = sqlDb.prepare('SELECT id FROM changes WHERE name = ?').get(cn);
         const changeId = changeRow.id;
 
@@ -938,7 +1003,7 @@ export class ProgressManager {
   // 或 verify 两窗口，锚「完成时刻」会把 execute 期间产的证据判旧（时序两难）；无行 null 走 completed_at → R-05
   getStageStartedAt(cwd, changeName, stage) { return this._changeRegistry.getStageStartedAt(cwd, changeName, stage); }
 
-  registerChange(cwd, changeName) { return this._changeRegistry.registerChange(cwd, changeName); }
+  registerChange(cwd, changeName, opts) { return this._changeRegistry.registerChange(cwd, changeName, opts); }
 
   updateChangeIsolation(cwd, changeName, isolation) { return this._changeRegistry.updateChangeIsolation(cwd, changeName, isolation); }
 
@@ -972,6 +1037,28 @@ export class ProgressManager {
   // quick --done 兜底复用启动 ql-ID（坑 platform-takeover-phantom-progress-db 同日变体）
   getQuicklogId(cwd, changeName) { return this._changeRegistry.getQuicklogId(cwd, changeName); }
 
+  // ── change 所有权读写 API（2026-09-14-change-ownership-guards task-01 数据载体，D-001/D-005@v1）──
+  // 只铺数据读写；所有权判定/心跳窗口/接管语义（assertChangeOwnership）归 task-02 接线。
+
+  /** 读变更所有者会话标识；无行/未登记/无主 → null */
+  getChangeOwner(cwd, changeName) { return this._changeRegistry.getChangeOwner(cwd, changeName); }
+
+  /** 认领所有权：首建写 own、已有值不覆盖；返回实际 owner（string|null） */
+  claimChangeOwner(cwd, changeName, session) { return this._changeRegistry.claimChangeOwner(cwd, changeName, session); }
+
+  // task-02 接线（FR-01 / D-001@v1）：判定/接管/心跳窗——会话标识三级解析见模块级
+  // resolveSessionIdentity；接线点=index.js apply/cleanup/assess 自动 apply（锁内、实际动作前）。
+
+  /**
+   * 所有权判定（纯读不写库，详见 change-registry.assertChangeOwnership）：
+   * 四分支 self/no-owner/takeover-stale/takeover-forced 放行；他人且活跃窗内 →
+   * { allowed:false, action:'blocked-active-owner' }（owner+lastActive+heartbeatMs 供结构化错误）。
+   */
+  assertChangeOwnership(cwd, changeName, opts) { return this._changeRegistry.assertChangeOwnership(cwd, changeName, opts); }
+
+  /** 强制重写所有者+心跳起算（接管放行后的写库侧；claimChangeOwner 是「已有值不覆盖」守卫版） */
+  setChangeOwner(cwd, changeName, session) { return this._changeRegistry.setChangeOwner(cwd, changeName, session); }
+
   // ── CLI 命令 ──
 
   init(cwd) {
@@ -1018,10 +1105,15 @@ export class ProgressManager {
     }
     // quick 会话 id（quick-<uuid8>，见 run.js QUICK_SID_RE）只作 progress 的跨进程 session key，
     // 进度存 SQL 不需要实体 change 目录——跳过避免 changes/quick-<uuid>/ 空目录残留。
+    // default 兜底 key 同款待遇（坑 default-empty-dir-materialized，2026-09-14 用户反馈）：
+    // default 行是辅助阶段（explore 等）无实体产物的进度容器，物化 changes/default/ 空目录
+    // 纯污染——next.js 会报「变更目录为空→清理该空目录」误导、resolveChangeNameAuto 的目录
+    // 计数被搅动、spec 树上行空目录（本仓实证 changes/default/ 建于 09-11 零文件）。进度真相
+    // 在 DB 行；辅助阶段续跑锚定改由 run/command.js 的 default 行阶段亲和解析承担。
     // 注：日期前缀门禁（assertDatedChangeName）只在 CLI 边界强制（run --change / change-rename，
     // 见 run/command.js + index.js）——initChange 是库函数，测试/平台工具合法用任意名建 fixture，
     // 不在此设门（2026-09-11 决策，避免 ~30 处测试 fixture 非日期名被拦）。
-    if (!/^quick-[0-9a-f]{8}$/.test(changeName)) {
+    if (!/^quick-[0-9a-f]{8}$/.test(changeName) && changeName !== 'default') {
       this._ensureChangeDir(cwd, changeName);
     }