sillyspec 3.28.8 → 3.28.10

package/src/index.js

@@ -60,6 +60,9 @@ SillySpec CLI — 规范驱动开发工具包
              --force-rescan              覆盖已有 scan 文档保护
              --diff [--base <commit>] [--full] [--report]   scan 文档 vs 源码漂移清单（纯只读）
              （子命令: sillyspec scan diff 等价 --diff）
+             refresh [--project <名>] [--force] [--json]   增量刷新①拍：门控+受影响文档手术工单
+             refresh --done [--docs a.md,b.md] [--force]    增量刷新②拍：内容比对+per-doc 基线推进+postcheck
+             （检出极限：refresh 只覆盖带 file:line 引用的检出项，不声称文档与源码一致）
     archive: --confirm                   归档确认（必须）
     auto:    --mode <模式>               显式指定流程模式
     平台:    --runtime-root <path> / --workspace-id <id> / --scan-run-id <id>
@@ -70,6 +73,9 @@ SillySpec CLI — 规范驱动开发工具包
     check | repair [--apply] | validate | reset [--stage X] |
     batch --total N --completed M [--failed F] [--skipped K] | batch --status
 
+  sillyspec wt-commit [--change <名>] -m <信息> [--pathspec-from-file <f>] -- <path...>
+                                      worktree 内 per-task 串行化提交（文件锁排队 + 强制显式 pathspec，
+                                      防 add -A 卷入并行兄弟 WIP；worktree 内可省 --change，从 cwd 推断）
   sillyspec worktree <cmd>     git worktree 隔离管理（execute 阶段相关）
     create <change> [--base <branch>]   创建隔离 worktree
     apply <change> [--check-only]       校验并应用变更到主工作区
@@ -1109,6 +1115,18 @@ task 进行中状态标记：开工/完工落 .runtime/task-progress/，list 标
             console.log(`📄 已补齐缺失槽段（不触碰既有正文）: ${vpAdded.added.join('、')}`)
           }
         }
+        // 2026-09-14-acceptance-test-matrix：探针 7 验收×测试覆盖矩阵骨架幂等补段——
+        // verify-result.md 已存在但缺「#### 探针 7」段且 applicable（有 TaskCard）时补矩阵
+        // 骨架（学 backfillMissingEvidenceSlots 形态，不触既有正文；判定/证据槽 fail-closed
+        // 由 verify 门禁负责）。本变更自举：verify-result.md 先于特性存在的存量走此补段。
+        try {
+          const { ensureAcceptanceMatrixSection } = await import('./verify-probes.js')
+          const vpMatrix = ensureAcceptanceMatrixSection(vpReportPath, vpResult.probe7)
+          if (vpMatrix.added) {
+            try { await mirrorInitArtifact(vpReportPath, 'verify-result.md', readFileSync(vpReportPath, 'utf8')) } catch { /* 镜像失败不阻断 */ }
+            console.log(`🧩 探针 7 验收×测试覆盖矩阵骨架段已补齐（判定=四选一/证据两槽待填，命中≠判定；不触碰既有正文）: ${vpReportPath}${vpPlatformNote}`)
+          }
+        } catch { /* 矩阵补段失败不阻断 --init */ }
         // P0-1（noai-ir-roadmap §3）两件机械预填，均幂等 fail-soft：
         //   ①决策追踪矩阵机械半边——D→FR→task 链自 decisions.md × tasks/*.md frontmatter
         //     结构化字段构建，Evidence/状态两列留 agent 逐格复核；
@@ -1309,10 +1327,14 @@ task 进行中状态标记：开工/完工落 .runtime/task-progress/，list 标
       // 路由形态对齐 verify-probes（:897）/ module-impact（:1041）先例——--change 必填缺参
       // 用法错 exit 2、assertSafeChangeName 消毒、动态 import、--json 结构化输出、运行错
       // fail-soft 出错误摘要 exit 1 不抛栈。
+      // 画像双出口（2026-09-14-quick-exit-tiered-gates task-03，FR-04 / D-008）：quick 会话的
+      // gateProfile 由 computeChangeScopeAudit 结果对象携带——--json 出口经 ...saResult 展开
+      // 自动透出（gateProfile-json）、表格出口经 renderScopeAuditTable 按存在性追加 [gate]
+      // 画像段（gate-table-section），本层零分支零新解析；--file 子命令行为不变。
       const saChangeIdx = args.indexOf('--change');
       const saChange = saChangeIdx >= 0 && args[saChangeIdx + 1] && !String(args[saChangeIdx + 1]).startsWith("--") ? args[saChangeIdx + 1] : null;
       if (!saChange) {
-        console.error('用法: sillyspec scope-audit --change <name> [--file <path>] [--json] [--spec-dir <path>]\n  变更范围对账：计划×实际三态全表 + 行数（quick 会话传 quick-<8hex> 出归属表；已归档变更可查——快照冻结记录态）；--file <path> 看单文件变化内容（对账同源锚点的 git diff）；advisory 只读展示，不构成门禁');
+        console.error('用法: sillyspec scope-audit --change <name> [--file <path>] [--json] [--spec-dir <path>]\n  变更范围对账：计划×实际三态全表 + 行数（quick 会话传 quick-<8hex> 出归属表，附 [gate] 分级门禁画像——表格画像段与 --json gateProfile 字段；已归档变更可查——快照冻结记录态）；--file <path> 看单文件变化内容（对账同源锚点的 git diff）；advisory 只读展示，不构成门禁');
         process.exit(2);
       }
       assertSafeChangeName(saChange, '--change 变更名');
@@ -1340,10 +1362,12 @@ task 进行中状态标记：开工/完工落 .runtime/task-progress/，list 标
       }
       // full-flow 变更目录存在性预检（endpoints baseline 先例同款）：post-apply 形态下实际侧三源
       // 对「变更不存在」不敏感（status 成功即 ok=true，会把主仓脏区误当实际侧），靠预检给明确
-      // 错误摘要 exit 1；quick 会话 id 无 changes/ 目录（guard 祖先链定位），不预检。
+      // 错误摘要 exit 1；quick 会话 id 无 changes/ 目录（guard 祖先链定位），不预检；ql-xxx
+      // 条目号同 quick 会话 id（ql-xxx 反查走 quicklog/patches，亦无 changes/ 目录）不预检。
       // 归档形态兼容（quick-8aa52289）：changes/<名> 不在 → 接受 changes/archive/<名>（scope-audit
       // 内部走快照记录态/HEAD 未提交窗口兜底）。
       if (!/^quick-[0-9a-f]{8}$/.test(saChange)
+        && !/^ql-\d{8}-\d{3}-[0-9a-f]{4}$/.test(saChange)
         && !existsSync(join(saSpecBase, 'changes', saChange))
         && !existsSync(join(saSpecBase, 'changes', 'archive', saChange))) {
         console.error(`❌ 变更目录不存在（活跃与归档区均未找到）: ${join(saSpecBase, 'changes', saChange)}（确认 --change 名，或 --spec-dir 指向主仓 .sillyspec）`);
@@ -2244,6 +2268,8 @@ ${generated.length} 个骨架已就绪——逐节把 <!--TODO--> 替换为语
         // usage 输出且 exit 0——gate 形同虚设（docs-signals 范围内文件+hook 已就位，仅此分支缺）。
         // B9（2026-08-16）：flag 白名单化（对齐 docs check 分支）——未知 --xxx 显式 exit 2
         // （interface-contract §1.3b 宣称），并接线 --paths 透传 runDocsGate.checkOpts（原被忽略）。
+        // 坑 docs-gate-stale-baseline（ql-20260915-004）：超基线分支实测 origin/main 兜底——
+        // 未劣于远端放行 + 提示重锚；--json 输出含 originCount 字段（null=未实测/快路径）。
         const GATE_BARE_FLAGS = ['--init-baseline'];
         const GATE_PAIRED_FLAGS = ['--paths', '--against'];
         const rawGateArgs = filteredArgs.slice(2);
@@ -2546,6 +2572,40 @@ ${generated.length} 个骨架已就绪——逐节把 <!--TODO--> 替换为语
         })
         break
       }
+      // scan refresh 子命令（2026-09-14-scan-incremental-refresh D-002@v1：增量刷新两拍交互）。
+      // ①拍纯读出工单（含 guard 握手写）；②拍 --done 盖章收尾。与 diff 同为旁路：跳过
+      // triggerPullActiveChange、不走 scan 主流程。--project 支持子项目（缺省仓库根 basename，
+      // 与 scan facts 同口径）。
+      if (filteredArgs[1] === 'refresh') {
+        const { runRefresh, finalizeRefresh } = await import('./scan-refresh.js')
+        const refreshEffectiveDir = specDir ? dir : resolveEffectiveDir(dir)
+        const refreshSpecBase = resolvePlatformSpecDir(dir, specDir) || join(refreshEffectiveDir, '.sillyspec')
+        const projIdxR = filteredArgs.indexOf('--project')
+        const refreshProjectName = projIdxR >= 0 && filteredArgs[projIdxR + 1] && !String(filteredArgs[projIdxR + 1]).startsWith("--") ? filteredArgs[projIdxR + 1] : basename(refreshEffectiveDir)
+        if (filteredArgs.includes('--done')) {
+          const docsIdx = filteredArgs.indexOf('--docs')
+          const docsList = docsIdx >= 0 && filteredArgs[docsIdx + 1] && !String(filteredArgs[docsIdx + 1]).startsWith("--")
+            ? filteredArgs[docsIdx + 1].split(',').map(s => s.trim()).filter(Boolean) : null
+          const r = await finalizeRefresh({
+            projectRoot: refreshEffectiveDir,
+            specBase: refreshSpecBase,
+            projectName: refreshProjectName,
+            docs: docsList,
+            force: filteredArgs.includes('--force'),
+            platformOpts: platformWorkspaceId || platformRuntimeRoot ? { workspaceId: platformWorkspaceId, runtimeRoot: platformRuntimeRoot, specRoot: resolvePlatformSpecDir(dir, specDir) } : null,
+          })
+          process.exitCode = r.code
+        } else {
+          process.exitCode = await runRefresh({
+            projectRoot: refreshEffectiveDir,
+            specBase: refreshSpecBase,
+            projectName: refreshProjectName,
+            force: filteredArgs.includes('--force'),
+            json: filteredArgs.includes('--json'),
+          })
+        }
+        break
+      }
     }
     case 'status':
     case 'quick':
@@ -2597,14 +2657,82 @@ ${generated.length} 个骨架已就绪——逐节把 <!--TODO--> 替换为语
       console.log('按 Ctrl+C 停止服务器');
       break;
     }
+    case 'wt-commit': {
+      // 坑 wt-commit-ghost-dispatch：runWtCommit 模块自 bd1cb91 存在但 dispatch 从未接线——
+      // execute Wave prompt 指示的 `sillyspec wt-commit` 一直报「未知命令」（2026-09-14
+      // knowledge-loop-close execute W1 实证，ql-20260914-016-8786 根治）。参数面见模块头：
+      // wt-commit [--change <名>] -m <信息> [--pathspec-from-file <f>] -- <path...>；
+      // worktree 内可省 --change（从 cwd 的 worktrees/<名> 段推断）。
+      const wtCommitRest = filteredArgs.slice(1);
+      const wtCommitDd = wtCommitRest.indexOf('--');
+      const wtCommitFlags = wtCommitDd === -1 ? wtCommitRest : wtCommitRest.slice(0, wtCommitDd);
+      const wtCommitPaths = wtCommitDd === -1 ? [] : wtCommitRest.slice(wtCommitDd + 1);
+      let wtCommitChange = null;
+      let wtCommitMessage = null;
+      let wtCommitPathspecFile = null;
+      for (let i = 0; i < wtCommitFlags.length; i++) {
+        if (wtCommitFlags[i] === '--change' && wtCommitFlags[i + 1]) wtCommitChange = wtCommitFlags[++i];
+        else if ((wtCommitFlags[i] === '-m' || wtCommitFlags[i] === '--message') && wtCommitFlags[i + 1]) wtCommitMessage = wtCommitFlags[++i];
+        else if (wtCommitFlags[i] === '--pathspec-from-file' && wtCommitFlags[i + 1]) wtCommitPathspecFile = wtCommitFlags[++i];
+      }
+      if (!wtCommitChange) {
+        const inferred = String(dir).match(/[\\/]worktrees[\\/]([^\\/]+)/);
+        wtCommitChange = inferred ? inferred[1] : null;
+      }
+      try {
+        const { runWtCommit } = await import('./wt-commit.js');
+        const r = await runWtCommit({
+          changeName: wtCommitChange,
+          message: wtCommitMessage,
+          pathspecs: wtCommitPaths,
+          pathspecFile: wtCommitPathspecFile,
+          cwd: dir,
+        });
+        if (json) console.log(JSON.stringify({ command: 'wt-commit', ...r }, null, 2));
+        else if (r.skipped) console.log(`⏭️  wt-commit 无变更跳过（HEAD 不动）：${r.shortHead}`);
+        else console.log(`✅ wt-commit 完成：${r.shortHead}（${r.files.length} 文件，worktree=${r.worktreePath}）`);
+      } catch (e) {
+        console.error(`❌ wt-commit 失败：${e.message}`);
+        process.exit(1);
+      }
+      break;
+    }
     case 'worktree': {
       const { WorktreeManager } = await import('./worktree.js');
-      const { ProgressManager } = await import('./progress.js');
+      const { ProgressManager, resolveSessionIdentity } = await import('./progress.js');
       const wtSubCmd = filteredArgs[1];
       const wtName = filteredArgs.slice(2).find(a => !a.startsWith('-'));
       const wm = new WorktreeManager({ cwd: dir });
       const pm = new ProgressManager({ specDir: resolvePlatformSpecDir(dir, specDir) });
 
+      // ── 所有权护栏公共件（2026-09-14-change-ownership-guards task-02 / FR-01 / D-001@v1）──
+      // 接管类操作（apply / cleanup / assess 自动 apply）改主仓前校验 change 归属：
+      // 他人且活跃（活跃窗内，heartbeat_minutes 缺省 15min）→ 拒绝；无主 / 窗口外 / 本会话
+      // 自有 / --takeover → 放行，接管分支重写 owner=本会话（setChangeOwner 含 last_active
+      // 心跳起算）。调用点必须在 withMainRepoLock 锁内（判定与执行无 TOCTOU）；只读路径
+      // （diff/list/meta/doctor/--check-only）不接。会话标识三级解析：--session flag >
+      // env SILLYSPEC_SESSION_ID > anon@host 机器级降级（同机并行不设防是 R-01 明示局限）。
+      const sessionFlagIdx = args.indexOf('--session');
+      const sessionFlagValue = (sessionFlagIdx !== -1 && args[sessionFlagIdx + 1]
+        && !String(args[sessionFlagIdx + 1]).startsWith('--')) ? String(args[sessionFlagIdx + 1]).trim() : null;
+      // soft=true：assess 自动路径拒绝语义（跳过自动落盘 + warning 不抛错，同 overlapSkipped 软跳）；
+      // soft=false：显式 apply/cleanup 拒绝（结构化错误，调用方 exit 非零）。
+      function _guardChangeOwnership(changeName, { forced = false, soft = false } = {}) {
+        const { session } = resolveSessionIdentity({ flagSession: sessionFlagValue, cwd: dir });
+        const check = pm.assertChangeOwnership(dir, changeName, { selfSession: session, nowMs: Date.now(), forced });
+        if (check.allowed) {
+          if (check.action !== 'self') pm.setChangeOwner(dir, changeName, session);
+          return { allowed: true, action: check.action };
+        }
+        const lines = [
+          `变更 ${changeName} 正被其他会话持有（owner: ${check.owner}，最后活跃: ${check.lastActive || '未知'}），活跃窗口 ${Math.round(check.heartbeatMs / 60000)} 分钟内拒绝接管类操作`,
+          `确认对方已放弃且本会话应接管：加 --takeover 显式强制接管（重写 owner 并留痕）；或等对方会话收尾后重试`,
+        ];
+        if (soft) { for (const l of lines) console.warn(`⚠️  ${l}`); }
+        else { for (const l of lines) console.error(`🚫 ${l}`); }
+        return { allowed: false, action: check.action };
+      }
+
       // isolation 写入 DB 的辅助函数
       function _writeIsolationToDB(cwd, changeName, info) {
         if (info.blocked) {
@@ -2629,17 +2757,19 @@ SillySpec worktree — git worktree 隔离管理
 
 用法:
   sillyspec worktree create <change-name> [--base <branch>] [--adopt-branch]   创建隔离 worktree（--adopt-branch：收编既有同名分支为工作分支，分支现状作 baseline）
-  sillyspec worktree apply <change-name> [--check-only] [--base merge-base|baseline] [--merge] [--skip-overlap] [--stash-dirty]   校验并应用变更到主工作区（--stash-dirty：主仓在途改动自动 stash→apply→恢复，SHA 兜底可审计）
-  sillyspec worktree assess <change-name>                     风险审计 + 自动 apply
+  sillyspec worktree apply <change-name> [--check-only] [--base merge-base|baseline] [--merge] [--skip-overlap] [--stash-dirty] [--force] [--takeover]   校验并应用变更到主工作区（--stash-dirty：主仓在途改动自动 stash→apply→恢复，SHA 兜底可审计；--force：越过活跃 quick 会话 guard 相交预检，overlapForced 留痕；--takeover：越过所有权护栏显式强制接管，owner 重写留痕）
+  sillyspec worktree assess <change-name>                     风险审计 + 自动 apply（自动路径受所有权护栏约束：他人活跃 change 跳过自动落盘并 warning）
   sillyspec worktree diff <change-name> [--base <commit>]      查看 worktree 相对 base 的变更
   sillyspec worktree list                                      列出所有活跃 worktree
   sillyspec worktree meta <change-name>                        读取 worktree meta.json
-  sillyspec worktree cleanup <change-name> [--force]           强制清理 worktree
+  sillyspec worktree cleanup <change-name> [--force] [--takeover]   强制清理 worktree（受所有权护栏约束：他人活跃 change 拒绝，--takeover 显式接管）
   sillyspec worktree doctor [--fix] [--stale-hours N] [--change <name>]   健康检查 + 修复（--change 仅扫指定 change）
 
 选项:
   --base <branch>       create: 指定基础分支（默认当前 HEAD）
   --check-only          apply: 只输出检查结果，不实际 apply
+  --takeover            apply/cleanup: 所有权护栏拒绝时的显式强制接管口（owner 他人且活跃时解锁，重写 owner 留痕）
+  --session <id>        显式会话标识（所有权三级解析最高优先级；缺省 env SILLYSPEC_SESSION_ID，再缺省 anon@<host> 机器级降级——同机并行不设防）
 `);
         break;
       }
@@ -2677,13 +2807,15 @@ SillySpec worktree — git worktree 隔离管理
         }
         case 'apply': {
           if (!wtName) {
-            console.error('❌ 用法: sillyspec worktree apply <change-name> [--check-only] [--base merge-base|baseline] [--merge] [--skip-overlap] [--stash-dirty]');
+            console.error('❌ 用法: sillyspec worktree apply <change-name> [--check-only] [--base merge-base|baseline] [--merge] [--skip-overlap] [--stash-dirty] [--force] [--takeover]');
             process.exit(1);
           }
           const checkOnly = args.includes('--check-only');
           const merge = args.includes('--merge');
           const skipOverlap = args.includes('--skip-overlap');
           const stashDirty = args.includes('--stash-dirty');
+          const force = args.includes('--force'); // guard 相交预检显式解锁（task-02 / FR-03；人工 flag，自动路径永不带）
+          const takeover = args.includes('--takeover'); // 所有权护栏显式强制接管（2026-09-14-change-ownership-guards task-02 / FR-01；人工 flag，自动路径永不带）
 
           // 解析 --base 参数（默认 merge-base）
           let base = 'merge-base';
@@ -2711,15 +2843,22 @@ SillySpec worktree — git worktree 隔离管理
           }
           // 主仓 apply 互斥锁（坑 main-apply-no-mutex）：真 apply（非 checkOnly）在锁内跑——
           // apply 链（rollback/merge/cleanup）直接改主仓工作区，两会话并发互踩会互相清文件。
+          // 所有权护栏（2026-09-14-change-ownership-guards task-02 / FR-01）：锁内、实际 apply 前
+          // 判归属——他人且活跃（活跃窗内）拒绝；--check-only 是只读路径不校验（铁律：只读命令不接）。
+          // 拒绝时结构化错误已在护栏内打印，经哨兵返回值带出锁外统一 exit 1（不进结果展示分支）。
           let result;
           try {
             result = checkOnly
-              ? applyWorktree(wtName, { cwd: dir, checkOnly, merge, base, ctx: _applyCtx, skipOverlap, stashDirty })
-              : await withMainRepoLock(dir, wtName, 'apply', () => applyWorktree(wtName, { cwd: dir, checkOnly, merge, base, ctx: _applyCtx, skipOverlap, stashDirty }));
+              ? applyWorktree(wtName, { cwd: dir, checkOnly, merge, base, ctx: _applyCtx, skipOverlap, stashDirty, force })
+              : await withMainRepoLock(dir, wtName, 'apply', () => {
+                if (!_guardChangeOwnership(wtName, { forced: takeover }).allowed) return { __ownershipDenied: true };
+                return applyWorktree(wtName, { cwd: dir, checkOnly, merge, base, ctx: _applyCtx, skipOverlap, stashDirty, force });
+              });
           } catch (lockErr) {
             console.error(`❌ ${lockErr.message}`);
             process.exit(1);
           }
+          if (result && result.__ownershipDenied) process.exit(1);
 
           if (result.errors.length > 0) {
             console.error(`❌ 校验失败:`);
@@ -2855,15 +2994,29 @@ SillySpec worktree — git worktree 隔离管理
           if (assessment.decision === 'SAFE' || assessment.decision === 'WARNING') {
             console.log('Action: auto-applying...');
             const { applyWorktree, withMainRepoLock } = await import('./worktree-apply.js');
-            // 主仓互斥锁（与手动 apply 同款）：自动 apply 同样改主仓工作区，必须互斥
+            // 主仓互斥锁（与手动 apply 同款）：自动 apply 同样改主仓工作区，必须互斥。
+            // 所有权护栏（2026-09-14-change-ownership-guards task-02 / FR-01）：assess 自动 apply
+            // 是护栏①最可能的旁路（SAFE/WARNING 即自动改主仓+链内 cleanup）——锁内、实际动作前
+            // 判归属。自动路径永不带 --takeover；他人活跃 change 拒绝 = 跳过自动落盘 + warning
+            // 不抛错（同 overlapSkipped 软跳语义：无人值守不越权也不阻断审计流）。
             let applyResult;
             try {
-              applyResult = await withMainRepoLock(dir, wtName, 'assess-auto-apply', () => applyWorktree(wtName, { cwd: dir, ctx: _assessCtx }));
+              applyResult = await withMainRepoLock(dir, wtName, 'assess-auto-apply', () => {
+                if (!_guardChangeOwnership(wtName, { soft: true }).allowed) return { ownershipSkipped: true };
+                return applyWorktree(wtName, { cwd: dir, ctx: _assessCtx, autoApply: true });
+              });
             } catch (lockErr) {
               console.error(`❌ 自动 apply 未执行：${lockErr.message}`);
               break;
             }
-            if (applyResult.errors.length > 0) {
+            if (applyResult.ownershipSkipped) {
+              // 所有权拒绝（结构化 warning 已在护栏内打印）：跳过自动落盘，指引人工显式接管
+              console.log('   → 确认对方会话已放弃：人工评估后显式接管 sillyspec worktree apply ' + wtName + ' --takeover（或等对方收尾后重跑 assess）');
+            } else if (applyResult.overlapSkipped) {
+              // guard 相交软跳过（task-02 / FR-03）：无人值守不越权也不阻断审计流——不落盘，亮 warning 指引人工评估
+              for (const w of applyResult.warnings || []) console.log(`⚠️  ${w}`);
+              console.log('   → 人工评估后显式 apply: sillyspec worktree apply ' + wtName + '（确认与活跃 quick 会话无冲突；或等对方 --done 后重跑 assess）');
+            } else if (applyResult.errors.length > 0) {
               console.error('❌ apply 失败:', applyResult.errors.join('; '));
             } else {
               console.log(`✅ 已自动应用 ${applyResult.changedFiles.length} 个文件变更：`);
@@ -2956,15 +3109,23 @@ SillySpec worktree — git worktree 隔离管理
         }
         case 'cleanup': {
           if (!wtName) {
-            console.error('❌ 用法: sillyspec worktree cleanup <change-name>');
+            console.error('❌ 用法: sillyspec worktree cleanup <change-name> [--force] [--takeover]');
             process.exit(1);
           }
           const forceFlag = args.includes('--force');
+          const takeover = args.includes('--takeover'); // 所有权护栏显式强制接管（task-02 / FR-01）
           try {
             // 主仓互斥锁（坑 main-repo-no-mutex 二批）：cleanup 删 worktree 注册表/分支/目录，
-            // 与并行会话的 apply/cleanup 互踩会互相清——与其他写主仓操作共用一把 main-repo.lock
+            // 与并行会话的 apply/cleanup 互踩会互相清——与其他写主仓操作共用一把 main-repo.lock。
+            // 所有权护栏（2026-09-14-change-ownership-guards task-02 / FR-01）：锁内、实际清理前
+            // 判归属——他人且活跃拒绝（结构化错误在护栏内打印，哨兵带出统一 exit 1，跨仓清理
+            // 同步跳过）；--takeover 显式强制接管放行。
             const { withMainRepoLock } = await import('./worktree-apply.js');
-            const result = await withMainRepoLock(dir, wtName, 'worktree-cleanup', () => wm.cleanup(wtName, { force: forceFlag }));
+            const result = await withMainRepoLock(dir, wtName, 'worktree-cleanup', () => {
+              if (!_guardChangeOwnership(wtName, { forced: takeover }).allowed) return { __ownershipDenied: true };
+              return wm.cleanup(wtName, { force: forceFlag });
+            });
+            if (result && result.__ownershipDenied) process.exit(1);
             // 跨仓 worktree（坑 cross-repo-no-worktree-isolation）：与主仓同锁清理——跨仓 worktree
             // 注册在各跨仓仓 .git 内，但目录/meta 在主仓 .sillyspec 运行时区，同样怕并发互踩
             const { cleanupCrossWorktrees } = await import('./worktree-cross.js');
@@ -2986,7 +3147,16 @@ SillySpec worktree — git worktree 隔离管理
               }
             } else if (result.result === 'skipped') {
               console.log(`⏭️  worktree 跳过清理: ${wtName} (mode: ${result.mode})`);
-              console.log(`   原因: in-place 模式没有隔离目录需要清理`);
+              // ql-20260915-003 修复②（坑 cleanup-meta-fallback，2026-09-15 实证「mode: null
+              // 跳过清理」但 worktree 实际创建过）：早退跳过（meta/目录/git 注册三路探针全未
+              // 命中）时，误导性的「in-place 模式」文案升级为诊断式——列三路探针路径 + meta
+              // 丢失可能原因 + doctor 指引。probePaths 由 cleanup 兜底探测带回。
+              if (Array.isArray(result.probePaths) && result.probePaths.length > 0) {
+                for (const p of result.probePaths) console.log(`   探针: ${p}`);
+                console.log(`   meta 丢失可能原因：apply/cleanup 后随目录删除、并行会话已清理、cwd/specDir 漂移。可用 sillyspec worktree doctor 检查 git 注册与分支残留。`);
+              } else {
+                console.log(`   原因: in-place 模式没有隔离目录需要清理`);
+              }
             } else if (result.result === 'blocked') {
               console.error(`🚫 拒绝清理：有未落主仓交付变更，请先 sillyspec worktree apply ${wtName} 或 --force`);
             } else if (result.result === 'partial') {
@@ -3250,7 +3420,8 @@ SillySpec platform — SillyHub 平台同步
         case 'sync': {
           const syncChangeIdx = args.indexOf('--change');
           const syncChangeName = syncChangeIdx >= 0 && args[syncChangeIdx + 1] && !String(args[syncChangeIdx + 1]).startsWith("--") ? args[syncChangeIdx + 1] : null;
-          await syncModule.sync(syncChangeName, dir);
+          // manual：用户显式同步，change_deleted 回执噪音闸旁路（显式动作的回执必须可见）
+          await syncModule.sync(syncChangeName, dir, { manual: true });
           break;
         }
         case 'sync-docs': {
@@ -3918,7 +4089,14 @@ SillySpec modules — 模块文档管理
           process.exit(1);
         }
         const { resolveLocalYamlWriteTarget } = await import('./config-cat.js');
-        const target = resolveLocalYamlWriteTarget(dir, { specBase: rrSpecBase });
+        // 坑 register-repo-specbase-split-brain（2026-09-15 wp 平台模式会话实证）：specBase
+        // 优先的写候选链在平台模式下命中平台 spec 根 local.yaml，而 repos: 段的全部读侧
+        // （execute MultiRepoContext / worktree-cross / run shared）恒读 <cwd>/.sillyspec/local.yaml
+        // ——注册写进 spec 根 = 死配置，execute 启动 fail-closed 报未注册，agent 只能试出
+        // --spec-dir 指向项目 .sillyspec 才能绕过。修复：默认（无显式 --spec-dir）写目标走
+        // 读侧对齐链（不喂 specBase，cwd 祖先链命中项目 local.yaml，worktree 自动反推主仓）；
+        // 显式 --spec-dir 是用户明示选择，仍尊重。
+        const target = resolveLocalYamlWriteTarget(dir, specDir ? { specBase: rrSpecBase } : {});
         const { registerRepoInLocalYaml } = await import('./local-register.js');
         let rrResult;
         try {
@@ -3930,6 +4108,16 @@ SillySpec modules — 模块文档管理
         const verb = rrResult.replaced ? '已更新（覆盖旧路径）' : '已注册';
         console.log(`✅ repos.${rrKey} ${verb}: ${absRepo.replace(/\\/g, '/')}`);
         console.log(`   写入: ${target.path}${rrResult.fileCreated ? '（新建文件）' : ''}${rrResult.sectionCreated ? '（新建 repos: 段）' : ''}`);
+        // 同坑提醒：平台 spec 根也躺着一份 local.yaml 时，其 repos: 段不生效（读侧只读项目侧）
+        // ——不Dual写（两份各自演化=再分裂），只提示用户那份是死配置可清理
+        if (!specDir && rrSpecBase) {
+          const altYaml = join(rrSpecBase, 'local.yaml');
+          try {
+            if (existsSync(altYaml) && resolve(altYaml) !== resolve(target.path)) {
+              console.warn(`⚠️  平台 spec 根另有一份 local.yaml（${altYaml}）——repos: 注册只在项目 local.yaml 生效（execute 等读侧只读项目侧），spec 根那份的 repos: 段是死配置`);
+            }
+          } catch { /* 提醒失败不影响注册结果 */ }
+        }
         console.log('   查看: sillyspec config cat（真实配置）; main 隐式=主仓不用注册');
         break;
       }