sillyspec 3.29.5 → 3.30.0

package/src/index.js

@@ -9,7 +9,7 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, writeFileSync, unlinkSync } from 'fs';
 import { writeAtomicSync } from './fs-atomic.js';
 import { basename, dirname, extname, join, resolve, isAbsolute, sep, relative } from 'path';
-import { safeGit, git } from './git-helper.js';
+import { safeGit, git, gitQuiet } from './git-helper.js';
 import { getVersion } from './version.js';
 
 // E22（性能#2）：progress.js（拖 db.js→node:sqlite 链 ~48ms）与 run/shared.js（拖 stages 全家
@@ -53,11 +53,7 @@ SillySpec CLI — 规范驱动开发工具包
     --json                             输出 JSON（程序化读取）
 
   阶段特有参数:
-    quick:   --linked-changes none|a,b   显式关联变更（取代 --change，推荐）
-             --files a.js,b.js           显式声明允许修改的文件
-             --allow-new                 允许新增文件（默认禁止）
-             --force-baseline            允许覆盖 baseline 受保护文件
-             --confirm                   完成时确认接受变更审计
+    quick:   （通道已退役 v3.30.0——仅收尾升级前在途会话：--done/--cancel/--change <会话ID>；新工作走 flow start）
     scan:    --quick | --standard | --deep   显式选择 profile（优先于规模自动判定；三档互斥）
              --force-rescan              覆盖已有 scan 文档保护
              --diff [--base <commit>] [--full] [--report]   scan 文档 vs 源码漂移清单（纯只读）
@@ -95,6 +91,10 @@ SillySpec CLI — 规范驱动开发工具包
   sillyspec config [schema] [--json]      打印 local.yaml 全部已知键 + 生效状态 + 读取点（堵外部 agent 配置发现缺口）
   sillyspec config cat [--json]           读取 local.yaml 实际内容（自动定位真实路径，worktree 内解析到主仓）
   sillyspec runtime list [--json]         枚举 .sillyspec/.runtime/ 运行时产物（只读，看手上有哪些证据/状态文件）
+  sillyspec watcher alerts --change <名> [--all] [--follow] [--runtime-root <路径>]
+                                      哨兵告警查询（watcher 事件流只读可视化；--all 全事件、--follow 2s 轮询持续打印）
+  sillyspec watcher timeline --change <名> [--runtime-root <路径>]
+                                      变更合成时间线（事件流 × tasks.md × git 提交锚三源真实留痕渲染；活跃/归档变更均可）
   sillyspec dispatch <probe | hint>       SillyHub 派发能力探测 + 策略生成（agent 调用桥，仅渲染不执行 tool）
   sillyspec agent-log [--detect] [--json]  本地 agent 会话日志查询/现场探测（run 命令自动上报平台 POST /api/agent-logs 并本地留底）
 
@@ -145,7 +145,8 @@ SillySpec CLI — 规范驱动开发工具包
   sillyspec knowledge <search --query "..." --limit N
                         | inspect --id "..."
                         | validate | refresh
-                        | propose --title "..." --category <name>>
+                        | propose --title "..." --category <name>
+                        | inbox [--json]  （知识收件箱：uncategorized 待审清单+基线态）>
   sillyspec platform <connect <url> [--token <t>]
                       | disconnect
                       | sync [--change <name>] | sync-docs [--change <name>]
@@ -167,11 +168,10 @@ SillySpec CLI — 规范驱动开发工具包
 示例:
   sillyspec init
   sillyspec run brainstorm --change 2026-07-03-add-login
-  sillyspec run quick --linked-changes none --done --output "修复手机号校验"
+  sillyspec flow start --change my-fix --input "<动机与背景＋独立一行『成功标准：』＋每行一条『- 可验证标准』>"   # 轻量变更（默认快道，2 次调用）
   sillyspec run verify --done --output "验证通过，测试全绿"
   sillyspec run archive --done --confirm --output "归档完成"
   sillyspec run plan --reopen --from-step 2          # 修订 plan，从第 2 步重做
-  sillyspec run quick --non-interactive --done --output "CI 内的快修"  # 脚本/CI
   sillyspec progress show
   sillyspec progress show --all         # 多变更汇总时无信号变更全量单行列出（默认折叠超 8 个）
   sillyspec progress show --json        # 全局总览 envelope（面板/脚本消费）
@@ -196,6 +196,36 @@ async function withJsonOutput(json, fn) {
   }
 }
 
+// quick 通道直接退役（2026-09-25-quick-channel-retire）：CLI 入口预门——拦「新会话启动形态」的
+// quick 调用。必须在 process entry 层拒绝：run/command.js 对新会话的 id 生成 / owner.json 落盘 /
+// 「📌 已建立」公告都发生在 runStage 之前，晚于此处拒绝会留幻影会话残留（违背零副作用承诺）。
+// 放行面（在途收尾与校验路径，全部先于 command.js 会话建立、零副作用）：
+//   ① --done/--cancel/--status/--skip/--reset/--reopen/--help——收尾/只读/帮助
+//   ② --change quick-<8hex>——在途续跑（指向不存在会话的由 stage.js 第二道网拒绝）
+//   ③ 含「新启合法集」之外旗标的形态——未知旗标由 command.js 未知参数校验 exit 2（该校验
+//      2026-09-19 已上移至会话建立之前），放行不产生副作用；漏放行的合法收尾形态同理被
+//      stage.js 兜底网拒绝。进程内直调 runCommand 的入口不经此门，亦由 stage.js 兜底。
+const QUICK_FRESH_START_FLAGS = new Set([
+  '--input', '--linked-changes', '--files', '--file-notes',
+  '--allow-new', '--allow-delete', '--force-baseline',
+  '--non-interactive', '--interactive', '--session',
+  '--json', '--dir', '--spec-dir', '--spec-root', '--runtime-root', '--workspace-id',
+  '--skip-approval', '--no-docs', '--confirm-mode',
+])
+function refuseRetiredQuickFreshStart(stageArgs) {
+  const flags = stageArgs.slice(1).filter((a) => String(a).startsWith('-'))
+  const passThrough = flags.some((f) => !QUICK_FRESH_START_FLAGS.has(f))
+    || (() => {
+      const i = stageArgs.indexOf('--change')
+      return i !== -1 && /^quick-[0-9a-f]{8}$/.test(String(stageArgs[i + 1] || ''))
+    })()
+  if (passThrough) return false
+  console.error('❌ quick 通道已退役，不再接受新会话（v3.30.0 起）。')
+  console.error('   新工作请走轻量变更：sillyspec flow start --change <名> --input "<动机与背景；随后独立一行『成功标准：』；再每行一条『- <可验证标准>』>"')
+  console.error('   升级前进行中的 quick 会话仍可收尾：sillyspec run quick --change <会话ID> 续跑 / --done 收口 / --cancel 取消。')
+  process.exit(1)
+}
+
 async function main() {
   const args = process.argv.slice(2);
 
@@ -390,6 +420,22 @@ async function main() {
             break;
           }
           pm.show(progDir, progChangeName, { all: filteredArgs.includes('--all') });
+          // 预览出口（2026-09-23-watcher-preview-progress task-03 / FR-04）：--preview 在默认
+          // 输出后追加 watcher 预览段（带「预览」徽标与证据引用）；缺省零行为变化（保险丝外显式通道）。
+          if (filteredArgs.includes('--preview') && progChangeName) {
+            const { readPreviewProgress } = await import('./progress.js');
+            const pv = readPreviewProgress(resolvePlatformSpecDir(dir, specDir) || join(progDir, '.sillyspec'), progChangeName);
+            console.log('');
+            if (!pv.exists || pv.stages.length === 0) {
+              console.log('👀 预览：无 watcher 预览行（变更未注册/库缺失/尚无投影）');
+            } else {
+              console.log(`👀 预览（watcher 推断，authority='watcher'——非流程真相，CLI --done 才是）：${pv.stages.length} 行`);
+              for (const r of pv.stages) {
+                const files = r.evidence && Array.isArray(r.evidence.files) ? r.evidence.files.join('/') : '';
+                console.log(`   [预览] ${r.stage} → ${r.status}${files ? `（依据：${files}${r.evidence && r.evidence.changed ? ' 本拍有变化' : ''}）` : ''}`);
+              }
+            }
+          }
           break;
         }
         case 'check': {
@@ -524,6 +570,9 @@ async function main() {
       // 只传 cwd 致 --spec-dir 对 gate verify 无效。不传 --spec-dir 时 specBase 走默认
       // resolveSpecDir(cwd)，向后兼容。
       const gateOpts = { cwd: dir };
+      // P1 --full 只读预检档（batch3 task-03）：覆盖 --done 独有检查面（reconcile/stage review）——
+      // 预检过=必过（同因），省一轮 gate 失败重跑的整 agent 回合
+      if (args.includes('--full')) gateOpts.full = true;
       // A4：平台指针 / 显式 --spec-dir / 本地 fallback 三合一解析 specBase——平台模式（指针指向外部
       // specDir）下 gate 也能核验（原只传 cwd 致 runGate 的 resolveSpecDir 指向本地孤儿库，恒
       // 「无法核验」exit 2）。resolvePlatformSpecDir 指针失效时抛 PointerUnreachableError，由顶层 catch 优雅 fail-closed。
@@ -781,9 +830,12 @@ async function main() {
       if (!taskSub || ['help', '--help', '-h'].includes(taskSub)) {
         console.log(`用法:
   sillyspec task start --change <名> --task task-NN [--note "一句话在做什么"]
+  sillyspec task done --change <名> --task task-NN --verdict <pass|fail|cannot_verify> [--notes "评审备注"]
+                     [--evidence "..."] [--commit -m "提交信息"] [-- <精确路径...>] [--force]
   sillyspec task finish --change <名> --task task-NN
   sillyspec task list --change <名>
-task 进行中状态标记：开工/完工落 .runtime/task-progress/，list 标红 >2h 中断遗留（接管审查点名用）`);
+task done 四合一（r5l 方案1）：review write（落 review.json+自动勾选）→ finish（清标记）→ 可选 wt-commit，
+子步幂等可断点重入；task 进行中状态标记：开工/完工落 .runtime/task-progress/，list 标红 >2h 中断遗留`);
         break;
       }
       const tChangeIdx = filteredArgs.indexOf('--change');
@@ -805,6 +857,76 @@ task 进行中状态标记：开工/完工落 .runtime/task-progress/，list 标
           task: tTask, change: tChange, note: tNote || '', startedAt: new Date().toISOString(),
         }, null, 2) + '\n');
         console.log(`📌 ${tTask} 已标记进行中${tNote ? '（' + tNote + '）' : ''}——完工时 sillyspec task finish --change ${tChange} --task ${tTask}`);
+        // ── 受影响测试族前移注入（2026-09-21 R5 接线 ql-20260921-007，②）──
+        // deps(auto) 同源计算（verify-postcheck discoverModuleDependentTests）从 quick 收尾门
+        // 前移到任务开工：30 秒定向定位替代 100 秒全量轰炸+混合归因（W1 实证全量当首验多跑
+        // 2 轮+triage 三轮）。按 task 卡 allowed_paths 声明面计算；best-effort：卡片缺失/
+        // 解析失败/零命中零输出零阻断。
+        try {
+          const tCardPath = join(tSpecBase, 'changes', tChange, 'tasks', `${tTask}.md`);
+          if (existsSync(tCardPath)) {
+            const { parseAllowedPaths } = await import('./stages/plan-postcheck.js');
+            const { discoverModuleDependentTests } = await import('./verify-postcheck.js');
+            const tAllowed = parseAllowedPaths(readFileSync(tCardPath, 'utf8'));
+            if (tAllowed.length > 0) {
+              const tDeps = discoverModuleDependentTests({ cwd: dir, changedFiles: tAllowed, coveredCommands: [] });
+              if (tDeps.length > 0) {
+                console.log(`🎯 受影响测试族（deps(auto) 同源 ${tDeps.length} 个）——写完先跑定向再全量（30s 定位 < 100s 全量+归因）：`);
+                console.log(`   node --test ${tDeps.slice(0, 10).join(' ')}${tDeps.length > 10 ? `  …等共 ${tDeps.length} 个` : ''}`);
+              }
+            }
+          }
+        } catch { /* 注入 best-effort */ }
+      } else if (taskSub === 'done') {
+        // ── task done 四合一（r5l-forensic-verdict 方案 1 / 评审护栏#3）：13 任务 × 4 连收尾
+        // 往返（review write+勾选 / finish / wt-commit）合并为单进程串行 + 合并输出——每次省
+        // 一次 ~300K 全量上下文重发。原子性：子步幂等跳过 / 中断精确报告已完成子步 / 重入断点
+        // 续；ownership 与拒覆盖语义继承 writeTaskReview / runWtCommit 既有判定（编排零旁路）。──
+        const tdVal = (flag) => {
+          const i = filteredArgs.indexOf(flag);
+          return i >= 0 && filteredArgs[i + 1] && !String(filteredArgs[i + 1]).startsWith("--") ? filteredArgs[i + 1] : null;
+        };
+        const tdVerdict = tdVal('--verdict');
+        const tdNotes = tdVal('--notes');
+        const tdEvidence = tdVal('--evidence');
+        const tdCommit = filteredArgs.includes('--commit');
+        const tdMessage = tdVal('-m') || tdVal('--message');
+        const tdBase = tdVal('--base');
+        const tdHead = tdVal('--head');
+        const tdCfIdx = filteredArgs.indexOf('--changed-files');
+        // 存在即显式覆盖（含空串=纯验证任务零 diff 声明）——与 review write 同语义
+        const tdFilesOverride = tdCfIdx >= 0
+          ? (filteredArgs[tdCfIdx + 1] || '').split(',').map((x) => x.trim()).filter(Boolean)
+          : null;
+        const tdPsIdx = filteredArgs.indexOf('--pathspec-from-file');
+        const tdPsFile = tdPsIdx >= 0 && filteredArgs[tdPsIdx + 1] ? filteredArgs[tdPsIdx + 1] : null;
+        const tdDd = filteredArgs.indexOf('--');
+        const tdPaths = tdDd === -1 ? [] : filteredArgs.slice(tdDd + 1);
+        if (!tdVerdict || (tdCommit && !tdMessage)) {
+          console.error('用法: sillyspec task done --change <名> --task task-NN --verdict <pass|fail|cannot_verify> [--notes "评审备注"] [--evidence "cannot_verify 证据"]\n  [--commit -m "提交信息"] [--pathspec-from-file <f>] [-- <精确路径...>] [--force]\n  四合一收尾：review write（落 review.json+自动勾选）→ task finish（清进行中标记）→ 可选 wt-commit；\n  子步幂等可断点重入；verdict 改判已存在 review 需 --force（与 review write 拒覆盖同款）');
+          process.exit(2);
+        }
+        if (tdCommit && tdPaths.length === 0 && !tdPsFile) {
+          console.error('❌ --commit 需要提交路径：`--` 后逐个给出本 task 的精确路径（或 --pathspec-from-file <f>）——wt-commit 刻意不支持空 pathspec（同 Wave 兄弟 WIP 防卷入）');
+          process.exit(2);
+        }
+        const tdPlatformOpts = {};
+        const tdResolved = resolvePlatformOpts(dir, specDir);
+        if (tdResolved) {
+          tdPlatformOpts.specRoot = tdResolved.specRoot;
+          if (tdResolved.runtimeRoot) tdPlatformOpts.runtimeRoot = tdResolved.runtimeRoot;
+        }
+        const { runTaskDone } = await import('./task-done.js');
+        const tdResult = await runTaskDone({
+          changeName: tChange, cwd: dir, taskId: tTask, verdict: tdVerdict,
+          notes: tdNotes || '', evidence: tdEvidence,
+          commitMessage: tdCommit ? tdMessage : null,
+          pathspecs: tdPaths, pathspecFile: tdPsFile,
+          markerDir: tDir, platformOpts: tdPlatformOpts,
+          baseOverride: tdBase, headOverride: tdHead, changedFilesOverride: tdFilesOverride,
+          force: filteredArgs.includes('--force'),
+        });
+        if (!tdResult.ok) process.exit(1);
       } else if (taskSub === 'finish') {
         try { unlinkSync(join(tDir, `${tTask}.json`)); console.log(`✅ ${tTask} 进行中标记已清除（完工）`); }
         catch { console.log(`ℹ️ ${tTask} 无进行中标记（已完工或从未 start）`); }
@@ -825,7 +947,7 @@ task 进行中状态标记：开工/完工落 .runtime/task-progress/，list 标
         }
         if (stale > 0) console.log(`   共 ${stale} 个疑似中断遗留——主代理接管时逐一审查（半成品无主的痛点出口）`);
       } else {
-        console.error(`❌ 未知子命令「${taskSub}」（start | finish | list）`); process.exit(2);
+        console.error(`❌ 未知子命令「${taskSub}」（start | done | finish | list）`); process.exit(2);
       }
       break;
     }
@@ -1024,7 +1146,7 @@ task 进行中状态标记：开工/完工落 .runtime/task-progress/，list 标
         const { spawnSync } = await import('node:child_process');
         const { fileURLToPath } = await import('node:url');
         // ESM 无 __dirname（ql-20260911-029：此处曾直接引用，--apply 常态路径必 ReferenceError）
-        const r = spawnSync(process.execPath, [fileURLToPath(new URL('../bin/sillyspec.js', import.meta.url)), '--dir', dir, ...childArgs], { stdio: 'inherit' });
+        const r = spawnSync(process.execPath, [fileURLToPath(new URL('../bin/sillyspec.js', import.meta.url)), '--dir', dir, ...childArgs], { stdio: 'inherit', windowsHide: true });
         process.exit(r.status === null ? 1 : r.status);
       }
       if (json) {
@@ -1138,8 +1260,14 @@ task 进行中状态标记：开工/完工落 .runtime/task-progress/，list 标
       const vpChange = vpChangeIdx >= 0 && args[vpChangeIdx + 1] && !String(args[vpChangeIdx + 1]).startsWith("--") ? args[vpChangeIdx + 1] : null;
       const vpInit = args.includes('--init');
       const vpForce = args.includes('--force');
+      const vpDraft = args.includes('--draft');
+      const vpAmendDraft = args.includes('--amend-draft');
+      if (vpDraft && !vpInit) {
+        console.error('❌ --draft 需与 --init 同用（draft 是骨架生成的机器起草模式）——sillyspec verify-probes --change <名> --init --draft');
+        process.exit(2);
+      }
       if (!vpChange) {
-        console.error('用法: sillyspec verify-probes --change <name> [--init [--force]] [--json] [--spec-dir <path>]\n  跑机械探针（TODO 标记/测试覆盖/API 对账/删除对账）输出 markdown；--init 生成 verify-result.md 骨架（探针预填，已存在不覆盖；--force 覆盖重生成全骨架——手填内容会重置，先备份）');
+        console.error('用法: sillyspec verify-probes --change <name> [--init [--force]] [--draft] [--amend-draft] [--json] [--spec-dir <path>]\n  跑机械探针（TODO 标记/测试覆盖/API 契约/删除对账）输出 markdown；--init 生成 verify-result.md 骨架（探针预填，已存在不覆盖；--force 覆盖重生成全骨架——手填内容会重置，先备份）；\n  --init --draft 填槽模式（r5l 方案3）：任务完成度/风险等级/测试结果/决策追踪四节机器预填完整句子+指纹防篡改，agent 只填三处 <!--AGENT:--> 槽（结论枚举/移交项/审查叙述）；\n  --amend-draft 留痕重锚：确要修改机器预填段时重算指纹并记 sidecar 审计（--done 篡改门禁的显式例外通道）');
         process.exit(2);
       }
       assertSafeChangeName(vpChange, '--change 变更名');
@@ -1166,6 +1294,24 @@ task 进行中状态标记：开工/完工落 .runtime/task-progress/，list 标
         } catch { return null }
       }
       const vpResult = runVerifyProbes({ cwd: dir, changeName: vpChange, specDir: vpSpecBase });
+      // ── --amend-draft（r5l 方案3/护栏#2：机器段修改的唯一留痕通道）── 对 md 中现存
+      // MACHINE-DRAFT 标记段按当前内容重锚哈希 + sidecar amendment 审计，不跑探针不写骨架。
+      if (vpAmendDraft) {
+        const { resolveRuntimeRoot } = await import('./run/shared.js');
+        const { amendDraftMarkers } = await import('./verify-draft.js');
+        const vpAmRoot = resolveRuntimeRoot({}, vpSpecBase);
+        const vpAmKeys = amendDraftMarkers({
+          mdPath: join(vpSpecBase, 'changes', vpChange, 'verify-result.md'),
+          changeName: vpChange, runtimeRoot: vpAmRoot,
+        });
+        if (vpAmKeys.length > 0) {
+          try { await mirrorInitArtifact(join(vpSpecBase, 'changes', vpChange, 'verify-result.md'), 'verify-result.md', readFileSync(join(vpSpecBase, 'changes', vpChange, 'verify-result.md'), 'utf8')) } catch { /* 镜像失败不阻断 */ }
+          console.log(`✏️  amend-draft 已重锚 ${vpAmKeys.length} 个机器段：${vpAmKeys.join('、')}（sidecar 记 amendment 审计——verify --done 篡改门禁按新指纹放行）`);
+        } else {
+          console.log('ℹ️  无 MACHINE-DRAFT 标记段可重锚（报告未用 --draft 生成，或标记已全部删除——后者会被 --done 拒收，先恢复标记或重跑 --init --force --draft）');
+        }
+        break;
+      }
       if (json) {
         console.log(JSON.stringify({ command: 'verify-probes', change: vpChange, ...vpResult }, null, 2));
         break;
@@ -1204,6 +1350,68 @@ task 进行中状态标记：开工/完工落 .runtime/task-progress/，list 标
           await mirrorInitArtifact(vpReportPath, 'verify-result.md', vpSkeleton);
           console.log(`\n📄 已生成 verify-result.md 骨架: ${vpReportPath}（探针已预填；结论必须写明 PASS/FAIL，留待填会被 gate 判不过）${vpPlatformNote}`);
         }
+        // ── --draft 填槽模式（r5l 方案3/护栏#2，v2 件二）── 四节机器预填完整句子 + 指纹防篡改。
+        // 位置刻意在 backfill/ensure/inject 三 enricher 之前：决策追踪矩阵由本段先落（含标记），
+        // injectDecisionChainDraft 随后见表格自然 no-op（幂等两不误）。材料与 verify 门对账同源：
+        // 测试结果优先级 P2 账本 > 质量扫描记录（gates.js 同序）；风险判级 evaluateConclusionDraft
+        // 同款口径（detectChangeRisk 词表已退役 D-008）。幂等：段内非 TODO 占位（已手写/已
+        // draft 化）零改动；平台模式 sidecar 随 vpSpecBase 锚定（门禁侧 not-applicable 即降级放行，
+        // 不产生假红）。
+        if (vpDraft && existsSync(vpReportPath)) {
+          try {
+            const { resolveRuntimeRoot } = await import('./run/shared.js');
+            const { summarizeTaskCompletion } = await import('./task-review.js');
+            const { buildDecisionChainMatrix } = await import('./verify-probes.js');
+            const { parseFileChangeListDetailed } = await import('./change-list.js');
+            const { loadBlastDeclarationsAllProjects } = await import('./blast-surface.js');
+            const { resolveChangeRisk, extractExplicitRiskLevel } = await import('./change-risk-profile.js');
+            const { consultTestLedger } = await import('./run/test-ledger.js');
+            const { loadReusableQualityScan } = await import('./run/verify-quality-scan.js');
+            const { buildDraftSections, applyDraftMode } = await import('./verify-draft.js');
+            const vpChangeDir = join(vpSpecBase, 'changes', vpChange);
+            const vpRuntimeRoot = resolveRuntimeRoot({}, vpSpecBase);
+            // ① 任务完成度（summarizeTaskCompletion 同源：review verdict 真源 + 降级说明句）
+            const vpSummarize = summarizeTaskCompletion({ changeDir: vpChangeDir, runtimeRoot: vpRuntimeRoot, changeName: vpChange });
+            // ② 风险等级（evaluateConclusionDraft 同款输入面；无清单 → null 走降级句）
+            let vpRisk = null;
+            try {
+              const vpDesignPath = join(vpChangeDir, 'design.md');
+              const vpDesignContent = existsSync(vpDesignPath) ? readFileSync(vpDesignPath, 'utf8') : '';
+              const vpDeclared = parseFileChangeListDetailed(vpDesignPath, { keepSillyspecDocs: true }).map((e) => e.path);
+              if (vpDeclared.length > 0) {
+                vpRisk = resolveChangeRisk({
+                  files: vpDeclared,
+                  blastDeclarations: loadBlastDeclarationsAllProjects({ specBase: vpSpecBase }),
+                  explicitRiskLevel: vpDesignContent ? extractExplicitRiskLevel(vpDesignContent) : null,
+                });
+              }
+            } catch { /* 风险材料不可得 → 降级句（完整句子，不空段） */ }
+            // ③ 测试结果（与 verify 门对账同源优先级：P2 账本 > 扫描记录 > 无记录提示句）
+            let vpTest = null;
+            try {
+              const vpConsult = consultTestLedger({ runtimeRoot: vpRuntimeRoot, changeName: vpChange, projectRoot: dir, testRoot: join(dir, 'test'), specBase: vpSpecBase, cwd: dir });
+              if (vpConsult.reuse) vpTest = { source: 'ledger', command: vpConsult.runPlan?.[0]?.runner || 'npm test', status: 'passed', ranAt: vpConsult.result.ranAt, durationMs: vpConsult.result.durationMs, total: vpConsult.result.total ?? null };
+            } catch { /* 账本咨询异常 → 下一源 */ }
+            if (!vpTest) {
+              try {
+                const vpScan = loadReusableQualityScan({ specBase: vpSpecBase, cwd: dir, changeName: vpChange });
+                if (vpScan && vpScan.testResult) vpTest = { source: 'scan', command: vpScan.testResult.command, status: vpScan.testResult.status, ranAt: vpScan.ranAt, durationMs: vpScan.testResult.durationMs, total: vpScan.testResult.total ?? null };
+              } catch { /* 扫描记录不可得 → 提示句 */ }
+            }
+            // ④ 决策追踪（buildDecisionChainMatrix 机械半边——Evidence/状态两列留人工）
+            const vpChain = buildDecisionChainMatrix(vpChangeDir);
+            const vpDraftRes = applyDraftMode({
+              mdPath: vpReportPath, changeName: vpChange, runtimeRoot: vpRuntimeRoot,
+              sections: buildDraftSections({ summarize: vpSummarize, risk: vpRisk, testResult: vpTest, decisionChain: vpChain }),
+            });
+            if (vpDraftRes) {
+              try { await mirrorInitArtifact(vpReportPath, 'verify-result.md', readFileSync(vpReportPath, 'utf8')) } catch { /* 镜像失败不阻断 */ }
+              console.log(`\n📝 填槽模式已应用：${vpDraftRes.applied.length} 节机器预填（${vpDraftRes.applied.join('、')}，MACHINE-DRAFT 指纹防篡改——整段改写会被 verify --done 拒收）；你只填三处 <!--AGENT:--> 槽（结论枚举/移交项/审查叙述）${vpPlatformNote}`);
+            }
+          } catch (e) {
+            console.warn(`⚠️ --draft 机器起草降级（fail-soft，骨架保持原态）: ${e && e.message ? e.message : e}`);
+          }
+        }
         const vpFacts = writeVerifyFacts(join(vpSpecBase, 'changes', vpChange), vpResult, vpChange, {
           platformNote: formatPlatformPathNote(vpPlatformBase, vpChange, 'verify-facts.json'),
         }); // P3b：facts 底稿随 --init 刷新（骨架已存在也刷新；v2 起分段合并保留固化段）
@@ -1270,6 +1478,15 @@ task 进行中状态标记：开工/完工落 .runtime/task-progress/，list 标
           }
         } catch { /* 草稿预填失败不阻断 --init */ }
       }
+      // ── 产物落盘即推平台（2026-09-24 fr-test-readside 断流实证修复④）：--init/--force
+      //    写探针报告/骨架/facts 后不触发同步，verify 期步骤与文件迟到平台直到 --done——
+      //    补 triggerSync 与 stage 渲染同拍（bg 异步，不阻塞命令返回）。──
+      if (vpChange && (vpInit || vpForce)) {
+        try {
+          const { triggerSync } = await import('./run/shared.js')
+          triggerSync(dir, vpChange, { specRoot: vpSpecBase })
+        } catch { /* 同步触发失败不阻断探针命令 */ }
+      }
       break;
     }
     case 'review-dispatch': {
@@ -2508,6 +2725,9 @@ ${generated.length} 个骨架已就绪——逐节把 <!--TODO--> 替换为语
         break
       }
       const { runCommand } = await import('./run.js')
+      // quick 通道退役预门（2026-09-25-quick-channel-retire）：`run quick` 新会话形态在进
+      // runCommand（及其前置副作用：sid 生成/owner.json/已建立公告）之前拒绝
+      if (filteredArgs[1] === 'quick') refuseRetiredQuickFreshStart(filteredArgs.slice(1))
       // 平台模式（--spec-dir 已指定）时，--dir 是明确的 source_root，不应被 resolveEffectiveDir 纠正
       const effectiveDir = specDir ? dir : resolveEffectiveDir(dir)
       // 下行 pull：对齐顶层 stage 别名块（task-10 / D-009 / FR-04）。修复前 case 'run' 漏接，
@@ -2784,8 +3004,11 @@ ${generated.length} 个骨架已就绪——逐节把 <!--TODO--> 替换为语
     case 'verify':
     case 'auto':
     case 'archive': {
-      const { runCommand } = await import('./run.js')
       const stageArgs = [command, ...filteredArgs.slice(1)]
+      // quick 通道退役预门（2026-09-25-quick-channel-retire）：顶层 quick 别名的新会话形态
+      // 在进 runCommand（及其前置副作用）之前拒绝
+      if (command === 'quick') refuseRetiredQuickFreshStart(stageArgs)
+      const { runCommand } = await import('./run.js')
       const effectiveDir = specDir ? dir : resolveEffectiveDir(dir)
       // 下行 pull：stage 命令（run/--done，含 archive）启动时拉一次（task-10 / D-009 / FR-04）
       // 不在每步 pull，仅低频边界点；未连接平台静默跳过
@@ -2796,7 +3019,182 @@ ${generated.length} 个骨架已就绪——逐节把 <!--TODO--> 替换为语
     }
     case 'knowledge': {
       const { cmdKnowledge } = await import('./stages/knowledge.js')
-      await cmdKnowledge(filteredArgs.slice(1), specDir ? dir : resolveEffectiveDir(dir), { specDir })
+      await cmdKnowledge(filteredArgs.slice(1), specDir ? dir : resolveEffectiveDir(dir), { specDir, json })
+      break
+    }
+    // ── sillyspec tests（2026-09-24-fr-test-bindings task-02，fr-test-binding §3.2/§5）：
+    //    绑定面视图 + 唯一合法修理工。锚可解析+路径存在硬校验——修理工不得制造悬空。──
+    case 'tests': {
+      const {
+        queryByAnchor, queryByChange, upsertFrBindings, upsertQlBindings,
+        unbindFrRows, unbindQlRows, anchorResolvable, normalizeRow, testAnchorFile,
+        readFrBindings, upsertFrBindingsRaw, resolveTestFileRel,
+      } = await import('./test-bindings.js')
+      const effDir = specDir ? dir : resolveEffectiveDir(dir)
+      const specBase = specDir || join(effDir, '.sillyspec')
+      const knowledgeRoot = join(specBase, 'knowledge')
+      // ── repair-paths（2026-09-26-dynamic-test-inference）：存量绑定路径错形修复 ──
+      // 三形态混杂（根相对 ✓ / 丢子项目前缀的 cwd 相对 / 裸文件名——平台仓实证）统一归一为
+      // 仓根相对。缺省干跑预览，--write 落盘（upsertFrBindingsRaw 权威重写，路径级修复不触
+      // 行语义）。逐条经硬校验（resolveTestFileRel 只认磁盘在场文件），修复工不得制造悬空。
+      if (filteredArgs.slice(1).includes('repair-paths')) {
+        const write = filteredArgs.includes('--write')
+        const frDir = join(knowledgeRoot, 'fr')
+        if (!existsSync(frDir)) { console.error(`❌ knowledge/fr 不存在（${frDir}）——本仓无 FR 绑定面`); process.exitCode = 1; break }
+        let plannedRows = 0, plannedPaths = 0, unresolvable = []
+        const filePlan = []
+        for (const f of readdirSync(frDir).filter(x => x.endsWith('.md')).sort()) {
+          const p = join(frDir, f)
+          const lines = readFileSync(p, 'utf8').split(/\r?\n/)
+          const frIds = [...new Set(lines.filter(l => /^## (FR-[\w-]+-\d+)\s/.test(l)).map(l => l.match(/^## (FR-[\w-]+-\d+)/)[1]))]
+          for (const frId of frIds) {
+            const rows = readFrBindings({ knowledgeRoot, frId })
+            let rowChanged = 0
+            const fixedRows = rows.map(r => {
+              const fixedTests = (r.tests || []).map(t => {
+                const filePart = testAnchorFile(String(t))
+                const anchorPart = String(t).slice(filePart.length)
+                if (existsSync(resolve(effDir, filePart.replace(/\\/g, '/')))) return String(t) // 已是仓根相对
+                const rel = resolveTestFileRel(filePart, { projectRoot: effDir })
+                if (rel) { plannedPaths++; return rel + anchorPart }
+                unresolvable.push(`${frId}:${t}`)
+                return String(t)
+              })
+              if (JSON.stringify(fixedTests) !== JSON.stringify(r.tests || [])) { rowChanged++; return { ...r, tests: fixedTests } }
+              return r
+            })
+            if (rowChanged > 0) { plannedRows += rowChanged; filePlan.push({ file: f, frId, rows: fixedRows }) }
+          }
+        }
+        if (plannedPaths === 0) {
+          console.log(`✅ 绑定路径无需修复（fr/*.md 全部条目 tests 均可自仓根解析${unresolvable.length ? `；${unresolvable.length} 个无法定位需人工核（--write 也只保留原值）：${unresolvable.slice(0, 5).join('、')}${unresolvable.length > 5 ? ' 等' : ''}` : ''}）`)
+          break
+        }
+        console.log(`🔧 绑定路径修复${write ? '' : '预览（--write 落盘）'}：${plannedRows} 行 / ${plannedPaths} 个路径归一为仓根相对，涉及 ${filePlan.length} 个条目`)
+        for (const fp of filePlan.slice(0, 10)) console.log(`   ${fp.file} :: ${fp.frId}`)
+        if (filePlan.length > 10) console.log(`   … 共 ${filePlan.length} 个条目`)
+        if (unresolvable.length > 0) console.warn(`⚠️ ${unresolvable.length} 个路径无法自仓根定位（保留原值，人工核）：${unresolvable.slice(0, 5).join('、')}${unresolvable.length > 5 ? ' 等' : ''}`)
+        if (!write) break
+        for (const fp of filePlan) upsertFrBindingsRaw({ knowledgeRoot, frId: fp.frId, rows: fp.rows })
+        console.log(`✅ 已写入 ${filePlan.length} 个条目的归一路径`)
+        break
+      }
+      const flag = (name) => { const i = filteredArgs.indexOf(name); return i !== -1 && i + 1 < filteredArgs.length ? filteredArgs[i + 1] : null }
+      const has = (name) => filteredArgs.includes(name)
+      const anchor = flag('--anchor')
+      const change = flag('--change')
+      const rowId = flag('--row-id')
+      const testsArg = flag('--tests')
+      const reason = flag('--reason') || 'spec'
+      const fail = (msg) => { console.error(`❌ ${msg}`); process.exitCode = 1 }
+      // repair-paths/--redomain 自带用法门，不走 anchor/change 前置守卫
+      if (!anchor && !change && !has('--repair-paths') && !filteredArgs.slice(1).includes('repair-paths') && !has('--redomain')) { fail('用法: sillyspec tests --anchor <FR-…|ql-…> | --change <名> [--bind|--unbind] [--tests <p1,p2>] [--row-id <id>] [--reason spec|capability|regression] | repair-paths | --redomain --from <域> --to <域>'); break }
+      // 变更期局部锚（FR-NN 未铸全局）只读拒绝修改——修理工仅面向提升后行
+      const isLocalAnchor = anchor && /^FR-\d+$/.test(anchor)
+      if ((has('--bind') || has('--unbind')) && isLocalAnchor) { fail(`变更期局部锚「${anchor}」只读——修理工仅面向提升后的全局锚（FR-<域>-NNN / ql-…）`); break }
+      if (has('--bind') || has('--unbind')) {
+        if (!anchor) { fail('--bind/--unbind 须配 --anchor'); break }
+        if (!anchorResolvable({ specBase, knowledgeRoot, anchor })) { fail(`锚不可解析「${anchor}」（FR=活库条目 / ql=QUICKLOG 在册）——修理工不得制造悬空锚`); break }
+      }
+      if (has('--bind')) {
+        const tests = (testsArg || '').split(',').map(s => s.trim()).filter(Boolean)
+        if (tests.length === 0) { fail('--bind 须配 --tests <p1,p2>（仓根相对路径）'); break }
+        const missing = tests.filter(p => !existsSync(resolve(effDir, p)))
+        if (missing.length > 0) { fail(`tests 路径不存在：${missing.join('、')}（相对 ${effDir}）——修理工不得制造悬空路径`); break }
+        const head = (() => { try { return gitQuiet(effDir, ['rev-parse', 'HEAD']) || null } catch { return null } })()
+        const row = { anchor, row_id: rowId || `manual:${Date.now().toString(36)}:${tests[0]}`, tests, reason, state: 'active', discovery: 'agent', confirmed_by: 'agent', confirmed_at: head, source_change: change || 'manual' }
+        try {
+          normalizeRow(row)
+          if (/^FR-/.test(anchor)) upsertFrBindings({ knowledgeRoot, frId: anchor, rows: [row], projectRoot: effDir })
+          else upsertQlBindings({ specBase, qlId: anchor, rows: [row] })
+          console.log(`✅ 绑定写入：${anchor} ← ${tests.join(', ')}（confirmed_by=agent${head ? ` @${head.slice(0, 8)}` : ''}）`)
+        } catch (e) { fail(`绑定写入被拒：${e && e.message ? e.message : e}`) }
+        break
+      }
+      if (has('--unbind')) {
+        const ids = rowId ? [rowId] : (testsArg || '').split(',').map(s => s.trim()).filter(Boolean)
+        if (ids.length === 0) { fail('--unbind 须配 --row-id <id> 或 --tests <p1,…>'); break }
+        if (/^FR-/.test(anchor)) {
+          const cur = queryByAnchor({ specBase, knowledgeRoot, anchor })
+          // tests 条目可携带用例锚（2026-09-26-binding-anchor-fidelity）——给路径也能命中带锚行
+          const del = cur.filter(r => ids.includes(r.row_id) || (testsArg && ids.length === 1 && r.tests.some(t => ids.includes(t) || ids.includes(testAnchorFile(t))))).map(r => r.row_id)
+          if (del.length === 0) { fail(`未命中可解绑行（anchor=${anchor}，给=${ids.join(',')}）`); break }
+          unbindFrRows({ knowledgeRoot, frId: anchor, rowIds: del })
+          console.log(`✅ 解绑 ${del.length} 行（${anchor}）`)
+        } else {
+          const cur = queryByAnchor({ specBase, knowledgeRoot, anchor })
+          const del = cur.filter(r => ids.includes(r.row_id)).map(r => r.row_id)
+          if (del.length === 0) { fail(`未命中可解绑行（anchor=${anchor}）`); break }
+          unbindQlRows({ specBase, qlId: anchor, rowIds: del })
+          console.log(`✅ 解绑 ${del.length} 行（${anchor}）`)
+        }
+        break
+      }
+      // ── confirm（2026-09-27-confirm-on-use 三层治理①层）：消费时确认翻牌 ──
+      // candidate 机器行（confirmed_by=null）批量翻 active（confirmed_by=agent）——抽查式
+      // 确认的写回通道。机械防橡皮图章：--evidence 必须是可自仓根解析的真实测试路径
+      // （resolveTestFileRel 单源），解析失败拒绝 exit 1。
+      if (has('--confirm')) {
+        if (!anchor || !/^FR-/.test(anchor)) { fail('用法: sillyspec tests --confirm --anchor FR-<域>-NNN --evidence <真实测试路径>'); break }
+        const evidenceRaw = flag('--evidence')
+        if (!evidenceRaw) { fail('--confirm 须配 --evidence <真实测试路径>（防橡皮图章：证据必须是盘上文件）'); break }
+        const { resolveTestFileRel: _rtf2 } = await import('./test-bindings.js')
+        const evRel = _rtf2(testAnchorFile(evidenceRaw), { projectRoot: effDir }) || (existsSync(resolve(effDir, evidenceRaw.replace(/\\/g, '/'))) ? evidenceRaw.replace(/\\/g, '/') : null)
+        // 评审 P2-1 清偿：证据须为测试形态文件（*.test.* / *.spec.* / test_*.py / *_test.*）——
+        // resolveTestFileRel 直取分支无形态检查（package.json/win.ini 实证可绕），此处收口
+        const evBase = evRel ? evRel.split('/').pop() : ''
+        const EV_TEST_SHAPE_RE = new RegExp('\\.(test|spec)\\.[cm]?[jt]sx?$')
+        const evShaped = !!evRel && (EV_TEST_SHAPE_RE.test(evBase) || /^test_[\w.]+\.py$/.test(evBase) || /_test\.(go|py)$/.test(evBase))
+        if (!evShaped) { fail(`证据必须是盘上真实测试文件（*.test.* / test_*.py 等形态）：${evidenceRaw}——不收口头相符，不收非测试文件`); break }
+        const rows = readFrBindings({ knowledgeRoot, frId: anchor })
+        if (rows.length === 0) { fail(`${anchor} 无绑定行——确认对象不存在（先 --bind 或经归档提升）`); break }
+        const head2 = (() => { try { return gitQuiet(effDir, ['rev-parse', 'HEAD']) || null } catch { return null } })()
+        const confirmed = rows.map((r) => r.confirmed_by === 'agent' ? r : { ...r, state: 'active', confirmed_by: 'agent', confirmed_at: head2 })
+        const flipped = confirmed.filter((r, i) => rows[i].confirmed_by !== 'agent').length
+        if (flipped === 0) { console.log(`ℹ️ ${anchor} 全部绑定行已 active（幂等，无需确认）`); break }
+        upsertFrBindingsRaw({ knowledgeRoot, frId: anchor, rows: confirmed, projectRoot: effDir })
+        console.log(`✅ 确认翻牌：${anchor} ${flipped}/${rows.length} 行 candidate→active（confirmed_by=agent${head2 ? ` @${head2.slice(0, 8)}` : ''}；证据=${evRel}）`)
+        break
+      }
+      // ── redomain（2026-09-27-redomain，三层治理 v2 ③）：伪域条目机器迁移 ──
+      // --from <域> --to <域> [--anchor <FR-id> 可重复]；干跑缺省列条目，--write 落盘。
+      // 身份铁律：迁域不换号（绑定/supersede 链靠 ID 寻址）；平台伪域卡「一键迁移」的 CLI 端。
+      if (has('--redomain')) {
+        const fromD = flag('--from')
+        const toD = flag('--to')
+        if (!fromD || !toD) { fail('用法: sillyspec tests --redomain --from <源域> --to <目标域> [--anchor <FR-id>] [--write]'); break }
+        // 多 --anchor 收集
+        const anchorList = []
+        for (let i = 0; i < filteredArgs.length - 1; i++) if (filteredArgs[i] === '--anchor') anchorList.push(filteredArgs[i + 1])
+        try {
+          const { planRedomain, redomainFrEntries } = await import('./redomain.js')
+          if (!has('--write')) {
+            const plan = planRedomain({ knowledgeRoot, from: fromD, to: toD, anchors: anchorList.length ? anchorList : null })
+            console.log(`🔧 域迁移预览（--write 落盘）：fr/${fromD}.md → fr/${toD}.md，${plan.entries.length} 条`)
+            for (const e of plan.entries.slice(0, 10)) console.log(`   ${e.id} ${e.title}`)
+            if (plan.entries.length > 10) console.log(`   … 共 ${plan.entries.length} 条`)
+            console.log(`   目标域文件${plan.targetExists ? '在场' : '将新建'}；源域${plan.sourceWillDelete ? '将删空壳' : '保留余条'}；ID 不变（身份保持）`)
+            break
+          }
+          const r = redomainFrEntries({ knowledgeRoot, from: fromD, to: toD, anchors: anchorList.length ? anchorList : null })
+          console.log(`✅ 域迁移完成：${r.moved.length} 条 fr/${fromD}.md → fr/${toD}.md（ID 不变）`)
+          for (const m of r.moved.slice(0, 10)) console.log(`   ${m.id} ${m.title}`)
+          if (r.sourceDeleted) console.log(`   源域空壳已删：fr/${fromD}.md`)
+          if (r.targetCreated) console.log(`   目标域文件新建：fr/${toD}.md`)
+          if (r.indexLineAdded) console.log(`   INDEX 路由行已补：${toD}`)
+        } catch (e) { fail(`域迁移被拒：${(e && e.message) || e}`) }
+        break
+      }
+      // 视图
+      const rows = anchor
+        ? queryByAnchor({ specBase, knowledgeRoot, anchor })
+        : queryByChange({ specBase, knowledgeRoot, sourceChange: change })
+      if (rows.length === 0) { console.log(`（无绑定行：${anchor || change}）`); break }
+      console.log(`${anchor || change} — ${rows.length} 行`)
+      for (const r of rows) {
+        console.log(`  ${r.state === 'active' ? '🟢' : '⚪'} ${r.tests.join(', ')}｜reason=${r.reason}｜discovery=${r.discovery}｜confirmed_by=${r.confirmed_by || '-'}${r.confirmed_at ? '@' + String(r.confirmed_at).slice(0, 8) : ''}｜status=${r.status}`)
+        console.log(`     row=${r.row_id}｜source=${r.source_change || '-'}`)
+      }
       break
     }
     case 'dashboard': {
@@ -4153,6 +4551,12 @@ checkbox 行；depends_on 自动反填行内注解 "(depends_on: task-01,02)"；
       process.exitCode = r.ok ? 0 : 1;
       break;
     }
+    case 'flow': {
+      // R7 切片二：2-调用轻量协议命令族（start/done/amend-draft）——协议必需交互=2
+      const flowMod = await import('./flow.js');
+      await flowMod.cmdFlow(filteredArgs.slice(1), dir, specDir);
+      break;
+    }
     case 'workflow': {
       const wfSub = filteredArgs[1];
       if (!wfSub || wfSub === 'help' || wfSub === '--help') {
@@ -4663,8 +5067,158 @@ SillySpec pull — 拉取服务器 spec 快照到本地（X2 / FR-07）
       }
       break;
     }
+    case 'watcher': {
+      // 哨兵告警可视化出口（2026-09-23 quick / 1a91587c 后续件）：watcher 落的
+      // watcher-events-<change>.jsonl 是事件唯一真相源，此前只能人肉 grep。纯只读查询 +
+      // 可选 --follow 轮询；不改 applySentinelRules、不做平台推送、不加新事件类型。
+      // 子命令面：alerts；预留名（勿占）：events（原始流格式化）/ tail（时间窗过滤）。
+      const watcherSub = filteredArgs[1];
+      if (watcherSub !== 'alerts' && watcherSub !== 'timeline') {
+        const sug = didYouMean(watcherSub || '', ['alerts', 'timeline']);
+        console.error(`❌ 未知子命令: watcher ${watcherSub || '(空)'}`);
+        if (sug) console.error(`   你是想输入「watcher ${sug}」吗？`);
+        console.error('用法: sillyspec watcher alerts --change <名> [--all] [--follow] [--runtime-root <路径>]');
+        console.error('      sillyspec watcher timeline --change <名> [--runtime-root <路径>]');
+        process.exit(2);
+      }
+      // ── timeline 子命令（2026-09-26-watcher-timeline）：变更合成时间线只读出口 ──
+      // 三源 join（事件流 × tasks.md × git 提交锚）在 src/timeline.js 纯函数层；此处只做
+      // I/O 接线（runtimeRoot 解析与 alerts 同源；change 目录活跃>归档双路径探测）。
+      if (watcherSub === 'timeline') {
+        const tRest = filteredArgs.slice(2);
+        let tChange = null;
+        let tRuntimeRootFlag = null;
+        for (let i = 0; i < tRest.length; i++) {
+          if (tRest[i] === '--change' && tRest[i + 1]) tChange = tRest[++i];
+          else if (tRest[i] === '--runtime-root' && tRest[i + 1]) tRuntimeRootFlag = resolve(tRest[++i]);
+        }
+        if (!tChange) {
+          console.error('❌ watcher timeline 需要 --change <变更名>');
+          console.error('用法: sillyspec watcher timeline --change <名> [--runtime-root <路径>]');
+          process.exit(2);
+        }
+        assertSafeChangeName(tChange, '变更名');
+        const { resolveRuntimeRoot } = await import('./run/shared.js');
+        const { readWatcherEvents } = await import('./watcher.js');
+        const { loadChangeTasks, readBirthTs, resolveCommitAnchors, parseTaskLines, renderTimeline } = await import('./timeline.js');
+        const tSpecBase = resolvePlatformSpecDir(dir, specDir) || join(dir, '.sillyspec');
+        const tPlatformOpts = resolvePlatformOpts(dir, specDir);
+        const tRuntimeRoot = resolveRuntimeRoot({ runtimeRoot: tRuntimeRootFlag || (tPlatformOpts && tPlatformOpts.runtimeRoot) || null }, tSpecBase);
+        let tRes = readWatcherEvents({ runtimeRoot: tRuntimeRoot, change: tChange });
+        let tSourceNote = '';
+        if (!tRes.exists) {
+          // 归档包烤制副本回退（2026-09-28-archive-timeline-bake）：本机 .runtime 无事件流（跨机
+          // clone / 机本位清理）时读归档包内 watcher-events.jsonl 副本——时间线不随 .runtime 存活消失；
+          // 副本也缺失时保持既有 exit 2 提示语义。
+          const tBakedPath = join(tSpecBase, 'changes', 'archive', tChange, 'watcher-events.jsonl');
+          const tBaked = readWatcherEvents({ path: tBakedPath });
+          if (tBaked.exists) {
+            tRes = tBaked;
+            tSourceNote = `（事件源：归档包烤制快照 ${tBakedPath}——本机 .runtime 无事件流）`;
+          }
+        }
+        if (!tRes.exists) {
+          console.error(`📭 ${tChange} 无事件流（未跑过 watcher），无从合成时间线`);
+          console.error(`   事件流路径：${join(tRuntimeRoot, `watcher-events-${tChange}.jsonl`)}；活跃变更跑任意 flow/run 命令会拉起 watcher`);
+          process.exit(2);
+        }
+        const { changeDir, tasksMd } = loadChangeTasks(tSpecBase, tChange);
+        const tasks = tasksMd ? parseTaskLines(tasksMd) : null;
+        let tier = null;
+        if (changeDir) {
+          try {
+            const m = /^tier:\s*(\S+)/m.exec(readFileSync(join(changeDir, 'flow-state.yaml'), 'utf8'));
+            if (m) tier = m[1];
+          } catch { /* 缺 flow-state（头脑风暴预段等）按未知 */ }
+        }
+        const { gitQuiet } = await import('./git-helper.js');
+        const anchors = resolveCommitAnchors(tRes.events, (hash) => {
+          const out = gitQuiet(dir, ['log', '-1', '--format=%h%x1f%aI%x1f%B', hash]);
+          if (typeof out !== 'string' || !out.trim()) return null;
+          const sep = out.indexOf('\x1f');
+          const rest = out.slice(sep + 1);
+          const sep2 = rest.indexOf('\x1f');
+          return { hash: out.slice(0, sep), dateISO: rest.slice(0, sep2), message: rest.slice(sep2 + 1) };
+        });
+        console.log(renderTimeline({ change: tChange, events: tRes.events, tasks, anchors, birthTs: readBirthTs(changeDir), tier }));
+        if (tSourceNote) console.log(tSourceNote);
+        break;
+      }
+      const wRest = filteredArgs.slice(2);
+      let wChange = null;
+      let wRuntimeRootFlag = null;
+      let wAll = false;
+      let wFollow = false;
+      for (let i = 0; i < wRest.length; i++) {
+        if (wRest[i] === '--change' && wRest[i + 1]) wChange = wRest[++i];
+        else if (wRest[i] === '--runtime-root' && wRest[i + 1]) wRuntimeRootFlag = resolve(wRest[++i]);
+        else if (wRest[i] === '--all') wAll = true;
+        else if (wRest[i] === '--follow') wFollow = true;
+      }
+      if (!wChange) {
+        console.error('❌ watcher alerts 需要 --change <变更名>（事件流按变更名分文件）');
+        console.error('用法: sillyspec watcher alerts --change <名> [--all] [--follow] [--runtime-root <路径>]');
+        process.exit(2);
+      }
+      assertSafeChangeName(wChange, '变更名');
+      const { resolveRuntimeRoot } = await import('./run/shared.js');
+      const { readWatcherEvents, watcherEventsPath } = await import('./watcher.js');
+      // runtimeRoot 解析与 watcher.js spawnWatcher 同源：--runtime-root flag > 平台指针
+      // runtimeRoot > specBase/.runtime（resolveRuntimeRoot 单点收敛）。
+      const wSpecBase = resolvePlatformSpecDir(dir, specDir) || join(dir, '.sillyspec');
+      const wPlatformOpts = resolvePlatformOpts(dir, specDir);
+      const wRuntimeRoot = resolveRuntimeRoot({ runtimeRoot: wRuntimeRootFlag || (wPlatformOpts && wPlatformOpts.runtimeRoot) || null }, wSpecBase);
+
+      const ALERTS_POLL_MS = 2000;
+      const fmtLocal = (ts) => {
+        const d = new Date(Number(ts));
+        if (Number.isNaN(d.getTime())) return String(ts);
+        const p = (n) => String(n).padStart(2, '0');
+        return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
+      };
+      // detail 截 80：超长取前 79 列 + 省略号恰好 80 列
+      const clip80 = (s) => {
+        const t = String(s ?? '');
+        return t.length > 80 ? t.slice(0, 79) + '…' : t;
+      };
+      const fmtRow = (e) => `${fmtLocal(e.ts)} | ${String(e.rule ?? e.kind ?? '').padEnd(12)} | ${clip80(e.detail)}`;
+      const fmtStats = (warnN, evN, badN) => `📊 ${warnN} 条告警 / ${evN} 条事件${badN > 0 ? `（跳过 ${badN} 坏行）` : ''}`;
+
+      let wRes = readWatcherEvents({ runtimeRoot: wRuntimeRoot, change: wChange });
+      if (!wRes.exists) {
+        console.log(`📭 ${wChange} 无事件流（未跑过 watcher）: ${watcherEventsPath(wRuntimeRoot, wChange)}`);
+        break;
+      }
+      console.log(`🕒 watcher alerts — ${wChange}（${wRuntimeRoot}）`);
+      console.log(`${'本地时间'.padEnd(19)} | ${wAll ? 'rule/kind' : 'rule'.padEnd(12)} | detail`);
+      const shown = wAll ? wRes.events : wRes.warnings;
+      for (const e of shown) console.log(fmtRow(e));
+      console.log(fmtStats(wRes.warnings.length, wRes.events.length, wRes.badLines));
+      if (!wFollow) break;
+
+      // --follow：2s 轮询增量打印（jsonl 单写者 append-only，按 events 序号单调锚定已打印
+      // 水位；坏行不产事件不干扰锚——残行下一轮解析成功后自然补打）。Ctrl-C 打印末次统计退出。
+      console.log('\n⏳ 持续监听中（2s 轮询，Ctrl-C 退出）');
+      const printNew = (from) => {
+        const rows = (wAll ? wRes.events : wRes.warnings).slice(from);
+        for (const e of rows) console.log(fmtRow(e));
+      };
+      let printed = shown.length;
+      process.on('SIGINT', () => {
+        console.log(`\n${fmtStats(wRes.warnings.length, wRes.events.length, wRes.badLines)}（已停止监听）`);
+        process.exit(0);
+      });
+      // eslint-disable-next-line no-constant-condition
+      while (true) {
+        await new Promise((r) => setTimeout(r, ALERTS_POLL_MS));
+        wRes = readWatcherEvents({ runtimeRoot: wRuntimeRoot, change: wChange });
+        if (!wRes.exists) continue; // 文件中途被删：继续等（watcher 重启会重建）
+        printNew(printed);
+        printed = wAll ? wRes.events.length : wRes.warnings.length;
+      }
+    }
     default: {
-      const topCommands = ['init', 'setup', 'run', 'progress', 'worktree', 'dispatch', 'agent-log', 'local', 'workflow', 'gate', 'derive', 'backfill-reviews', 'register-stage-review', 'modules', 'change-rename', 'change-delete', 'knowledge', 'platform', 'pull', 'scan', 'brainstorm', 'plan', 'execute', 'verify', 'archive', 'quick', 'explore', 'status', 'doctor', 'auto', 'runtime'];
+      const topCommands = ['init', 'setup', 'run', 'progress', 'worktree', 'dispatch', 'agent-log', 'local', 'workflow', 'gate', 'derive', 'backfill-reviews', 'register-stage-review', 'modules', 'change-rename', 'change-delete', 'knowledge', 'platform', 'pull', 'scan', 'brainstorm', 'plan', 'execute', 'verify', 'archive', 'quick', 'explore', 'status', 'doctor', 'auto', 'runtime', 'watcher'];
       const suggestion = didYouMean(command, topCommands);
       console.error(`❌ 未知命令: ${command}`);
       if (command === '--status') {