sillyspec 3.30.0 → 3.32.0

package/src/modules.js

@@ -452,6 +452,8 @@ export function parseModuleMapSimple(content) {
   let currentArray = null;
 
   for (const line of content.split('\n')) {
+    // 空行/注释行：保状态（列表块内允许空行与注释穿插——结构守卫前的免死金牌）
+    if (line.trim() === '' || line.trim().startsWith('#')) continue;
     // 模块 id 字符集含点（db.engine 等，与 module-impact.js classifyFile 同口径）：
     // 不含点时带点 id 的条目被静默丢弃，上下文注入/scan-diff 侧与 module-impact 侧给相反结论
     const moduleMatch = line.match(/^  ([a-zA-Z0-9_.\-]+):$/);
@@ -501,6 +503,13 @@ export function parseModuleMapSimple(content) {
       currentArray.push(itemMatch[1].trim());
       continue;
     }
+
+    // 结构守卫（坑 module-map-list-leak，2026-10-06-wallclock-entry 实测发现）：list 收集只在
+    // 「6 缩进项行 / 空行 / 注释」上存活，其余任何行——未知字段头（字段名开放集，不枚举；
+    // 枚举白名单外的字段头此前不重置收集，其列表项漏进上一个 list 字段如 paths）、顶层段
+    // （span_risk:/blast:）、异缩进项——终结收集并落盘已收集项。字段名识别仍按白名单（语义面），
+    // 收集边界按行结构（开放世界安全）。
+    if (currentArray && currentKey) { modules[currentModule][currentKey] = currentArray; currentArray = null; currentKey = null; }
   }
 
   // Flush last

package/src/progress/change-registry.js

@@ -222,6 +222,26 @@ export class ChangeRegistry {
     }
   }
 
+  /**
+   * 读变更标题（2026-10-06-flow-status-title：flow status 显示面消费——flow start/--title 写入侧
+   * 的对读）。只读不抛（与 getChangeOwner 同族容错）：DB 文件不在场/行缺失/title 空/读取失败 → null。
+   * 前置 existsSync 判 DB 在场——只读查询路径不得经 _ensureDB 的建库副作用新建 sillyspec.db。
+   * @param {string} cwd
+   * @param {string} changeName
+   * @returns {string|null} 变更标题，无值返回 null
+   */
+  getChangeTitle(cwd, changeName) {
+    if (!changeName) return null;
+    try {
+      if (!existsSync(this.pm._runtimePath(cwd, 'sillyspec.db'))) return null;
+      const db = this.pm._ensureDB(cwd);
+      const row = db.getDb().prepare('SELECT title FROM changes WHERE name = ?').get(changeName);
+      return (row && typeof row.title === 'string' && row.title) || null;
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * 认领变更所有权（2026-09-14-change-ownership-guards task-01 数据载体）：
    * - 行不存在 → 创建并写 owner=session（首建者获得）；

package/src/progress/stage-machine.js

@@ -6,6 +6,7 @@
 import { mkdirSync, existsSync, readdirSync, readFileSync } from 'fs';
 import { join, resolve, basename } from 'path';
 import { writeAtomicSync } from '../fs-atomic.js';
+import { timeAgo } from '../datetime.js';
 import { runValidators } from '../stage-contract.js';
 import { QUICK_SID_RE } from '../run/shared.js';
 import { VALID_STAGES, STAGE_LABELS, STAGE_ORDER, MAIN_FLOW_ORDER, SPEC_DIR_NAME, CURRENT_VERSION, STALL_WARN_DAYS, emptyStage } from './shared.js';
@@ -831,13 +832,9 @@ export class StageMachine {
   _timeAgo(dateStr) {
     const ts = _parseFlexibleTs(dateStr);
     if (ts === null) return dateStr || '未知';
-    const diff = Date.now() - ts;
-    const minutes = Math.floor(diff / 60000);
-    if (minutes < 1) return '刚刚';
-    if (minutes < 60) return `${minutes} 分钟前`;
-    const hours = Math.floor(minutes / 60);
-    if (hours < 24) return `${hours} 小时前`;
-    return `${Math.floor(hours / 24)} 天前`;
+    // 档位换算委托 datetime.timeAgo（单源）；zh-CN 旧格式容错解析与失败回退留在调用方
+    // ——是对本模块存量 lastActive 数据的展示职责（2026-10-06-datetime-timeago 收敛）。
+    return timeAgo(ts);
   }
 }
 

package/src/progress.js

@@ -582,7 +582,7 @@ export class ProgressManager {
 
     // 1. changes 行（投影流程进度列 + name 标识 + 所有权列 owner_session）
     const changeRow = sqlDb.prepare(
-      `SELECT id, name, current_stage, status, last_active, last_synced_platform_ts, last_local_modified_ts, owner_session
+      `SELECT id, name, current_stage, status, last_active, last_synced_platform_ts, last_local_modified_ts, owner_session, title
        FROM changes WHERE name = ?`
     ).get(changeName);
     if (changeRow === undefined) return null;
@@ -595,6 +595,10 @@ export class ProgressManager {
       last_synced_platform_ts: changeRow.last_synced_platform_ts ?? null,
       last_local_modified_ts: changeRow.last_local_modified_ts ?? null,
       owner_session: changeRow.owner_session ?? null,
+      // title 一并上行（用户需求 2026-09-29：变更标题为中文概括 ≤50 字）——平台
+      // _ensure_change_row 占位与既有行收养均消费 changes[].title；此前 SELECT 漏列
+      // → 上行恒无标题，平台只能落 change_key（「英文 key」病灶的同步链一侧）。
+      title: changeRow.title ?? null,
     };
 
     // 2. project 全局单行（只投影稳定字段 name/schema_version；created_at/updated_at 是本地库元数据，
@@ -1084,6 +1088,9 @@ export class ProgressManager {
   /** 读变更所有者会话标识；无行/未登记/无主 → null */
   getChangeOwner(cwd, changeName) { return this._changeRegistry.getChangeOwner(cwd, changeName); }
 
+  /** 读变更标题（2026-10-06-flow-status-title）：纯读不抛、无 DB 不建库，缺值 → null */
+  getChangeTitle(cwd, changeName) { return this._changeRegistry.getChangeTitle(cwd, changeName); }
+
   /** 认领所有权：首建写 own、已有值不覆盖；返回实际 owner（string|null） */
   claimChangeOwner(cwd, changeName, session) { return this._changeRegistry.claimChangeOwner(cwd, changeName, session); }
 

package/src/quicklog.js

@@ -118,6 +118,26 @@ export function sanitizeDesc(description) {
   return s.length > 120 ? s.slice(0, 120) + '…' : s
 }
 
+/**
+ * 变更标题推导（用户需求 2026-09-29：changes.title 应为中文描述，≤50 字、建议 ~20 字）。
+ * 取 --input 首个非空行（「成功标准：」引导行即止——那是验收面不是标题素材），剥
+ * 「需求：/动机：」类标签前缀，空白折叠单行，超长截断加 …；空输入返回 ''（调用方兜底
+ * change 名）。agent 在 --input 首行写一句中文概括即成标题（flow start 横幅有指引），
+ * --title 显式覆盖一切推导。
+ */
+export function deriveChangeTitle(input, max = 50) {
+  for (const l of String(input || '').replace(/\r\n/g, '\n').split('\n')) {
+    const t = l.trim()
+    if (!t) continue
+    if (/^成功标准\s*[:：]/.test(t)) break
+    const stripped = t.replace(/^(?:需求|动机|背景|任务|标题)\s*[:：]\s*/, '').trim()
+    if (!stripped) continue
+    const one = stripped.replace(/\s+/g, ' ')
+    return one.length > max ? one.slice(0, max) + '…' : one
+  }
+  return ''
+}
+
 
 // ── 平台推送（best-effort，2026-08-16-change-center-quick-tab task-06 / D-003）──
 

package/src/redomain.js

@@ -47,13 +47,23 @@ function newDomainPreamble(domain) {
   ]
 }
 
+/** 条目段「变更：<名>」行提取（--by-change 分批迁移的过滤键，坑 fr-domain-suggest 缺陷2） */
+function entrySourceChange(sectionLines) {
+  for (const l of sectionLines) {
+    const m = /^变更：(.+)$/m.exec(String(l || '').trim())
+    if (m) return m[1].trim()
+  }
+  return null
+}
+
 /**
  * 执行迁移（纯函数式落盘）。
- * @param {{knowledgeRoot: string, from: string, to: string, anchors?: string[]}} opts
+ * @param {{knowledgeRoot: string, from: string, to: string, anchors?: string[], byChange?: string}} opts
+ *   byChange：仅迁「变更：<名>」字段匹配的条目（unmapped 等混合池按来源变更分批治理）。
  * @returns {{moved: Array<{id,title}>, sourceDeleted: boolean, targetCreated: boolean, indexLineAdded: boolean}}
  * @throws 源域缺席 / 无匹配条目 / anchor 未命中
  */
-export function redomainFrEntries({ knowledgeRoot, from, to, anchors = null }) {
+export function redomainFrEntries({ knowledgeRoot, from, to, anchors = null, byChange = null }) {
   const frDir = join(knowledgeRoot, 'fr')
   const fromPath = join(frDir, `${from}.md`)
   const toPath = join(frDir, `${to}.md`)
@@ -75,10 +85,13 @@ export function redomainFrEntries({ knowledgeRoot, from, to, anchors = null }) {
     const id = frEntryId(s.lines[0] || '')
     if (!id) { staying.push(s); continue } // 非条目段（说明/杂项）留守
     if (anchorSet && !anchorSet.has(id)) { staying.push(s); continue }
+    if (byChange && entrySourceChange(s.lines) !== byChange) { staying.push(s); continue }
     moving.push({ id, title: (FR_HEADER_RE.exec(s.lines[0])?.[2] || '').trim(), section: s })
   }
   if (moving.length === 0) {
-    throw new Error(anchorSet ? `anchor 未命中（${[...anchorSet].join('、')} 不在 fr/${from}.md）` : `fr/${from}.md 无 FR 条目段`)
+    throw new Error(anchorSet
+      ? `anchor 未命中（${[...anchorSet].join('、')} 不在 fr/${from}.md）`
+      : byChange ? `「变更：${byChange}」条目在 fr/${from}.md 无命中` : `fr/${from}.md 无 FR 条目段`)
   }
   if (anchorSet && moving.length !== anchorSet.size) {
     const got = new Set(moving.map((m) => m.id))
@@ -119,8 +132,8 @@ export function redomainFrEntries({ knowledgeRoot, from, to, anchors = null }) {
   }
 }
 
-/** 干跑预览：列出将迁移条目，不落盘 */
-export function planRedomain({ knowledgeRoot, from, to, anchors = null }) {
+/** 干跑预览：列出将迁移条目，不落盘（byChange 同执行侧过滤） */
+export function planRedomain({ knowledgeRoot, from, to, anchors = null, byChange = null }) {
   const frDir = join(knowledgeRoot, 'fr')
   const fromPath = join(frDir, `${from}.md`)
   if (!existsSync(fromPath)) throw new Error(`源域文件不存在：fr/${from}.md`)
@@ -132,10 +145,13 @@ export function planRedomain({ knowledgeRoot, from, to, anchors = null }) {
     const id = frEntryId(s.lines[0] || '')
     if (!id) continue
     if (anchorSet && !anchorSet.has(id)) continue
-    candidates.push({ id, title: (FR_HEADER_RE.exec(s.lines[0])?.[2] || '').trim() })
+    if (byChange && entrySourceChange(s.lines) !== byChange) continue
+    candidates.push({ id, title: (FR_HEADER_RE.exec(s.lines[0])?.[2] || '').trim(), sourceChange: entrySourceChange(s.lines) })
   }
   if (candidates.length === 0) {
-    throw new Error(anchorSet ? `anchor 未命中（${[...anchorSet].join('、')}）` : `fr/${from}.md 无 FR 条目段`)
+    throw new Error(anchorSet
+      ? `anchor 未命中（${[...anchorSet].join('、')}）`
+      : byChange ? `「变更：${byChange}」条目在 fr/${from}.md 无命中` : `fr/${from}.md 无 FR 条目段`)
   }
   return {
     from,

package/src/route-hindsight.js

@@ -0,0 +1,276 @@
+/**
+ * route-hindsight.js — 轻量道「疑似该走预段未走」事后闭环（2026-09-28-unclear-req-to-brainstorm FR-02）。
+ *
+ * 三层分工中的后门层：前门盘问（flow.js 渲染）管入口弱信号，本模块管收口事后指标——
+ * flow done 收口时计算过程形态指标，任一超阈即标记落库，下次 flow start 点名提示
+ * （「疑似」非定罪、可无视），形成 per-repo 自校准回路。
+ *
+ * D-003 禁区（rejected 决策，逐字遵守）：全部指标为封闭面——行级 diff 比例与记录计数，
+ * 零关键词/词表语义判定。需求清不清晰的判定归 agent，机器只产过程形态信号（D-005 弱信号）。
+ *
+ * 数据面（均 .runtime 下，跨平台 join + 原子写）：
+ *   - 首版快照 route-hindsight-baseline-<change>.json：start/adopt 机器稿首次落盘后由
+ *     flow.js 调 snapshotBaseline 存 design.md/tasks.md 全文副本；首写者胜（幂等，R-04：
+ *     快照锚定起草时点，重入不覆盖）。
+ *   - 标记文件 route-hindsight.json：per-repo 单条，每次标记整文件覆盖——提示语义即
+ *     「上个轻量变更」。
+ *
+ * 指标四元组（口径）：
+ *   designRewriteRatio / tasksRewriteRatio：终稿 vs 首版快照的行级改写比——复用
+ *     flow-draft.computeEditRatio 同款 LCS 口径（改写行/首版行数，纯增行不计入；CRLF/LF
+ *     归一后比对）。diff 面先做结构归一：剔 frontmatter 块、HTML 注释标记行（<!--）、空行
+ *     ——惰性脚手架行（机器稿里约占半数）会把真实换血稀释到阈值以下（实测整写机器段仅得
+ *     0.175-0.275，0.5 阈值永不可达=闭环失效面）；归一是纯结构过滤零语义判定（D-003）。
+ *     tasks 面另做勾选框状态归一（normalizeTaskCheckbox：[x]/[X]→[ ]——v2 镜像任务行
+ *     翻格是进度簿记非内容改写，2026-10-05-hindsight-checkbox-noise 修复前全勾即 N/(N+1)
+ *     恒超阈）；design 面不归一。无快照（旧变更/起草失败）= 0（零信号，不是「实测 0% 改写」）。
+ *   blindDims：收口评审 review.json 的 dimensionNotes 中值为 'finding' 的维数——枚举值
+ *     计数（评审员已按任务书 schema 判定的结构化面），非机器语义判定；无 review.json
+ *     （评审豁免）= 0。
+ *   testFailures：.runtime/verify-runs/<ts>/test-result.json 记录面中 change 归属本变更且
+ *     status='failed' 的实测失败次数——每次失败收口尝试各落一条（writeRunResult 既有面）。
+ *     flow-state substeps 无失败计数面（执行期裁决 D-006：数据源从卡面所述「flow-state
+ *     substeps」改读同为既有记录面的 verify-runs 时间线，封闭面语义不变）。
+ */
+import { existsSync, readFileSync, readdirSync, mkdirSync } from 'node:fs'
+import { createHash } from 'node:crypto'
+import { join, basename, dirname } from 'node:path'
+import { writeAtomicSync } from './fs-atomic.js'
+import { computeEditRatio } from './flow-draft.js'
+
+/** 超阈判定常量（可调；口径：比例两路为严格大于——恰等于阈值不算超，保守防误标 R-01；
+ * 计数两路为大于等于——2 维/2 次即系统性信号）。 */
+export const HINDSIGHT_THRESHOLDS = {
+  designRewriteRatio: 0.5, // design 机器稿改写比 > 0.5（50% 首版行被改写）
+  tasksRewriteRatio: 0.6,  // tasks 机器预填稿改写率 > 0.6
+  blindDims: 2,            // 评审盲维命中（dimensionNotes='finding'）≥ 2 维
+  testFailures: 2,         // 收口实测失败记录 ≥ 2 次
+}
+
+const BASELINE_PREFIX = 'route-hindsight-baseline-'
+const MARK_FILE = 'route-hindsight.json'
+
+/** CRLF/LF 归一（Windows/Linux/macOS 换行兼容——未归一的行比对会把换行差异计成改写）。 */
+function norm(text) {
+  return String(text || '').replace(/\r\n/g, '\n')
+}
+
+/** diff 面结构归一：剔 frontmatter 块、HTML 注释标记行（<!-- 机器段/槽标记）、空行、
+ *  引导行（> 起头——v2 纯 markdown 起草的头注指引是惰性脚手架，与 v1 由 MACHINE-DRAFT
+ *  段剔除覆盖同职责；不剔会把改写比稀释到阈下，2026-10-04-thin-docs-v2 实证）——
+ *  只留正文行（惰性脚手架行不稀释改写比；纯结构过滤，零语义判定）。 */
+function contentSurface(text) {
+  const lines = norm(text).split('\n')
+  const out = []
+  let fmOpen = false, fmDone = false
+  for (let i = 0; i < lines.length; i++) {
+    const l = lines[i]
+    if (!fmDone) {
+      if (i === 0 && l === '---') { fmOpen = true; continue }
+      if (fmOpen) { if (l === '---') { fmOpen = false; fmDone = true } continue }
+      fmDone = true // 首行非 ---：无 frontmatter 的裸文本，全行入面
+    }
+    if (l.startsWith('<!--')) continue
+    if (l.startsWith('>')) continue
+    if (l.trim() === '') continue
+    out.push(l)
+  }
+  return out.join('\n')
+}
+
+/** tasks 勾选框状态归一：行首 `- [x]`/`- [X]`/`- [ ]` → `- [ ]`（仅 tasks 比对面消费——
+ *  v2 镜像任务行翻格（勾选）是进度簿记不是内容改写，2026-10-05 四变更实测全勾即 N/(N+1)
+ *  恒超 0.6 阈误标「疑似该走预段」；纯结构 token 替换，D-003 封闭面零语义判定）。 */
+function normalizeTaskCheckbox(text) {
+  return norm(text).replace(/^(\s*[-*]\s+)\[[ xX]\]/gm, '$1[ ]')
+}
+
+function readTextSafe(p) {
+  try { return readFileSync(p, 'utf8') } catch { return null }
+}
+
+function round4(x) {
+  return Math.round(x * 10000) / 10000
+}
+
+function num(v) {
+  const n = Number(v)
+  return Number.isFinite(n) ? n : 0
+}
+
+/**
+ * 首版快照：机器稿起草时点（start 的 draftAll / adopt·resume 的 redraftMissingArtifacts
+ * 首次落盘后）由 flow.js 调用。首写者胜——已存在不覆盖（重入/续跑取到的都是首版，R-04）。
+ * 缺件（起草失败的文件）存 null，指标面按零信号处理。
+ * @returns {{ captured: boolean, path?: string, reason?: string }}
+ */
+export function snapshotBaseline({ specBase, change, changeDir }) {
+  try {
+    const runtimeRoot = join(specBase, '.runtime')
+    const p = join(runtimeRoot, `${BASELINE_PREFIX}${change}.json`)
+    if (existsSync(p)) return { captured: false, reason: 'already-exists（首写者胜）' }
+    const payload = {
+      schemaVersion: 1,
+      change,
+      capturedAt: new Date().toISOString(),
+      design: readTextSafe(join(changeDir, 'design.md')),
+      tasks: readTextSafe(join(changeDir, 'tasks.md')),
+    }
+    mkdirSync(runtimeRoot, { recursive: true })
+    writeAtomicSync(p, JSON.stringify(payload, null, 2) + '\n')
+    return { captured: true, path: p }
+  } catch (e) {
+    return { captured: false, reason: (e && e.message) || String(e) }
+  }
+}
+
+/**
+ * 基线文件 sha256（2026-09-28-sentinel-waiver-hardening：flow-state 锚定用——start/adopt 快照
+ * 时点记哈希，哨兵消费时校验，防 .runtime 明文基线被事后改写伪装镜像）。缺文件 → null。
+ */
+export function baselineSha256({ specBase, change }) {
+  try {
+    const p = join(specBase, '.runtime', `${BASELINE_PREFIX}${change}.json`)
+    if (!existsSync(p)) return null
+    return createHash('sha256').update(readTextSafe(p)).digest('hex')
+  } catch {
+    return null
+  }
+}
+
+/**
+ * 机器稿基线读取面退役（2026-10-07-thin-tasks-v3）：哨兵镜像豁免与收口代勾下线后，
+ * readBaselineTasks/readBaselineTasksVerified（哨兵侧判别源）零消费删除——基线快照本体
+ * （snapshotBaseline/baselineSha256）保留，供 hindsight 改写比指标（computeHindsightMetrics
+ * 直读快照 JSON）与 flow-state 锚定。
+ */
+
+/**
+ * 收口指标计算（封闭面：只读文件与既有记录，无语义判定）。
+ * @param {{ changeDir: string, reviewJson: object|null, flowState: object|null }} p
+ *   changeDir 布局=<specBase>/changes/<change>（specBase 与 change 名据此派生）；
+ *   reviewJson=flow done 评审子步已校验的 review.json 解析对象（豁免时 null）；
+ *   flowState=flow-state 对象（仅随 raw 记录，不参与判定）。
+ * @returns {{ designRewriteRatio: number, tasksRewriteRatio: number, blindDims: number, testFailures: number, raw: object }}
+ */
+export function computeHindsightMetrics({ changeDir, reviewJson, flowState }) {
+  const raw = { baselinePresent: false }
+  const change = basename(changeDir)
+  const specBase = dirname(dirname(changeDir))
+
+  // ① 首版快照 → 终稿行级改写比
+  let designRewriteRatio = 0
+  let tasksRewriteRatio = 0
+  const baselineRaw = readTextSafe(join(specBase, '.runtime', `${BASELINE_PREFIX}${change}.json`))
+  let baseline = null
+  if (baselineRaw != null) { try { const j = JSON.parse(baselineRaw); baseline = j && typeof j === 'object' ? j : null } catch { baseline = null } }
+  if (baseline) {
+    raw.baselinePresent = true
+    const pairs = [['design', 'designRewriteRatio'], ['tasks', 'tasksRewriteRatio']]
+    for (const [key, outKey] of pairs) {
+      // tasks 面比对前先勾选框归一（翻格=簿记非改写）；design 面不归一（无此形态，保原口径）
+      const pre = key === 'tasks' ? normalizeTaskCheckbox : (t) => t
+      const first = typeof baseline[key] === 'string' ? contentSurface(pre(baseline[key])) : null
+      const finalText = readTextSafe(join(changeDir, `${key}.md`))
+      if (first && finalText != null) {
+        const surface = contentSurface(pre(finalText))
+        const ratio = round4(computeEditRatio(first, surface))
+        if (outKey === 'designRewriteRatio') designRewriteRatio = ratio
+        else tasksRewriteRatio = ratio
+        raw[`${key}BaselineLines`] = first.split('\n').length
+        raw[`${key}FinalLines`] = surface.split('\n').length
+      }
+    }
+  }
+
+  // ② 评审盲维命中：dimensionNotes 枚举值计数（'finding'——评审员结构化判定面）
+  let blindDims = 0
+  const dims = reviewJson && typeof reviewJson === 'object' && reviewJson.dimensionNotes
+    && typeof reviewJson.dimensionNotes === 'object' && !Array.isArray(reviewJson.dimensionNotes)
+    ? reviewJson.dimensionNotes : null
+  if (dims) {
+    for (const v of Object.values(dims)) if (v === 'finding') blindDims++
+    raw.dimensionNotesKeys = Object.keys(dims).length
+  }
+
+  // ③ 实测失败次数：verify-runs 记录面按 change 归属计数（status='failed' 枚举）
+  let testFailures = 0
+  const runsDir = join(specBase, '.runtime', 'verify-runs')
+  try {
+    for (const e of readdirSync(runsDir, { withFileTypes: true })) {
+      if (!e.isDirectory()) continue
+      const tr = readTextSafe(join(runsDir, e.name, 'test-result.json'))
+      if (tr == null) continue
+      try {
+        const j = JSON.parse(tr)
+        if (j && typeof j === 'object' && j.change === change && j.status === 'failed') testFailures++
+      } catch { /* 损坏记录不计 */ }
+    }
+  } catch { /* 无 verify-runs 目录 = 0 */ }
+  raw.failedRunCount = testFailures
+
+  // flowState 仅随 raw 留档（不参与判定——判定面恒为上方三个封闭面）
+  raw.flowTier = flowState && flowState.tier ? String(flowState.tier) : null
+  raw.adopted = Boolean(flowState && flowState.adopted_from)
+
+  return { designRewriteRatio, tasksRewriteRatio, blindDims, testFailures, raw }
+}
+
+/**
+ * 超阈判定＋标记落库（.sillyspec/.runtime/route-hindsight.json，per-repo 单条整文件覆盖）。
+ * @param {{ cwd: string, specBase: string, change: string, metrics: object }} p
+ * @returns {{ marked: boolean, reasons: string[] }}
+ */
+export function markHindsight({ cwd, specBase, change, metrics }) {
+  const base = specBase || join(cwd || '.', '.sillyspec')
+  const m = metrics || {}
+  const reasons = []
+  if (num(m.designRewriteRatio) > HINDSIGHT_THRESHOLDS.designRewriteRatio) {
+    reasons.push(`design 机器稿改写比 ${num(m.designRewriteRatio)} > ${HINDSIGHT_THRESHOLDS.designRewriteRatio}`)
+  }
+  if (num(m.tasksRewriteRatio) > HINDSIGHT_THRESHOLDS.tasksRewriteRatio) {
+    reasons.push(`tasks 机器预填稿改写率 ${num(m.tasksRewriteRatio)} > ${HINDSIGHT_THRESHOLDS.tasksRewriteRatio}`)
+  }
+  if (num(m.blindDims) >= HINDSIGHT_THRESHOLDS.blindDims) {
+    reasons.push(`评审盲维命中 ${num(m.blindDims)} 维 ≥ ${HINDSIGHT_THRESHOLDS.blindDims}`)
+  }
+  if (num(m.testFailures) >= HINDSIGHT_THRESHOLDS.testFailures) {
+    reasons.push(`实测失败 ${num(m.testFailures)} 次 ≥ ${HINDSIGHT_THRESHOLDS.testFailures}`)
+  }
+  if (reasons.length === 0) return { marked: false, reasons: [] }
+  const runtimeRoot = join(base, '.runtime')
+  mkdirSync(runtimeRoot, { recursive: true })
+  writeAtomicSync(join(runtimeRoot, MARK_FILE), JSON.stringify({
+    change,
+    marked_at: new Date().toISOString(),
+    metrics: {
+      designRewriteRatio: num(m.designRewriteRatio),
+      tasksRewriteRatio: num(m.tasksRewriteRatio),
+      blindDims: num(m.blindDims),
+      testFailures: num(m.testFailures),
+    },
+    reasons,
+  }, null, 2) + '\n')
+  return { marked: true, reasons }
+}
+
+/**
+ * 下次 flow start 的点名提示读取。无文件/无标记/损坏 → null（新装零影响——无 hindsight
+ * 文件的仓 flow start 输出与现状完全一致）。
+ * @returns { string | null }
+ */
+export function readHindsightHint({ specBase }) {
+  try {
+    const raw = readFileSync(join(specBase, '.runtime', MARK_FILE), 'utf8')
+    const j = JSON.parse(raw)
+    if (!j || typeof j !== 'object' || !j.change) return null
+    const m = j.metrics || {}
+    const pct = (v) => (Number.isFinite(Number(v)) ? `${Math.round(Number(v) * 100)}%` : '?')
+    const why = Array.isArray(j.reasons) && j.reasons.length > 0 ? j.reasons.join('；') : '过程形态超阈'
+    return `🕰️ route-hindsight：上个轻量变更「${j.change}」疑似该走头脑风暴预段未走（${why}；形态计数——design 改写比 ${pct(m.designRewriteRatio)}、tasks 改写率 ${pct(m.tasksRewriteRatio)}、评审盲维命中 ${m.blindDims ?? '?'}、实测失败 ${m.testFailures ?? '?'} 次）。「疑似」是过程形态信号非定罪——本次需求确实已含决策可无视；若拿不准，先 run brainstorm --change <名> 再回来收编。`
+  } catch {
+    return null
+  }
+}
+
+export default { HINDSIGHT_THRESHOLDS, snapshotBaseline, computeHindsightMetrics, markHindsight, readHindsightHint }

package/src/run/archive-distill.js

@@ -70,7 +70,9 @@ export async function executeArchiveDistill({ cwd, specBase, changeName }) {
     }
     // 删除缺口探针（D-008 护栏③）：观察信号，不算 L3 门禁——L1 无删除声明义务，只采趋势数据
     for (const u of (fr && fr.unreferenced) || []) {
-      appendKnowledgeHit(runtimeRoot, { type: 'fr-unreferenced', change: changeName, domain: u.domain, count: u.count })
+      // ids（2026-10-03-fr-governance-telemetry）：条目级信号透传（帽 20 已在探针端裁）——
+      // stats 裁决候选视图聚合键；缺席（异常形态）省字段不伪造。
+      appendKnowledgeHit(runtimeRoot, { type: 'fr-unreferenced', change: changeName, domain: u.domain, count: u.count, ...(Array.isArray(u.ids) && u.ids.length > 0 ? { ids: u.ids } : {}) })
       console.log(`   ℹ️  [观察信号·不算 L3 门禁] 触达域 ${u.domain} 有 ${u.count} 条 active FR 未被本次承接引用（fr-unreferenced 遥测，L3 裁决趋势数据）`)
     }
   } catch (e) {

package/src/run/command.js

@@ -29,7 +29,7 @@ import { resolveQuickLinkedChanges } from './quick-audit.js'
 import { outputStep, collectStageWaitHistory } from './prompt.js'
 import { completeStep, completeStepBurst, skipStep, waitStep, continueStep, synthesizeStepOutput } from './complete.js'
 import { runStage } from './stage.js'
-import { sanitizeDesc } from '../quicklog.js'
+import { sanitizeDesc, deriveChangeTitle } from '../quicklog.js'
 import { ProgressManager, resolveSessionIdentity } from '../progress.js'
 import { validateChangeExists, checkTransition } from '../stage-contract.js'
 import { READONLY_AUXILIARY_STAGES } from '../constants.js'
@@ -215,6 +215,22 @@ export async function ensureStageSteps(progress, stageName, cwd, specDir = null)
  * run <stage> --help/-h 的用法帮助（runCommand 内 --help 短路调用）。
  * 只打印不落盘：帮助查询不该有副作用（建会话/写 QUICKLOG）。
  */
+/**
+ * 只读空态引导文案（2026-10-05-status-empty-guide 首创；2026-10-06-status-multi-active-list
+ * 抽出单一源——库不在场前置门与 read 后空分支共用一份，防两处文案漂移）。静态文案——引用
+ * 通用命令形态而非本仓状态（空态定义即无数据可读）。可照抄实例（2026-10-05-input-teach-copyable）：
+ * 引号内换行合法，extractSuccessCriteria 行级 trim 容忍缩进，带缩进照抄亦过门。
+ */
+function emitReadonlyEmptyGuide() {
+  console.log('ℹ️ 未找到进度数据（只读查询不建变更）')
+  console.log('   → 可开始轻量变更（--input 引号内换行合法，下例可照抄）：')
+  console.log('     sillyspec flow start --change <YYYY-MM-DD-名> --input "<动机与背景>')
+  console.log('')
+  console.log('     成功标准：')
+  console.log('     - <可验证标准>"')
+  console.log('   → 需求不明可 sillyspec run brainstorm --change <名> 先探索')
+}
+
 function printStageUsage(stageName) {
   const stage = stageRegistry[stageName]
   console.log(`
@@ -833,7 +849,11 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
             quickSessionId = recent
             quickFallbackUsed = true
           } else {
-            console.log('   本仓无近期 quick 会话记录（current marker 与 quick-sessions 均空）——新工作请走轻量变更：sillyspec flow start --change <名> --input "<动机与背景；随后独立一行『成功标准：』；再每行一条『- <可验证标准>』>"')
+            console.log('   本仓无近期 quick 会话记录（current marker 与 quick-sessions 均空）——新工作请走轻量变更（--input 引号内换行合法，可照抄）：')
+            console.log('   sillyspec flow start --change <YYYY-MM-DD-名> --input "<动机与背景>')
+            console.log('')
+            console.log('   成功标准：')
+            console.log('   - <可验证标准>"')
             process.exit(0)
           }
         } else {
@@ -1111,9 +1131,23 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
     }
   }
 
+  // 只读辅助阶段的写意图 flag 清单（下方两处只读短路共用：库不在场前置门 + read 后短路）
+  const READONLY_WRITE_ACTIONS = ['--cleanup-remnant', '--align-execute-progress', '--done', '--skip', '--reset', '--reopen', '--wait', '--continue']
+
+  // 只读前置门（2026-10-06-status-multi-active-list）：库文件不在场时不得进入 pm.read()——
+  // read() 无显式 --change 先走 listChanges→_ensureDB，会凭空新建空库（只读承诺破防，实测）；
+  // 空库撞残留 schema-version 戳无表可查，首个 SELECT 直接崩（no such table: changes）。
+  // 库不在场=字面意义的零进度：与零活跃同款空态引导 + exit 0，零落盘。
+  if (READONLY_AUXILIARY_STAGES.includes(stageName) && !flags.some(f => READONLY_WRITE_ACTIONS.includes(f))
+      && !existsSync(pm._runtimePath(cwd, 'sillyspec.db'))) {
+    emitReadonlyEmptyGuide()
+    process.exit(0)
+  }
+
   let progress = pm.read(cwd, changeName)
 
-  // task-03 (D-005@v2 / FR-04): READONLY_AUXILIARY_STAGES（status/doctor）查询只读短路。
+  // task-03 (D-005@v2 / FR-04): READONLY_AUXILIARY_STAGES（status；doctor 已于 2026-09-09-doctor-noai
+  // 移出——阶段形态走状态机，顶层 doctor 只读语义由 index.js case 头部分流保真）查询只读短路。
   // 无显式写 flag 时在 registerChange / ensureStageSteps 之前拦截，零副作用：
   //   - 目标 progress 不存在 → 提示「只读查询不建变更」exit 0（不 initChange、不建 default 行，治 8b）
   //   - 目标 progress 存在 → 只读展示，不 seed steps、不刷新 lastActive、不 registerChange
@@ -1121,10 +1155,25 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
   // 显式写意图不短路：doctor 写操作 flag（--cleanup-remnant / --align-execute-progress）与
   // 步骤动作 flag（--done/--skip/--reset/--reopen/--wait/--continue）走原写路径；--status 本身
   // 是只读查询，纳入短路。--fix 是 worktree doctor 的 flag 不在此列（design.md Phase 4）。
-  const READONLY_WRITE_ACTIONS = ['--cleanup-remnant', '--align-execute-progress', '--done', '--skip', '--reset', '--reopen', '--wait', '--continue']
   if (READONLY_AUXILIARY_STAGES.includes(stageName) && !flags.some(f => READONLY_WRITE_ACTIONS.includes(f))) {
     if (!progress) {
-      console.log('ℹ️ 未找到进度数据（只读查询不建变更）')
+      // 多活跃分流（2026-10-06-status-multi-active-list）：read() 无显式 --change 在 ≥2 活跃
+      // 时同样返回 null——「有数据但需要点名」被空态文案一律误报成「无数据」（本仓实测
+      // 10 行 active、2 个目录待收口却被告知未找到）。前置门保证走到这库必在场，listChanges
+      // 纯读；显式 --change 未命中仍走空态引导（点名失败与未点名歧义是两件事）。
+      let activeChanges = []
+      try { activeChanges = pm.listChanges(cwd) || [] } catch { activeChanges = [] }
+      if (!changeName && activeChanges.length >= 2) {
+        console.log(`ℹ️ 进度数据存在，但有 ${activeChanges.length} 个活跃变更（未指定 --change，无法确定展示哪个）：`)
+        for (const name of activeChanges) {
+          // DB 行与目录是两个真相层：目录缺失的幽灵行如实标注（清幽灵走既有 doctor --cleanup-remnant）
+          console.log(`   - ${name}${existsSync(pm._changePath(cwd, name)) ? '' : '（本地无目录）'}`)
+        }
+        console.log(`   → 指定查看其一：sillyspec status --change ${activeChanges[0]}`)
+        console.log('   → 恢复面：sillyspec flow status --change <名>')
+        process.exit(0)
+      }
+      emitReadonlyEmptyGuide()
       process.exit(0)
     }
     // 只读展示路径：复用阶段定义渲染当前步骤 prompt（outputStep 对 status/doctor 纯只读），
@@ -1225,10 +1274,11 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
     // 如果指定了变更名或有变更目录，自动初始化变更的 progress
     const autoChange = changeName || resolveChangeNameAuto(cwd, specRoot)
     if (autoChange) {
-      // 创建时即写 title（与 name/KEY 同时落 db）：--input 需求描述 sanitizeDesc 优先，无则用 name 兜底。
+      // 创建时即写 title（与 name/KEY 同时落 db）：--input 首行推导 deriveChangeTitle（≤50 字，
+      // 用户需求 2026-09-29）优先，长输入兜底 sanitizeDesc 压行，无则用 name 兜底。
       // proposal 还没写、无权威标题来源，这是临时值；brainstorm/plan 完成 proposal/design 落盘后由
       // complete.js 通用完成路径 deriveTitleFromLinkedChange 刷新为真实 # 标题（与 quick 启动 title 同源）。
-      progress = pm.initChange(cwd, autoChange, { title: inputText ? sanitizeDesc(inputText) : autoChange })
+      progress = pm.initChange(cwd, autoChange, { title: inputText ? (deriveChangeTitle(inputText) || sanitizeDesc(inputText)) : autoChange })
     } else if (isAuxiliary) {
       let autoName = changeName || resolveChangeNameAuto(cwd, specRoot) || 'default'
       // archive 特例：归档后变更从活跃列表排除（listChanges WHERE status='active'），
@@ -1255,7 +1305,7 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
       changeName = autoName
       if (!progress) {
         // auxiliary 创建也写 title（--input 优先 / name 兜底），同上完整流程语义。
-        progress = pm.initChange(cwd, autoName, { title: inputText ? sanitizeDesc(inputText) : autoName })
+        progress = pm.initChange(cwd, autoName, { title: inputText ? (deriveChangeTitle(inputText) || sanitizeDesc(inputText)) : autoName })
         // initChange 可能因 project 表为空返回 null
         if (!progress) {
           progress = { currentStage: stageName, stages: {}, lastActive: new Date().toLocaleString('zh-CN', { hour12: false }), project: '' }
@@ -1287,7 +1337,7 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
         console.log(`  提示：可以用 --change <名称> 指定自定义变更名`)
         console.log(`  或事后重命名：sillyspec change-rename ${autoName} <新名称>`)
         // brainstorm 自动创建变更也写 title（--input 需求描述优先 / 自动名兜底），proposal 落盘后刷新。
-        progress = pm.initChange(cwd, autoName, { title: inputText ? sanitizeDesc(inputText) : autoName })
+        progress = pm.initChange(cwd, autoName, { title: inputText ? (deriveChangeTitle(inputText) || sanitizeDesc(inputText)) : autoName })
         changeName = autoName
       } else if (stageName === 'auto') {
         // auto 零活跃建变更（2026-09-08-auto-driver D-003@v1，Grill P1-②）：SKILL 启动命令即
@@ -1303,7 +1353,7 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
         const date = new Date().toISOString().slice(0, 10)
         const autoName = `${date}-new-change-${randomBytes(4).toString('hex')}`
         console.log(`🔄 auto 模式自动创建变更：${autoName}（可用 --change 指定名称，或事后 change-rename）`)
-        progress = pm.initChange(cwd, autoName, { title: inputText ? sanitizeDesc(inputText) : autoName })
+        progress = pm.initChange(cwd, autoName, { title: inputText ? (deriveChangeTitle(inputText) || sanitizeDesc(inputText)) : autoName })
         changeName = autoName
       } else {
         console.error('❌ 未找到进度数据，请先运行 sillyspec init 或指定 --change <变更名>')
@@ -2010,8 +2060,11 @@ async function runAutoMode(pm, progress, cwd, flags, changeName, platformOpts =
     const classification = classifyChange({ description: inputText || '', explicitMode, localConfig })
     if (classification.mode === 'quick') {
       console.log(`📊 auto 模式分类：${classification.reason} 判为小变更`)
-      console.log(`   小变更请走轻量变更（quick 通道已退役，v3.30.0 起拒绝新会话）：`)
-      console.log(`   sillyspec flow start --change <名> --input "<动机与背景；随后独立一行『成功标准：』；再每行一条『- <可验证标准>』>"`)
+      console.log(`   小变更请走轻量变更（quick 通道已退役，v3.30.0 起拒绝新会话；--input 引号内换行合法，可照抄）：`)
+      console.log('   sillyspec flow start --change <YYYY-MM-DD-名> --input "<动机与背景>')
+      console.log('')
+      console.log('   成功标准：')
+      console.log('   - <可验证标准>"')
       return
     }
     console.log(`📊 auto 模式分类：${classification.mode}（${classification.reason}）`)