sillyspec 3.32.2 → 3.32.4

package/src/verify-probes.js

@@ -2180,6 +2180,9 @@ export function runVerifyProbes({ cwd, changeName, specDir = null }) {
             task: fmId || f.replace(/\.md$/, ''),
             acceptance: parsed.acceptance,
             fmError: parsed.status === 'invalid-yaml' ? parsed.error : null,
+            // FR-06（2026-10-09-verify-reuse-friction）：行 repo 归属写侧透传（跨仓卡 tests
+            // 仓根相对，读侧按行根解析）
+            repo: parseRepo(raw) || null,
             raw,
           })
         }
@@ -2280,6 +2283,9 @@ export function runVerifyProbes({ cwd, changeName, specDir = null }) {
                 discovery: 'machine',
                 confirmed_by: null,
                 source_change: changeName,
+                // FR-06（2026-10-09-verify-reuse-friction）：跨仓卡的 tests 是仓根相对——
+                // 行携 repo 归属供读侧按行根解析（缺省不落键=主仓，D-005@v1）。
+                ...(t.repo && t.repo !== 'main' ? { repo: t.repo } : {}),
               })
             })
           }
@@ -3854,3 +3860,138 @@ export function refreshProbeSections(existingText, freshReportText) {
   }
   return { text: out.join('\n'), replaced, kept, appended, carriedRows }
 }
+
+// ── --force 保人工面（2026-10-09-verify-papercuts ②）──
+// postmortem（2026-10-09-verify-reuse-friction 收口实证）：--force 全骨架重置虽有自动备份，
+// 但结论槽/移交项表/探针矩阵已填判定/决策矩阵已填格仍全部被 wipe——重填整套人工面是当日
+// 最大单点浪费（备份在 .runtime 里，找回-回填的来回远比携载贵）。本组合器把 --force 语义
+// 从「全量重置 + 备份找回」升级为「机器段全量重刷 + 人工面按段携载」：
+//   - 纯人工段（结论/移交项/证据账/集成回执/任务完成度/设计一致性/独立复核/风险等级）：
+//     旧段已填（无 <待填/<TODO 占位）→ 原样保留；未填 → 用新骨架（占位换新占位，无损失）；
+//   - 矩阵段（决策追踪矩阵/接口验证覆盖矩阵）：表格行按首列键携载（mergeProbeSection 同
+//     款语义——已填 Evidence/判定行不丢，新增行从新骨架进场）；
+//   - 探针容器段（## 探针结果）：逐探针号 merge（已填表格行携载，机器结论行刷新）；
+//   - 其余机器段：新骨架；旧文独有的自定义段：追加保留（不销毁用户内容）。
+// 安全方向与 refreshProbeSections 一致：宁可少刷新不误删；stale 由 gate 的
+// checkProbeConsistency 独立把关。备份照旧保留（兜底通道不撤）。
+
+/** 顶层段切分（^## 标题行起，至下一 ^## 或 EOF；# 级更细的 #### 归属其容器段） */
+function splitTopSections(text) {
+  const lines = String(text ?? '').split('\n')
+  const sections = []
+  let cur = null
+  for (let i = 0; i < lines.length; i++) {
+    if (/^## /.test(lines[i])) {
+      if (cur) cur.endLine = i
+      cur = { headingLine: lines[i], startLine: i, endLine: lines.length }
+      sections.push(cur)
+    }
+  }
+  return { lines, sections }
+}
+
+/** 段身份键：剥 [层：…] 尾注与（…）括注——同族段跨渲染措辞漂移仍可对上 */
+function topSectionKey(headingLine) {
+  return headingLine
+    .replace(/^##\s*/, '')
+    .replace(/\s*\[.*\]\s*$/, '')
+    .replace(/（.*$/, '')
+    .trim()
+}
+
+const HUMAN_SECTION_KEYS = ['结论', '移交项', '证据账', '集成验证回执', '任务完成度', '设计一致性', '独立复核', '变更风险等级', '技术债务', 'Runtime Evidence', '代码审查']
+const MATRIX_SECTION_KEYS = ['决策追踪矩阵', '接口验证覆盖矩阵']
+const PROBE_CONTAINER_KEY = '探针结果'
+
+/** 探针容器段合并：新骨架容器为基，逐探针号对旧容器做已填行携载；旧独有探针号追加 */
+function mergeProbeContainer(oldContainerLines, freshContainerLines) {
+  const oldParsed = splitProbeSectionRanges(oldContainerLines.join('\n'))
+  const freshParsed = splitProbeSectionRanges(freshContainerLines.join('\n'))
+  const out = [...freshParsed.lines]
+  let carriedRows = 0
+  const oldByNum = new Map(oldParsed.sections.map(s => [s.num, s]))
+  for (let idx = freshParsed.sections.length - 1; idx >= 0; idx--) {
+    const fs = freshParsed.sections[idx]
+    const os = oldByNum.get(fs.num)
+    if (!os) continue
+    const merged = mergeProbeSection(
+      oldParsed.lines.slice(os.startLine, os.endLine),
+      freshParsed.lines.slice(fs.startLine, fs.endLine),
+    )
+    // 倒序替换（审查 P2 修正，2026-10-09-verify-papercuts）：mergeProbeSection 对含 stale
+    // 键的段会在段尾追加（行数 > freshSeg），正序 splice 会使后续探针段 startLine 错位——
+    // 从后往前替换则前面行号不受影响，任一段行数膨胀都安全。
+    carriedRows += merged.carried
+    // 用 merged 文本替换 fresh 容器中该探针段（逐段行数已知，从后往前替换保行号稳定）
+    const freshSeg = freshParsed.lines.slice(fs.startLine, fs.endLine)
+    out.splice(fs.startLine, freshSeg.length, ...merged.text.split('\n'))
+  }
+  const freshNums = new Set(freshParsed.sections.map(s => s.num))
+  for (const os of oldParsed.sections) {
+    if (!freshNums.has(os.num)) {
+      out.push('', ...oldParsed.lines.slice(os.startLine, os.endLine))
+    }
+  }
+  return { text: out.join('\n'), carriedRows }
+}
+
+/**
+ * --force 应用骨架：机器段全量重刷 + 人工面携载（纯函数，导出供回归直测）。
+ * @param {string} existingText 现文（含已填人工面）
+ * @param {string} skeletonText generateVerifyResultSkeleton 新骨架
+ * @returns {{ text: string, carriedSections: string[], carriedRows: number }}
+ */
+export function applySkeletonPreservingHuman(existingText, skeletonText) {
+  const old = splitTopSections(existingText)
+  const fresh = splitTopSections(skeletonText)
+  const oldByKey = new Map()
+  for (const s of old.sections) {
+    const k = topSectionKey(s.headingLine)
+    if (!oldByKey.has(k)) oldByKey.set(k, s) // 同键段取首个（重复标题形态保首段）
+  }
+  const carriedSections = []
+  let carriedRows = 0
+  const out = []
+  let cursor = 0
+  for (const fs of fresh.sections) {
+    // 骨架段前的行原样带过
+    for (; cursor < fs.startLine; cursor++) out.push(fresh.lines[cursor])
+    const k = topSectionKey(fs.headingLine)
+    const os = oldByKey.get(k)
+    const freshSeg = fresh.lines.slice(fs.startLine, fs.endLine)
+    if (!os) {
+      out.push(...freshSeg)
+    } else if (HUMAN_SECTION_KEYS.includes(k)) {
+      const oldSeg = old.lines.slice(os.startLine, os.endLine)
+      if (/<待填|<!--TODO/.test(oldSeg.join('\n'))) {
+        out.push(...freshSeg) // 未填 → 换新骨架占位
+      } else {
+        out.push(...oldSeg) // 已填 → 原样保留
+        carriedSections.push(k)
+      }
+    } else if (MATRIX_SECTION_KEYS.includes(k)) {
+      const merged = mergeProbeSection(old.lines.slice(os.startLine, os.endLine), freshSeg)
+      carriedRows += merged.carried
+      out.push(...merged.text.split('\n'))
+      if (merged.carried > 0) carriedSections.push(k)
+    } else if (k === PROBE_CONTAINER_KEY) {
+      const merged = mergeProbeContainer(old.lines.slice(os.startLine, os.endLine), freshSeg)
+      carriedRows += merged.carriedRows
+      out.push(...merged.text.split('\n'))
+      if (merged.carriedRows > 0) carriedSections.push(k)
+    } else {
+      out.push(...freshSeg) // 机器段（探针概览/接口声明等）→ 新骨架
+    }
+    cursor = fs.endLine
+    oldByKey.delete(k)
+  }
+  for (; cursor < fresh.lines.length; cursor++) out.push(fresh.lines[cursor])
+  // 旧文独有段（用户自定义节）追加保留
+  if (oldByKey.size > 0) {
+    out.push('')
+    for (const [, s] of oldByKey) {
+      out.push(...old.lines.slice(s.startLine, s.endLine))
+    }
+  }
+  return { text: out.join('\n'), carriedSections, carriedRows }
+}

package/src/worktree.js

@@ -1326,9 +1326,17 @@ export class WorktreeManager {
    * 写进 worktree 内的 .sillyspec——而 apply 的 filterDeliverableFiles 把 .sillyspec/changes/ 排除在
    * 交付外（spec 文档不进代码 patch），cleanup 删除 worktree 这些产物即蒸发、主仓流程看不到。
    * 删除前扫 worktree 内两棵子树做最后打捞：
-   *   changes/<name>/** → 主仓缺失则 copy 回（verify-result.md 等核心场景）；同名不同内容仅列
-   *                      清单 warn 不覆盖（主仓版本可能是更新的，覆盖会倒退）
-   *   docs/**           → 主仓缺失则 copy 回（模块文档卡片；同名差异不提示——tracked checkout 副本常态）
+   *   changes/<name>/** → 三态判定（坑 archive-resurrect，2026-10-10 下游实证
+   *                      2026-10-09-attachment-inline-reference 残留 13 文件：归档把 changes/<name>/
+   *                      整体 rename 进 changes/archive/ 后，原路径缺失被误判 worktree 独有，旧快照
+   *                      整批复制回原路径复活已归档目录）：
+   *                      · 原路径同名存在 → 内容不同仅列清单 warn 不覆盖（主仓版本可能是更新的）
+   *                      · 原路径缺、changes/archive/<name>/ 有副本 → 判归档搬运，跳过不复制
+   *                        （不复活原路径、不覆盖 archive 权威副本）
+   *                      · 原路径与 archive 均缺 → 真 worktree 独有照捞：归档态捞进
+   *                        changes/archive/<name>/（原路径已注销禁止重建），未归档态捞回原路径
+   *   docs/**           → 主仓缺失则 copy 回（模块文档卡片；同名差异不提示——tracked checkout 副本常态；
+   *                      docs 不参与归档搬运，无三态）
    * 只扫本变更子树（其它 change 的副本文件不越权搬运）。异常只 warn 不阻断清理。
    * @private
    */
@@ -1340,7 +1348,11 @@ export class WorktreeManager {
       if (resolve(wtSpec) === resolve(mainSpec)) return; // in-place：同一目录，无需打捞
       const salvaged = [];
       const conflicts = [];
-      const salvageTree = (subDir, reportConflict) => {
+      const archivedSkipped = [];
+      const salvagedIntoArchive = [];
+      const archivedBase = join('changes', 'archive', name);
+      const archivedBaseExists = existsSync(join(mainSpec, archivedBase));
+      const salvageTree = (subDir, reportConflict, trackArchive) => {
         const srcRoot = join(wtSpec, subDir);
         if (!existsSync(srcRoot)) return;
         const walk = (dir) => {
@@ -1349,28 +1361,50 @@ export class WorktreeManager {
             if (entry.isDirectory()) { walk(src); continue; }
             if (!entry.isFile()) continue;
             const rel = relative(wtSpec, src);
+            const rest = relative(srcRoot, src);
             const dst = join(mainSpec, rel);
+            const archivedDst = trackArchive ? join(mainSpec, archivedBase, rest) : null;
             try {
-              if (!existsSync(dst)) {
+              if (existsSync(dst)) {
+                if (reportConflict && readFileSync(src, 'utf8') !== readFileSync(dst, 'utf8')) {
+                  conflicts.push(rel);
+                }
+              } else if (archivedDst && existsSync(archivedDst)) {
+                archivedSkipped.push(rest);
+              } else if (archivedDst && archivedBaseExists) {
+                mkdirSync(dirname(archivedDst), { recursive: true });
+                copyFileSync(src, archivedDst);
+                salvagedIntoArchive.push(rest);
+              } else {
                 mkdirSync(dirname(dst), { recursive: true });
                 copyFileSync(src, dst);
                 salvaged.push(rel);
-              } else if (reportConflict && readFileSync(src, 'utf8') !== readFileSync(dst, 'utf8')) {
-                conflicts.push(rel);
               }
             } catch { /* 单文件失败不拖垮整体打捞 */ }
           }
         };
         walk(srcRoot);
       };
-      salvageTree(join('changes', name), true);
-      salvageTree('docs', false);
+      salvageTree(join('changes', name), true, true);
+      salvageTree('docs', false, false);
       if (salvaged.length > 0) {
         console.warn(`⚠️ worktree 清理前打捞：${salvaged.length} 个 spec 流程产物只存在于 worktree 副本，已复制回主仓（apply 不搬运 .sillyspec/changes，不捞即随清理蒸发）：`);
         for (const f of salvaged.slice(0, 20)) console.warn(`   ${join(mainSpec, f)}`);
         if (salvaged.length > 20) console.warn(`   …等共 ${salvaged.length} 个`);
         details.push(`salvaged ${salvaged.length} spec artifacts to main repo`);
       }
+      if (salvagedIntoArchive.length > 0) {
+        console.warn(`⚠️ worktree 清理前打捞：${salvagedIntoArchive.length} 个真独有产物（原路径与归档副本均缺）已捞进归档副本（变更已归档，原路径不重建）：`);
+        for (const f of salvagedIntoArchive.slice(0, 20)) console.warn(`   ${join(mainSpec, archivedBase, f)}`);
+        if (salvagedIntoArchive.length > 20) console.warn(`   …等共 ${salvagedIntoArchive.length} 个`);
+        details.push(`salvaged ${salvagedIntoArchive.length} spec artifacts into archive copy`);
+      }
+      if (archivedSkipped.length > 0) {
+        console.warn(`⏭️ worktree 清理前打捞：${archivedSkipped.length} 个流程产物判定为归档搬运（主仓 changes/${name}/ 原路径不存在、changes/archive/${name}/ 已有副本），跳过不复制——防复活已归档目录：`);
+        for (const f of archivedSkipped.slice(0, 20)) console.warn(`   ${join(mainSpec, archivedBase, f)}`);
+        if (archivedSkipped.length > 20) console.warn(`   …等共 ${archivedSkipped.length} 个`);
+        details.push(`skipped ${archivedSkipped.length} archived-moved spec artifacts (resurrect guard: changes/${name}/ not rebuilt)`);
+      }
       if (conflicts.length > 0) {
         console.warn(`⚠️ worktree 与主仓存在同名但内容不同的流程产物（不覆盖，请人工确认是否需要合并）：`);
         for (const f of conflicts.slice(0, 20)) console.warn(`   ${join(mainSpec, f)}`);

package/src/wt-commit.js

@@ -17,7 +17,7 @@
  *
  * 成功返回 HEAD hash（review.json 的 head 锚点直接可用）；无变更 → ok=true + skipped。
  */
-import { join, resolve } from 'node:path'
+import { join, resolve, relative, sep, basename, dirname } from 'node:path'
 import { existsSync, readFileSync } from 'node:fs'
 import { withFileLock } from './quicklog.js'
 import { safeGit } from './git-helper.js'
@@ -55,6 +55,48 @@ async function gitWithLockRetry(cwd, args, label, { retries = 6, waitMs = 1000 }
  * @returns {Promise<{ok:boolean,skipped:boolean,head:string,shortHead:string,worktreePath:string,changeName:string,files:string[]}>}
  *   ok=false 时抛错（调用方打错误 + exit 1），skipped=无变更可提交（HEAD 不动，不算失败）。
  */
+/**
+ * 从 cwd 推断变更名（wt-commit 免 --change 通道；FR-08 / D-006@v1）。
+ * 跨仓 worktree 名 <change>--<repoKey>——仅当后缀命中 repos 注册表（worktrees 上两级
+ * local.yaml）且剥出候选是已知变更目录才剥（不猜切分）；全段命中主仓已知变更不剥（防
+ * 变更真名恰以 --repoKey 结尾）；均不中 → 原样透传（现状行为，调用方自然报错引导
+ * 显式 --change）。导出供三态回归直测（index.js dispatch 内联形态不可测——独立审查指出的
+ * 验证面缺口）。
+ */
+export async function inferChangeFromWorktreeCwd(dir) {
+  // 深路径归一（FR-08）：cwd 可能在 worktree 内多层深处——specBase 推导须从 worktree 根起算。
+  // 找 'worktrees' 目录段在原路径中的位置，根 = 该段后第一段截尾；specBaseGuess = 根上溯
+  // 三级（worktrees → .runtime → .sillyspec 的父，即主仓 specBase）。
+  const s = String(dir)
+  const norm = s.split('\\').join('/')
+  const wtIdx = norm.lastIndexOf('/worktrees/')
+  let seg = null
+  let specBaseGuess = null
+  if (wtIdx !== -1) {
+    const rest = norm.slice(wtIdx + '/worktrees/'.length)
+    const rootRel = rest.split('/')[0]
+    seg = rootRel || null
+    const rootNorm = norm.slice(0, wtIdx + '/worktrees/'.length + rootRel.length)
+    specBaseGuess = rootNorm.split('/').slice(0, -3).join('/')
+  }
+  if (seg && seg.includes('--')) {
+    try {
+      if (specBaseGuess) {
+        const knownWhole = existsSync(join(specBaseGuess, 'changes', seg))
+        const dash = seg.lastIndexOf('--')
+        const cand = seg.slice(0, dash)
+        const suffix = seg.slice(dash + 2)
+        if (!knownWhole && cand && /^[A-Za-z0-9_.-]+$/.test(suffix)) {
+          const { parseRepoRegistry } = await import('./stages/plan-postcheck.js')
+          const reg = parseRepoRegistry(readFileSync(join(specBaseGuess, 'local.yaml'), 'utf8'))
+          if (reg.has(suffix) && existsSync(join(specBaseGuess, 'changes', cand))) seg = cand
+        }
+      }
+    } catch { /* 注册表不可读 → 原样透传（fail-safe） */ }
+  }
+  return seg
+}
+
 export async function runWtCommit({ changeName, message, pathspecs = [], pathspecFile = null, cwd = process.cwd() }) {
   if (!changeName) throw new Error('缺少 --change <变更名>（worktree 名；在 worktree 内运行时可省略，CLI 从 cwd 推断）')
   if (!message || !message.trim()) throw new Error('缺少 -m/--message <提交信息>（建议 "<task-NN 摘要>"）')
@@ -77,10 +119,47 @@ export async function runWtCommit({ changeName, message, pathspecs = [], pathspe
   // 隔离模式（worktree 目录存在）→ 提交目标 = worktree 本体；in-place-fallback（meta 声明无
   // worktree 直改主仓）→ 主仓根（与 MultiRepoContext 主仓 entry 的 worktreePath 兜底口径一致）。
   // 顺序先看目录再看 meta：worktree 目录存在即隔离态，meta 缺失/损坏不改变目标（fail-safe）。
+  // FR-08（2026-10-09-verify-reuse-friction / D-006@v1）：cwd 已在本变更的 worktree 内 →
+  // 提交目标=该 worktree 本体。跨仓 worktree 名 <change>--<repoKey> 不在 getWorktreePath
+  // 的主仓命名域（原路径必落「worktree 不存在」错）；主仓 worktree 场景与原值同目录零漂移。
+  // 归属校验（不猜）：worktree 根段 === changeName，或 === changeName--<注册repoKey>（repos
+  // 注册表读自 worktreeBase 上两级的 local.yaml；注册表不可读 → 只认精确名，fail-safe）。
   let target = null
-  if (existsSync(worktreePath)) {
+  {
+    // 基座发现（目录事实）：优先 wm.worktreeBase（主仓）；cwd 不在其下时向上找名为 worktrees
+    // 的目录作基座（跨仓 worktree 是跨仓仓的 git worktree，WorktreeManager 从其 cwd 算不出
+    // 主仓基座——跨仓 worktree 的父目录本身就是 worktrees 基座）。
+    let base = resolve(wm.worktreeBase)
+    {
+      let d = resolve(cwd)
+      for (;;) {
+        if (dirname(d) === base) break
+        const parent = dirname(d)
+        if (basename(parent) === 'worktrees') { base = parent; break }
+        if (parent === d) break
+        d = parent
+      }
+    }
+    const cwdAbs = resolve(cwd)
+    if (cwdAbs.startsWith(base + sep)) {
+      const wtRoot = relative(base, cwdAbs).split(sep)[0]
+      let own = wtRoot === changeName
+      if (!own && wtRoot.startsWith(changeName + '--')) {
+        const suffix = wtRoot.slice(changeName.length + 2)
+        if (suffix && /^[A-Za-z0-9_.-]+$/.test(suffix)) {
+          try {
+            const { parseRepoRegistry } = await import('./stages/plan-postcheck.js')
+            const reg = parseRepoRegistry(readFileSync(join(base, '..', '..', 'local.yaml'), 'utf8'))
+            own = reg.has(suffix)
+          } catch { own = false }
+        }
+      }
+      if (own && existsSync(join(base, wtRoot))) target = join(base, wtRoot)
+    }
+  }
+  if (!target && existsSync(worktreePath)) {
     target = worktreePath
-  } else {
+  } else if (!target) {
     const meta = wm.getMeta(changeName)
     if (meta && meta.mode === 'in-place-fallback') {
       target = resolve(wm.worktreeBase, '..', '..', '..') // <main>/.sillyspec/.runtime/worktrees → <main>

package/.claude/skills/sillyspec-quick/SKILL.md

@@ -1,116 +0,0 @@
----
-name: sillyspec:quick
-description: 用于明确、低风险、范围很小的直接任务。适合用户说"直接改、快速修、顺手调整、改个文案、修个小 bug、更新一个文件、不要完整流程"。跳过 brainstorm/plan，但仍按 sillyspec quick 流程执行。
----
-
-## 何时使用
-
-- 明确、低风险、范围小的直接修改：改文案、修小 bug、更新单个文件
-- 用户说"直接改、快速修、顺手调整、不要完整流程"
-- brainstorm 判定 `scale=small` 的变更：带 design.md 进 quick（`sillyspec run quick --linked-changes <变更名>`），design 当背景
-- 跳过 brainstorm/plan，但仍走 quick 的 3 步流程（理解任务 → 实现 → 自检提交）
-
-## 多变更说明（quick 特殊，务必注意）
-
-quick 阶段的 `--change` 语义是「关联变更」**且会触发步骤重置**，**不要用 `--change` 来指定关联变更**。多活跃变更时改用：
-
-- `--linked-changes none`：不关联，仅记 QUICKLOG（CLI 启动时写入）
-- `--linked-changes a,b`：显式关联到变更 a、b
-- `--non-interactive`：CI/脚本环境，默认不关联（避免交互 prompt 崩溃）
-
-首次 `sillyspec run quick` 选定的关联会持久化到 `.runtime/quick-sessions/<quick-session-id>/guard.json`（每个 quick 会话独立，多会话并发不互覆盖），后续 `--done` 自动复用，**不会重复弹交互 prompt**。
-
-## 步骤生命周期（所有阶段通用）
-
-> `sillyspec quick` 是 `sillyspec run quick` 的顶层别名，两者等价。
-
-```bash
-sillyspec run quick                            # 输出当前步骤 prompt（首次会记录 baseline）
-sillyspec run quick --done --output "摘要"     # 完成当前步骤
-sillyspec run quick --status                   # 查看阶段进度
-sillyspec run quick --skip                     # 跳过可选步骤
-sillyspec run quick --reset                    # 重置阶段（从头开始）
-sillyspec run quick --reopen --from-step N     # 重新打开已完成阶段修订（N=序号或名称）
-```
-
-### 已有进行中会话的恢复（sessionId）
-
-`sillyspec run quick` / `run quick --done` / `--status` **不带 `--change` 时，是启动一个新 quick 会话**（CLI 分配新 `quick-<hash>` + 新 ql-ID，QUICKLOG 追加「进行中」条目），不是恢复正在进行的旧会话。多会话并发或中断恢复时，必须带上启动时 CLI 打印的 sessionId：
-
-```bash
-sillyspec run quick --change quick-<hash>        # 恢复查看该会话当前 step prompt
-sillyspec run quick --done --change quick-<hash> --output "…"  # 完成该会话步骤
-```
-
-- 这里的 `--change quick-<hash>` 是「恢复到该 CLI 生成的 session」，与下方 `--linked-changes` 的关联业务变更语义不同：想关联真实业务变更才用 `--linked-changes`。
-- 误启动的空壳会话：`sillyspec run quick --cancel --change quick-<hash>` 一键取消（QUICKLOG 条目翻「已取消」+ tasks.md 挂载行移除 + 会话目录清理 + db 行注销；已完成/已勾选的拒绝取消）。
-
-## 通用参数（所有阶段适用）
-
-| 参数 | 说明 |
-|---|---|
-| `--spec-dir <path>` | 指定规范目录（默认 `<项目>/.sillyspec`） |
-| `--input "<一句话任务描述>"` | 通用参数，**quick 启动时强烈建议带**：作为 QUICKLOG 条目标题，条目从第一分钟即语义可读。不带则落「(quick 任务)」占位标题——平台「快速修复」列表默认隐藏进行中的占位条目，语义标题要到最终 `--done` 才回填（关联变更有 proposal/design 标题时可自动提取，免传） |
-| `--non-interactive` | CI/脚本下禁用交互式 prompt |
-| `--interactive` | 强制交互（即便 stdin 非 TTY） |
-| `--skip-approval` | 跳过阶段转换/审批检查（不能跳产物校验 gate——review.json/文档产物硬校验仍在） |
-
-## quick 特有参数
-
-| 参数 | 说明 |
-|---|---|
-| `--linked-changes none\|a,b` | **显式关联变更（取代 `--change`，推荐）**。none=不关联，a,b=关联列表 |
-| `--files a.js,b.js` | 显式声明本次允许修改的文件（边界保护 + 声明即归属：多 agent 并发仓防他者窗口文件混入 QUICKLOG 文件行，未声明窗口文件进「审计：」行追溯；**他向亦然**——其他 active 会话已声明的文件在你的 `--done` 审计中自动剔除归该会话，不再误拦、无需 `--force-baseline`）。**中途可追加**：发现要改声明外文件（如新写的测试）时，带新增文件恢复会话即并入边界（追加不替换）——`sillyspec run quick --files <新增> --change <sessionId>`；不带 `--files` 恢复则边界原样保留 |
-| `--file-notes "p::注 \|\| p::注"` | quick `--done` 用：QUICKLOG「文件：」行落盘为多行带括注 bullet（省事后手改文件行）。格式 `path::括注`，`\|\|` 分隔多条；**只随 step3 --done 同命令传**（CLI 短进程，step1/step2 传无效，不带到 step3） |
-| `--allow-new` | 允许新增文件（默认禁止，防意外创建） |
-| `--allow-delete` | 允许删除文件（默认 fail-closed，删除是破坏性操作；确认删除带此 flag 显式解锁） |
-| `--force-baseline` | 允许覆盖 baseline 受保护文件 / 压制 `.sillyspec/` 危险判定（危险，慎用） |
-| `--confirm` | ⚠️ 仅打印变更概览，**不解锁 blocked**（blocked 仍 exit 1）。真正解锁用 `--force-baseline`/`--allow-new`/`--allow-delete` |
-
-## 审计与并发变更（`--done` 边界审计）
-
-`--done` 收尾时对比 step1 baseline 与当前 `git status`，拦「危险文件 / 新增文件 / 覆盖 baseline」。要点：
-
-- **并发其他会话的 `.sillyspec/changes/<非关联变更>/` 不再被本 quick 拦截**。quick 自己没有 `changes/` 目录，该路径下非关联内容视为并发会话的工作，整体放行（确定性审计无法区分「并发工作」与「本 quick 偷建变更」，后者这类意图软判定留给 sillyhub）。
-- **其他 active 会话已声明的文件自动豁免（`--files` 的他向语义）**。多 agent 并发时，并行 quick 会话 `--files` 显式声明的文件（如它的 `daemon/router.py`）出现在你的窗口内（它在你启动后改的、不在你的 baseline）——`--done` 审计自动剔除归该会话边界管，不再判危险 BLOCK、无需 `--force-baseline`。放行可见：输出 🔗 软警告逐文件列归属会话；若确系你的改动，恢复会话时 `--files` 追加声明；超 7 天未收尾的僵尸会话声明自动失效（`sillyspec run quick --cancel --change <他者会话ID>` 清理）。豁免只认他者**显式声明**——未声明的他者文件照旧走各门判定（漏声明的补 `--files`，危险文件仍需 `--force-baseline`）。
-- **关联变更的文件仍走审计**：reverse-sync 改自己关联变更的 `design.md` 会被拦，需 `--force-baseline` 显式确认。
-- **baseline 折叠目录前缀匹配**：step1 启动时整片 `changes/` 未跟踪会被 git 折叠成 `?? .sillyspec/changes/`（带尾斜杠 token）；审计时若该目录下文件被并发会话跟踪而展开成文件级路径，按尾斜杠 token 前缀放行其下所有文件，不误判。
-- **同文件并发 warn（advisory，不阻断）**：step1 启动时若你的某个 `allowedFile` 已在他者脏文件列表里（他者也改了这文件），--done 时 CLI 会比对当前内容 hash 与启动时录入的 hash——不一致（你也改了它）即判「同文件并发」并 warn：整文件 pathspec 提交会夹带他者 hunk。warn 给出分离指引（`git add -p <file>` 交互选你自己的 hunk，或 `git diff <file> > mine.patch` 编辑后 `git apply --cached mine.patch` 再 commit）。这**不阻断** --done（你可能有意整文件提交），看 warn 后自行决定是否分离。
-- **`--confirm` ≠ 解锁**：它只打印概览。blocked 时真正解锁的是 `--force-baseline`（压制 `.sillyspec/` 危险判定 + baseline 覆盖）/`--allow-new`（放行新增）/`--allow-delete`（放行删除，删除是破坏性操作默认 fail-closed，须显式 opt-in），三者可在 step1 或 `--done` 传，都生效。
-
-## 典型用法
-
-```bash
-# 推荐启动：带一句话语义标题（QUICKLOG/平台快速修复列表进行中即可见可读）
-sillyspec run quick --input "修复登录限流 INCR 计数误清" --linked-changes none --files src/auth.ts
-
-# 单变更项目，直接开始
-sillyspec run quick
-
-# 多变更项目，显式不关联
-sillyspec run quick --linked-changes none
-
-# 多变更项目，关联到指定变更
-sillyspec run quick --linked-changes 2026-07-03-add-login
-
-# CI/脚本（非交互，避免 prompt 崩溃）
-sillyspec run quick --non-interactive
-sillyspec run quick --done --linked-changes none --output "修复手机号校验"
-
-# 限定修改文件范围
-sillyspec run quick --files src/phone.ts,src/phone.test.ts
-```
-
-## 铁律
-
-- **必须用 exec 工具（shell）执行 CLI，不要自己编造流程**
-- quick 直接在主工作区改代码（不创建 worktree），范围必须小且明确
-- 完成后立即 `--done`，不跳过
-- QUICKLOG 记录的**骨架由 CLI 接管**：启动时 CLI 自动分配 ql-ID 并在 `.sillyspec/quicklog/QUICKLOG-<user>.md` 写「进行中」条目（含关联变更 tasks.md），`--done` 时 CLI 自动翻「已完成」+ 勾选 task + 回填文件路径。ql-ID 分配/状态/task 你无需手写，只需用注入的 `<quicklog-id>` 在模块文档变更索引引用
-- **QUICKLOG 落盘已结构化（`--done` 后按需核对，多数无需手改）**：CLI 已落盘结构化条目——标题从 `--output` 的「需求：」自动提取、正文四字段自动分行、文件行用 `--file-notes` 时为多行带括注。`--done` 后只需核对：标题弱才改（禁留 `(quick 任务)` 占位）；没用 `--file-notes` 时文件行是单行、可事后补括注（参照同文件早期丰富条目）；正文 `需求：`/`根因：`/`方案：`/`结果：` 四段按需充实（禁只留一段「结果：」）。一条 quick = 一条独立 ql，不追加到旧条目
-- **收尾顺序（模块文档在 `--done` 前，QUICKLOG 在 `--done` 后，别记混）**：① 命中模块→改模块文档→`git add`；② `sillyspec run quick --done --change <id> --output "四字段" [--file-notes "..."]`（CLI 自动翻完成 + 勾 task + 落盘 QUICKLOG 标题/文件/正文；若 `--linked-changes` 关联的真实变更其 tasks.md 已全部勾选**且该变更未进入完整流程**（进度库阶段停在 brainstorm 及之前），CLI 会自动将其归档到 `changes/archive/`；已走到 plan/execute/verify/archive 的变更不自动归档（tasks.md 全勾不等于流程收尾），须走原流程收尾）；③ 核对 QUICKLOG 标题（CLI 已从「需求：」提取并截断，写成短标题则无需改）→若改了再 `git add`
-- **最后一步 `--done` 必须给全四字段**（逐项一句话）：🔧 **推荐四参数形式**（CLI 自动合成结构化模板，无格式事故面）：`--done --change <id> --req "一句语义化短标题" --cause "为什么改" --solution "怎么改的" --result "验证结果"`。兼容旧形式 `--output "需求：… 根因：… 方案：… 结果：…"`（手拼须懂截断规则、禁嵌套全角冒号，缺字段被拒 exit 1）。这是 QUICKLOG「结果：」归档的唯一来源。**`--req` 写一句语义化短标题**（写「改了什么」，如「登录限流修复——INCR 计数误清」）——CLI 把它提取为 QUICKLOG 条目标题，截到首个标点、超 80 字截断；写完整需求长句会被截成语义不完整的状语前半段，需求背景放 `--cause`/`--solution`。前两个 step 的 `--output` 是中间摘要，不用此模板
-- **禁止**在没有运行 CLI 的情况下自行决定流程
-
-## 用户指令
-$ARGUMENTS

package/assets/command-cards/run-quick.md

@@ -1,20 +0,0 @@
----
-name: sillyspec:run-quick
-description: 已退役重定向 — quick 通道已拒绝新会话（v3.31.0 起），小修补请用 /sillyspec:flow
----
-# 通道已退役
-
-quick 通道已于 v3.31.0 直接退役：`sillyspec run quick` 对新会话一律拒绝（exit 1 并指路 flow start）。本卡只保留触发词重定向，勿执行任何 quick 新会话命令。
-
-范围明确的小修补请走**轻量变更**（/sillyspec:flow）：
-
-```bash
-sillyspec flow start --change <变更名> --input "<动机与背景>
-
-成功标准：
-- <可验证标准>"
-# → 直接干活（改代码写测试，治理工件 CLI 机器起草）
-sillyspec flow done --change <变更名>
-```
-
-升级前遗留的在途 quick 会话仍可收尾：`sillyspec run quick --change <会话ID>` 续跑 / `--done` 收口 / `--cancel` 取消（以 CLI 拒绝文案里的指引为准）。