sillyspec 3.29.5 → 3.30.0

package/src/quicklog.js

@@ -752,10 +752,12 @@ const GUARD_CLAIM_STALE_MS = 7 * 24 * 60 * 60 * 1000
  * 遍历 quick-sessions 目录，按同一僵尸窗口口径读各会话 guard.json（collectGuardReservedQuicklogIds
  * 与 collectActiveQuickGuardFiles 共用，活跃判定勿分叉）：guard.json 损坏/缺失 → guard=null 保留
  * 条目（消费方各自决定跳过或视为空声明）；startedAt 可解析且超 GUARD_CLAIM_STALE_MS → 僵尸剔除。
+ * 附 guardMtimeMs（guard.json 最后写时间——会话结构性更新【启动/--files 追加边界】都会重写该文件，
+ * 是比 startedAt 更新的活性信号；非周期心跳，长思考会话会漂老，消费方 TTL 须以此为前提选窗）。
  *
  * @param {string} dir quick-sessions 目录
  * @param {number} [nowMs] 当前时间戳（可注入，测试用）
- * @returns {Array<{sessionId: string, guard: object|null}>}
+ * @returns {Array<{sessionId: string, guard: object|null, guardMtimeMs: number|null}>}
  */
 function listQuickSessionGuards(dir, nowMs = Date.now()) {
   const out = []
@@ -765,12 +767,17 @@ function listQuickSessionGuards(dir, nowMs = Date.now()) {
   } catch { return out } // 目录不存在/不可读 → 无会话
   for (const sessionName of sessionDirs) {
     let guard = null
-    try { guard = JSON.parse(readFileSync(join(dir, sessionName, 'guard.json'), 'utf8')) } catch { guard = null } // 损坏/缺失 → null
+    let guardMtimeMs = null
+    const guardPath = join(dir, sessionName, 'guard.json')
+    try {
+      guard = JSON.parse(readFileSync(guardPath, 'utf8'))
+      guardMtimeMs = statSync(guardPath).mtimeMs
+    } catch { guard = null } // 损坏/缺失 → null（mtime 一并放弃）
     if (guard && guard.startedAt) {
       const startedAtMs = Date.parse(guard.startedAt)
       if (Number.isFinite(startedAtMs) && nowMs - startedAtMs > GUARD_CLAIM_STALE_MS) continue // 僵尸不活跃
     }
-    out.push({ sessionId: sessionName, guard })
+    out.push({ sessionId: sessionName, guard, guardMtimeMs })
   }
   return out
 }
@@ -795,30 +802,61 @@ export function collectGuardReservedQuicklogIds(specBase, sessionsDirHint = null
  * （quick --done 完成时清理 guard 目录，完成态天然退出），超 7 天僵尸窗口（GUARD_CLAIM_STALE_MS，
  * 异常残留不钉死）剔除。勿用 changes.last_active 判活跃（非周期心跳，D-002）。
  *
+ * **拦截面 TTL（ql-20260921-009 ①，2026-09-21 batch2 归档实证）**：在僵尸窗口之上，本函数（apply
+ * 拦截面专用消费口）再按 guard.json **mtime** 收紧——超过 staleAfterMs（缺省 4h）无结构性更新的
+ * 会话视为放弃，声明不再参与相交拦截。实证形态：quick 会话中断未 --done、guard 目录残留 36h，
+ * apply 被幽灵守卫拦住，人工查证 owner.json 才敢解锁。安全性：守卫只是预警层，apply 的内容级
+ * 脏文件三方合并检查（EXCLUDE-DIRTY）仍兜底真实冲突；4h 窗口对 quick（短命流程）足够宽，
+ * 超窗未动 CLI 的会话即使活着，其声明文件若真有未提交改动也走内容级检查。quicklog ID 预留
+ * （collectGuardReservedQuicklogIds）**不套用**此 TTL——ID 复用避开近期死会话仍取 7 天窗。
+ * 过期跳过时打一行 ℹ️（可观测，不静默）；staleAfterMs=null 关闭（测试/回退口径）。
+ *
  * @param {string} specBase .sillyspec 根目录
- * @param {{ excludeChange?: string|null, sessionsDir?: string|null, nowMs?: number }} [opts]
+ * @param {{ excludeChange?: string|null, sessionsDir?: string|null, nowMs?: number, staleAfterMs?: number|null }} [opts]
  *   - excludeChange：排除自身 change 的 quick 会话——sessionId == changeName（quick 会话 id 即
  *     change 名）或 guard.linkedChanges 显式关联该 change 的协作会话（自己人，非拦截面）
  *   - sessionsDir：quick-sessions 目录（缺省 <specBase>/.runtime/quick-sessions）
  *   - nowMs：当前时间戳（可注入，测试用）
+ *   - staleAfterMs：拦截面 TTL 毫秒数（缺省 GUARD_INTERCEPT_STALE_MS=4h；null 关闭）
  * @returns {Map<string, string[]>} sessionId → guard.allowedFiles（无 guard/无声明 → 空数组；fail-open）
  */
-export function collectActiveQuickGuardFiles(specBase, { excludeChange = null, sessionsDir = null, nowMs = Date.now() } = {}) {
+const GUARD_INTERCEPT_STALE_MS = 4 * 60 * 60 * 1000
+export function collectActiveQuickGuardFiles(specBase, { excludeChange = null, sessionsDir = null, nowMs = Date.now(), staleAfterMs = GUARD_INTERCEPT_STALE_MS } = {}) {
   const out = new Map()
+  let staleSkipped = 0
   try {
     const dir = sessionsDir || join(specBase, '.runtime', 'quick-sessions')
-    for (const { sessionId, guard } of listQuickSessionGuards(dir, nowMs)) {
+    for (const { sessionId, guard, guardMtimeMs } of listQuickSessionGuards(dir, nowMs)) {
       if (excludeChange && (sessionId === excludeChange
         || (guard && Array.isArray(guard.linkedChanges) && guard.linkedChanges.includes(excludeChange)))) continue
+      if (staleAfterMs != null && guardMtimeMs != null && Number.isFinite(guardMtimeMs)
+        && nowMs - guardMtimeMs > staleAfterMs) { staleSkipped++; continue } // TTL 过期：拦截面视为放弃
       const allowed = (guard && Array.isArray(guard.allowedFiles))
         ? guard.allowedFiles.filter(f => typeof f === 'string' && f.length > 0)
         : []
       out.set(sessionId, allowed)
     }
   } catch { /* fail-open：采集失败等同无活跃 guard（不放大拦截面） */ }
+  if (staleSkipped > 0) {
+    console.log(`ℹ️ 已忽略 ${staleSkipped} 个过期 quick 守卫（>${Math.round(staleAfterMs / 3600000)}h 无活动，TTL 自动失效）——内容级脏文件合并检查仍兜底真实冲突`)
+  }
   return out
 }
 
+/**
+ * quick 启动并发错峰建议探测（ql-20260921-009 ③，2026-09-21 batch2 归档实证）。纯读：
+ * 他者活跃 quick 守卫（TTL 过滤后）≥1 且主仓已有 src/test 脏文件 → suggest=true——两者
+ * 同时在场时工作区互写/apply 相交拦截摩擦集中爆发。单会话常态 suggest=false 零输出。
+ * @returns {{ suggest: boolean, others: string[] }}
+ */
+export function detectQuickConcurrencyAdvice({ specBase, changeName, baselineFiles, sessionsDir = null, nowMs = Date.now() } = {}) {
+  const others = collectActiveQuickGuardFiles(specBase, { excludeChange: changeName, sessionsDir, nowMs })
+  const srcTestDirty = Array.isArray(baselineFiles) && baselineFiles.some(
+    (p) => { const n = String(p).split('\\').join('/'); return n.startsWith('src/') || n.startsWith('test/') }
+  )
+  return { suggest: others.size > 0 && !!srcTestDirty, others: [...others.keys()] }
+}
+
 /**
  * 数某 qlId 在所有 QUICKLOG-*.md 里的条目头出现次数（--done 占用校验用）。
  * ≥2 = 分配竞态残留已损坏记录（同 ID 双条目）；容错空白形态与 scanExisting 的 reLoose 同口径。

package/src/redomain.js

@@ -0,0 +1,147 @@
+/**
+ * redomain.js — FR 条目跨域迁移（2026-09-27-redomain，三层治理 v2 ③）
+ *
+ * 伪域信号卡指出迁移建议（suggestDomainFromFiles），本模块给机器通道：
+ * 把 fr/<from>.md 的条目段切出、拼进 fr/<to>.md（缺席则按 loadDomainSections
+ * 同款头新建），目标域无 INDEX 路由行则补（syncIndexRoutingLines 单源）。
+ *
+ * 身份铁律（D-001 单一身份同源）：迁域**不换号**——条目 ID（FR-<旧域>-NNN）
+ * 保持原样，绑定行/supersede 链/最近确认锚全靠 ID 寻址（upsertFrBindings 按
+ * `## ${frId}` 全目录扫描定位，与所在文件无关）；前缀与域不符属历史痕迹。
+ *
+ * 空壳防线：全域迁移后源文件剩 0 条目则删除（防留空壳域文件污染域列表）。
+ * 纯文件手术——不动条目内容、不动绑定块（随条目段整体搬）。
+ */
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs'
+import { join } from 'path'
+import { splitKnowledgeSections, joinKnowledgeFile, syncIndexRoutingLines } from './decision-distill.js'
+import { FR_SECTION_RE } from './fr-index.js'
+import { writeAtomicSync } from './fs-atomic.js'
+
+/** 条目段头（## FR-xxx-NNN / ## FR-NNN）判定与 ID 提取 */
+const FR_HEADER_RE = /^## (FR-[\w.-]+-\d+|FR-\d+)\s*(.*)$/
+
+function frEntryId(headerLine) {
+  const m = FR_HEADER_RE.exec(headerLine)
+  return m ? m[1] : null
+}
+
+/** 目标域文件头（与 fr-index loadDomainSections 新建头逐字同款） */
+function newDomainPreamble(domain) {
+  // 与 fr-index loadDomainSections 新建头逐字同款（评审 P2-2 清偿：含 superseded 回溯行
+  // 与 伪域/模块卡 条件行，勿再分叉）
+  return [
+    '---',
+    `author: sillyspec-fr-index`,
+    `created_at: ${new Date().toISOString()}`,
+    '---',
+    '',
+    `# FR 索引 — ${domain}`,
+    '',
+    '> fr-index 从归档变更 requirements.md 幂等提炼（「最近确认」= 归档时 HEAD）。条目字段行为机械解析契约，勿手改。',
+    '> superseded 条目保留供取代链回溯；brainstorm 注入默认只给 active。',
+    String(domain).startsWith('auto-')
+      ? '> 伪域（auto- 前缀）：由文件路径段投票派生，无模块卡——为该域补模块卡后，新变更将自动落回真域'
+      : `> 模块卡：modules/${domain}.md（域=模块 id 同构；行为条目↔模块契约互跳）`,
+    '',
+  ]
+}
+
+/**
+ * 执行迁移（纯函数式落盘）。
+ * @param {{knowledgeRoot: string, from: string, to: string, anchors?: string[]}} opts
+ * @returns {{moved: Array<{id,title}>, sourceDeleted: boolean, targetCreated: boolean, indexLineAdded: boolean}}
+ * @throws 源域缺席 / 无匹配条目 / anchor 未命中
+ */
+export function redomainFrEntries({ knowledgeRoot, from, to, anchors = null }) {
+  const frDir = join(knowledgeRoot, 'fr')
+  const fromPath = join(frDir, `${from}.md`)
+  const toPath = join(frDir, `${to}.md`)
+  if (!existsSync(fromPath)) throw new Error(`源域文件不存在：fr/${from}.md`)
+  if (from === to) throw new Error('源域与目标域相同')
+
+  const fromParsed = splitKnowledgeSections(readFileSync(fromPath, 'utf8'), { sectionRegex: FR_SECTION_RE, buildId: (n) => n })
+  const anchorSet = Array.isArray(anchors) && anchors.length > 0 ? new Set(anchors) : null
+
+  // 目标域既有内容（缺席=新建头）
+  const targetCreated = !existsSync(toPath)
+  const toParsed = targetCreated
+    ? { preamble: newDomainPreamble(to), sections: [] }
+    : splitKnowledgeSections(readFileSync(toPath, 'utf8'), { sectionRegex: FR_SECTION_RE, buildId: (n) => n })
+
+  const moving = []
+  const staying = []
+  for (const s of fromParsed.sections) {
+    const id = frEntryId(s.lines[0] || '')
+    if (!id) { staying.push(s); continue } // 非条目段（说明/杂项）留守
+    if (anchorSet && !anchorSet.has(id)) { 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 条目段`)
+  }
+  if (anchorSet && moving.length !== anchorSet.size) {
+    const got = new Set(moving.map((m) => m.id))
+    const miss = [...anchorSet].filter((a) => !got.has(a))
+    throw new Error(`anchor 未命中：${miss.join('、')}（不在 fr/${from}.md）`)
+  }
+  // 目标域 ID 冲突防线（同 ID 已在目标域=迁移语义不明）
+  const toIds = new Set(toParsed.sections.map((s) => frEntryId(s.lines[0] || '')).filter(Boolean))
+  const clash = moving.filter((m) => toIds.has(m.id))
+  if (clash.length > 0) throw new Error(`目标域已有同 ID 条目（${clash.map((c) => c.id).join('、')}）——先解冲突再迁移`)
+
+  // 落盘：目标域追加；源域留余或删除空壳
+  toParsed.sections.push(...moving.map((m) => m.section))
+  writeAtomicSync(toPath, joinKnowledgeFile(toParsed.preamble, toParsed.sections))
+  const sourceDeleted = staying.length === 0
+  if (sourceDeleted) unlinkSync(fromPath)
+  else writeAtomicSync(fromPath, joinKnowledgeFile(fromParsed.preamble, staying))
+
+  // INDEX 路由行：syncIndexRoutingLines 扫全目录幂等同步（既有行 no-op、目标域缺席行补上）
+  const indexPath = join(knowledgeRoot, 'INDEX.md')
+  const before = existsSync(indexPath) ? readFileSync(indexPath, 'utf8') : ''
+  try {
+    syncIndexRoutingLines(knowledgeRoot, {
+      section: 'FR 需求索引',
+      subdir: 'fr',
+      makeLine: (d) => d.startsWith('auto-')
+        ? `- ${d}|${d.slice(5)}|FR|需求|承接 → [fr/${d}.md](fr/${d}.md)`
+        : `- ${d}|FR|需求|承接 → [fr/${d}.md](fr/${d}.md)`,
+    })
+  } catch { /* INDEX 缺席/同步失败不拦迁移（主手术已成） */ }
+  const after = existsSync(indexPath) ? readFileSync(indexPath, 'utf8') : ''
+
+  return {
+    moved: moving.map((m) => ({ id: m.id, title: m.title })),
+    sourceDeleted,
+    targetCreated,
+    indexLineAdded: after !== before,
+  }
+}
+
+/** 干跑预览：列出将迁移条目，不落盘 */
+export function planRedomain({ knowledgeRoot, from, to, anchors = null }) {
+  const frDir = join(knowledgeRoot, 'fr')
+  const fromPath = join(frDir, `${from}.md`)
+  if (!existsSync(fromPath)) throw new Error(`源域文件不存在：fr/${from}.md`)
+  if (from === to) throw new Error('源域与目标域相同')
+  const fromParsed = splitKnowledgeSections(readFileSync(fromPath, 'utf8'), { sectionRegex: FR_SECTION_RE, buildId: (n) => n })
+  const anchorSet = Array.isArray(anchors) && anchors.length > 0 ? new Set(anchors) : null
+  const candidates = []
+  for (const s of fromParsed.sections) {
+    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 (candidates.length === 0) {
+    throw new Error(anchorSet ? `anchor 未命中（${[...anchorSet].join('、')}）` : `fr/${from}.md 无 FR 条目段`)
+  }
+  return {
+    from,
+    to,
+    targetExists: existsSync(join(frDir, `${to}.md`)),
+    entries: candidates,
+    sourceWillDelete: candidates.length === fromParsed.sections.filter((s) => frEntryId(s.lines[0] || '')).length,
+  }
+}

package/src/review-material-pack.js

@@ -23,7 +23,7 @@
  * 是 prompt.js tier 注入链的组包入口——机械抽素材半边（designDigest/fileList/硬约束/diff/热区/
  * checklist），主代理点名半边（五交叉点/plan 差量）留位不预填（decisions.md D-002）。
  */
-import { readFileSync } from 'fs'
+import { mkdirSync, readFileSync, writeFileSync } from 'fs'
 import { join } from 'path'
 import { REVIEW_CHECKLISTS } from './stage-review-checklist.js'
 
@@ -132,9 +132,15 @@ export function buildReviewMaterialPack(stage, inputs = {}) {
     const delta = (inputs.planDelta || []).map(d => `- [${d.id}] ${d.status}${d.note ? '——' + d.note : ''}`).join('\n')
     body = ['### design 硬约束', hc || '（无）', '### plan 差量（逐约束判定：一致/偏离/未覆盖）', delta || '（无——主代理未提供差量，评审者按 cannot_verify 列缺件）'].join('\n\n')
   } else if (stage === 'execute-qa') {
+    // 测试清单（R16 减负批次 2026-09-24）：diff 命中的测试文件点名——QA 对「组装行为」条目
+    // 作答时不必全仓找测试（R14 对撞失控勘察子代理 2.33M 的反面教材后，包内点名收窄查证面）。
+    const testFiles = (inputs.diffSummary && inputs.diffSummary.files || [])
+      .filter(f => /(^|[\\/])(tests?|__tests__)([\\/])|\.(test|spec)\.[cm]?[jt]sx?$|_test\.(go|py)$|(^|[\\/])test_[^\\/]+\.py$/i.test(f))
+      .slice(0, 30)
     body = [
       '### diff 摘要', (inputs.diffSummary && inputs.diffSummary.files || []).map(f => '- ' + f).join('\n') || '（无）',
       inputs.diffSummary && inputs.diffSummary.stat ? '```diff\n' + inputs.diffSummary.stat + '\n```' : '',
+      '### 测试清单（diff 命中的测试文件）', testFiles.map(f => '- ' + f).join('\n') || '（diff 无测试文件——「组装行为」条目按包不足处理：cannot_verify 列缺件或定向查证并列明）',
       '### design 热区（CLI 抽取）', extractDesignHotZone(inputs.designContent || '') || '（无命中节）',
       '### 验收清单', (inputs.checklist || []).map(c => '- [ ] ' + c).join('\n') || '（无）',
     ].filter(Boolean).join('\n\n')
@@ -263,3 +269,200 @@ export async function assembleStageReviewMaterials({ stage, cwd, changeName, spe
   } catch { /* 装配 best-effort：失败零注入（与占位符缺失同态） */ }
   return ''
 }
+
+// ══ execute 任务材料包（2026-09-21-r5-efficiency-batch1 task-02，B-④ / D-003）════
+// 两段式装配：稳定段（design.md「接口定义」「文件变更清单」固定节名机械选取原文 + 签名锚点）
+// 在前、专属段（task 卡 title/goal/implementation/acceptance + allowed_paths）在后——稳定前缀
+// 跨任务共享，兑现统一前缀缓存收益（压 task-08 型子代理轮均 148K vs 同侪 45-92K 差额）。
+// 只摘不译（D-003 错键正典红线）：一切内容为源文件原文逐字摘录/字段机械抽取，禁转写缩写。
+
+/** 材料包字节上限（专属段尾部优先截；稳定段超限按节优先级截断——见 assembleExecuteTaskMaterials） */
+const EXEC_MATERIALS_MAX_BYTES = 24576
+/** 被截节保底形态里「首个代码块/表格」的块级上限（单块病态体量防穿顶） */
+const EXEC_STUB_BLOCK_MAX_BYTES = 3600
+
+function bytesOf(s) { return Buffer.byteLength(String(s || ''), 'utf8') }
+
+/** 字节安全截断（按 UTF-8 字节预算切，不切断多字节字符） */
+function byteSafeSlice(text, maxBytes) {
+  const s = String(text || '')
+  if (bytesOf(s) <= maxBytes) return s
+  let out = ''
+  let used = 0
+  for (const ch of s) {
+    const b = Buffer.byteLength(ch, 'utf8')
+    if (used + b > maxBytes) break
+    out += ch
+    used += b
+  }
+  return out
+}
+
+/** 节内首个完整代码块（``` 围栏）或表格（连续 | 行）——被截节的保底保留形态 */
+function firstBlockOrTable(body) {
+  const fence = body.match(/```[^\n]*\n[\s\S]*?```/)
+  if (fence) return fence[0]
+  const lines = body.split('\n')
+  const start = lines.findIndex(l => l.trim().startsWith('|'))
+  if (start >= 0) {
+    let end = start
+    while (end < lines.length && lines[end].trim().startsWith('|')) end++
+    return lines.slice(start, end).join('\n')
+  }
+  return null
+}
+
+/** task 卡 frontmatter 块级解析（机械逐字）：顶格 key 行归属，其后缩进行归当前 key */
+function splitTaskCardFields(cardText) {
+  const m = String(cardText || '').match(/^---\r?\n([\s\S]*?)\r?\n---/)
+  if (!m) return {}
+  const fields = {}
+  let cur = null
+  for (const line of m[1].split(/\r?\n/)) {
+    if (/^[A-Za-z_][\w-]*:/.test(line)) {
+      const at = line.indexOf(':')
+      cur = { key: line.slice(0, at), raw: line.slice(at + 1).trim(), lines: [] }
+      fields[cur.key] = cur
+    } else if (cur) {
+      cur.lines.push(line)
+    }
+  }
+  return fields
+}
+
+function unquoteScalar(v) {
+  const s = String(v || '')
+  return s.replace(/^'(.*)'$/s, '$1').replace(/^"(.*)"$/s, '$1')
+}
+
+/**
+ * task 卡字段取值（只摘不译——原文保持，无 YAML 折叠语义改写）：
+ * 块标量（>/|）→ 原始行去公共缩进后逐行拼接；列表 → `- ` 后原文数组；标量 → 去包裹引号。
+ * @returns {string|string[]}
+ */
+function taskCardFieldValue(field) {
+  if (!field) return ''
+  if (/^[>|][+-]?$/.test(field.raw)) {
+    const indents = field.lines.filter(l => l.trim()).map(l => l.match(/^[ \t]*/)[0].length)
+    const cut = indents.length ? Math.min(...indents) : 0
+    return field.lines.map(l => (l.trim() ? l.slice(cut) : '')).join('\n').trim()
+  }
+  if (field.raw) return unquoteScalar(field.raw)
+  const items = []
+  for (const l of field.lines) {
+    const im = l.match(/^\s*-\s?(.*)$/)
+    if (im && im[1].trim()) items.push(im[1].trim())
+  }
+  return items
+}
+
+/**
+ * 组装 execute 任务材料包（两段式，只摘不译——契约见 change design.md「接口定义」）。
+ * @param {object} opts
+ * @param {string} opts.changeDir         - 变更目录（读 design.md / tasks/task-NN.md）
+ * @param {string} opts.taskId            - 'task-NN'
+ * @param {string} [opts.materialsDir]    - 落盘目录；缺省 → 不落盘不抛错返回 null（additive）
+ * @param {Array<{symbol: string, file: string, line: number}>} [opts.signatureAnchors]
+ *                                        - 接口签名锚点（可选，调用方供给；缺省空）
+ * @returns {Promise<{path: string, bytes: number, truncated: boolean}|null>}
+ *   截尾序：①专属段尾部优先截（稳定段全量保留）；②稳定段自身超限按节优先级（接口定义 >
+ *   文件变更清单——高优先节后截）逐节降为「节头 + 首个代码块/表格 + 回源指引行」；锚点永不丢。
+ */
+export async function assembleExecuteTaskMaterials({ changeDir, taskId, materialsDir, signatureAnchors }) {
+  if (!changeDir || !taskId || !materialsDir) return null
+  const designPath = join(changeDir, 'design.md')
+  const taskCardPath = join(changeDir, 'tasks', `${taskId}.md`)
+  let designContent = ''
+  let cardContent = ''
+  try { designContent = readFileSync(designPath, 'utf8') } catch { /* 缺 design → 稳定段只剩锚点 */ }
+  try { cardContent = readFileSync(taskCardPath, 'utf8') } catch { /* 缺卡 → 专属段仅回源指引 */ }
+
+  // ── 稳定段素材：固定节名机械选取（缺节跳过）+ 签名锚点行 ──
+  const anchors = (Array.isArray(signatureAnchors) ? signatureAnchors : [])
+    .filter(a => a && a.symbol)
+    .map(a => `- \`${String(a.symbol)}\` → ${a.file || '?'}:${a.line || '?'}`)
+  const anchorsBlock = anchors.length ? `### 接口签名锚点\n\n${anchors.join('\n')}` : ''
+
+  const SECTION_SPECS = [{ name: '接口定义' }, { name: '文件变更清单' }] // 序 = 保留优先级序
+  const secBlocks = SECTION_SPECS
+    .map(s => ({ ...s, body: sectionBody(designContent, s.name) }))
+    .filter(s => s.body)
+    .map(s => ({ ...s, full: `### ${s.name}（design.md 原文摘录）\n\n${s.body}` }))
+
+  /** 被截节残体：节头 + 首个代码块/表格（块级 clamp）+ 一行回源指引 */
+  const stubOf = s => {
+    const first = firstBlockOrTable(s.body)
+    const kept = first
+      ? (bytesOf(first) > EXEC_STUB_BLOCK_MAX_BYTES ? byteSafeSlice(first, EXEC_STUB_BLOCK_MAX_BYTES) + '\n…（首块超限截断）' : first)
+      : byteSafeSlice(s.body, 600)
+    return `### ${s.name}（design.md 原文摘录）\n\n${kept}\n\n完整内容回源：${designPath}#${s.name}`
+  }
+
+  // ── 专属段素材：task 卡要点（机械摘录）+ allowed_paths + 回源指引 ──
+  const fields = splitTaskCardFields(cardContent)
+  const val = k => taskCardFieldValue(fields[k])
+  const bulletList = v => (Array.isArray(v) ? v.map(i => `  - ${i}`).join('\n') : `  - ${v}`)
+  const title = val('title')
+  const goal = val('goal')
+  const impl = val('implementation')
+  const acc = val('acceptance')
+  const paths = val('allowed_paths')
+  const cardLines = [
+    title ? `- title：${title}` : '',
+    goal ? `- goal：${goal}` : '',
+    impl ? `- implementation：\n${bulletList(impl)}` : '',
+    acc ? `- acceptance：\n${bulletList(acc)}` : '',
+  ].filter(Boolean).join('\n')
+  const dedicatedFull = [
+    cardLines ? `### 任务卡要点（tasks/${taskId}.md 摘录）\n\n${cardLines}` : '',
+    Array.isArray(paths) && paths.length ? `### allowed_paths\n\n${paths.map(p => `- ${p}`).join('\n')}` : '',
+    `### 回源指引\n\n- design.md：${designPath}\n- 任务卡：${taskCardPath}`,
+  ].filter(Boolean).join('\n\n')
+
+  // ── 装配（稳定段在前、专属段在后）+ 字节预算 ──
+  const packTitle = `# execute 任务材料包：${taskId}`
+  const packNote = '> 两段式：稳定段（design 契约节原文摘录）在前、专属段（task 卡摘录）在后。\n> 只摘不译——正文均为源文件原文逐字摘录；与源文件冲突时以源文件为准，按锚点回源核对。'
+  const stableTitle = '## 稳定段（design 契约节原文摘录——跨任务稳定）'
+  const dedicatedTitle = `## 专属段（${taskId} 专属）`
+  const tailMarker = `…（专属段超限截尾——完整内容回源：${taskCardPath}）`
+  const joinParts = parts => parts.filter(Boolean).join('\n\n')
+  const assemble = (secs, dedicatedText) =>
+    joinParts([packTitle, packNote, stableTitle, ...secs, anchorsBlock, dedicatedTitle, dedicatedText])
+
+  let truncated = false
+  const sections = secBlocks.map(s => s.full)
+  let content = assemble(sections, dedicatedFull)
+
+  if (bytesOf(content) > EXEC_MATERIALS_MAX_BYTES) {
+    truncated = true
+    // ① 专属段尾部优先截：稳定段全量保留，专属段按剩余预算截尾
+    const clampDedicated = () => {
+      const head = assemble(sections, '')
+      const room = EXEC_MATERIALS_MAX_BYTES - bytesOf(head) - bytesOf('\n\n') - bytesOf(tailMarker) - 1
+      if (room < 0) return false
+      const sliced = byteSafeSlice(dedicatedFull, room)
+      content = head + '\n\n' + (sliced ? sliced + '\n' + tailMarker : tailMarker)
+      return true
+    }
+    if (!clampDedicated()) {
+      // ② 稳定段自身超限：按节优先级（接口定义 > 文件变更清单）低优先节先降为残节，逐节重试
+      for (let i = secBlocks.length - 1; i >= 0; i--) {
+        sections[i] = stubOf(secBlocks[i])
+        if (clampDedicated()) break
+      }
+    }
+    // ③ 终极兜底（双节皆残仍超限——仅病态锚点面可达）：字节安全截 + 锚点块强制保留
+    if (bytesOf(content) > EXEC_MATERIALS_MAX_BYTES && anchorsBlock) {
+      const cut = content.indexOf(anchorsBlock)
+      const before = (cut > 0 ? content.slice(0, cut) : content).replace(/\n+$/, '')
+      content = byteSafeSlice(before, EXEC_MATERIALS_MAX_BYTES - bytesOf('\n\n' + anchorsBlock)) + '\n\n' + anchorsBlock
+    } else if (bytesOf(content) > EXEC_MATERIALS_MAX_BYTES) {
+      content = byteSafeSlice(content, EXEC_MATERIALS_MAX_BYTES)
+    }
+  }
+
+  mkdirSync(materialsDir, { recursive: true })
+  const outPath = join(materialsDir, `${taskId}.md`)
+  writeFileSync(outPath, content, 'utf8')
+  return { path: outPath, bytes: bytesOf(content), truncated }
+}

package/src/run/archive-distill.js

@@ -48,8 +48,10 @@ export async function executeArchiveDistill({ cwd, specBase, changeName }) {
 
   // ── FR 索引提炼（2026-09-18-fr-index-l1 L1：稳定 id 发号+承接翻链；同 best-effort 降级语义）──
   try {
-    const { indexRequirements } = await import('../fr-index.js')
-    const fr = indexRequirements({ changeDir, knowledgeRoot, headHash })
+    const { indexRequirements, archiveDeliverableFiles } = await import('../fr-index.js')
+    // greenfield-bootstrap：供 deliverableFiles（design 表 ∪ apply-manifest）——此前缺供致域路由
+    // 退化为 design 清单单源，全泛化段时落 unmapped（R17 臂3 实证），与轻量道口径对齐。
+    const fr = indexRequirements({ changeDir, knowledgeRoot, headHash, deliverableFiles: archiveDeliverableFiles(changeDir) })
     const frWritten = Array.isArray(fr && fr.written) ? fr.written : []
     if (fr && fr.skipped) {
       console.log(`\nℹ️  FR 索引零输出：${fr.skipped}`)

package/src/run/bg-sync.js

@@ -52,6 +52,11 @@ const LOCK_STALE_MS = 15 * 60 * 1000;
 const LOG_TRUNCATE_THRESHOLD = 1_000_000;
 const LOG_TRUNCATE_KEEP = 512 * 1024;
 
+// 终态补推扫描窗口与上限（2026-09-23 quick ql-20260923-007）：候选取 last_active 倒序
+// 前 50 行（老终态缺位也收敛，但不全表扫描）；一轮最多补 3 条（防多缺位风暴挤爆预算）。
+const TERMINAL_SWEEP_CANDIDATES = 50;
+export const TERMINAL_SWEEP_MAX = 3;
+
 /** pid 活性探测（跨平台）：signal 0 探测；EPERM = 进程存在但属他户，保守按活。 */
 function isPidAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
@@ -178,6 +183,48 @@ export async function spawnBackgroundSync(cwd, changeName, platformOpts = {}, op
   return { status: 'spawned', logPath };
 }
 
+/**
+ * 归档终态补推扫描：DB 里 status=archived/deleted 且本地终态脏于平台镜像
+ * （last_local_modified_ts > last_synced_platform_ts，或从未同步）的变更名，last_active
+ * 倒序取前 TERMINAL_SWEEP_MAX 条。
+ *
+ * 背景（2026-09-22 session-fork-continuation 实证）：终态推送依赖归档后还有一轮
+ * triggerSync——bg 子进程 best-effort，spawn 失败/单飞锁竞态/会话在归档后戛然而止都会
+ * 吞掉最后一轮，本地已归档而平台镜像停在旧阶段（verify），此后再无命令碰该变更即永久
+ * 滞后。归档/删除收尾均 _touchLocalModified（change-registry 语义：本地状态推进），
+ * 谓词即「终态戳晚于最后一次成功推送」。补推幂等（sync() 对 archived/deleted 推终态+
+ * 墓碑，POST 幂等），任意后续命令触发的 bg 轮顺带收敛。
+ * 时钟口径：last_synced_platform_ts 是服务端时间，本地钟超前服务端时至多多补一轮幂等
+ * 推送（无副作用），且 synced 随每次成功推进，自愈。
+ * 库路径与 sync() 内 ProgressManager 同源（resolvePlatformSpecDir(cwd)：平台指针→向上
+ * 发现→cwd/.sillyspec 默认；platformOpts.specRoot 不进库路径——与 triggerSync 对齐），
+ * 保证扫的库就是主轮推的库；解析抛错（指针失效等）→ 空集跳过本轮（best-effort）。
+ */
+export async function collectTerminalSyncPending(cwd) {
+  const { resolvePlatformSpecDir, ProgressManager } = await import('../progress.js');
+  let specDir = null;
+  try { specDir = resolvePlatformSpecDir(cwd); } catch { return []; }
+  if (!specDir) return [];
+  if (!existsSync(join(specDir, '.runtime', 'sillyspec.db'))) return [];
+  const pm = new ProgressManager({ specDir });
+  const rows = pm._ensureDB(cwd).getDb().prepare(
+    `SELECT name, last_active, last_synced_platform_ts, last_local_modified_ts
+     FROM changes WHERE status IN ('archived','deleted')
+     ORDER BY last_active DESC LIMIT ${TERMINAL_SWEEP_CANDIDATES}`
+  ).all();
+  const pending = [];
+  for (const r of rows) {
+    if (!r.name) continue;
+    const synced = r.last_synced_platform_ts || '';
+    const local = r.last_local_modified_ts || '';
+    // 脏度戳必须在场（fail-closed）：D-013 之前的陈年行两戳皆空，无从判滞后——补推只会
+    // 给平台凭空造新行；synced 空而 local 在场 = 从未成功推送过但终态有据 → 补。
+    if (local && (!synced || local > synced)) pending.push(r.name);
+    if (pending.length >= TERMINAL_SWEEP_MAX) break;
+  }
+  return pending;
+}
+
 /**
  * 子侧入口（bootstrap 经 env 传参调起；env 注入默认值供测试覆盖）。
  *
@@ -224,6 +271,26 @@ export async function runBgSyncFromEnv(env = process.env) {
       break;
     }
   }
+  // 终态补推（2026-09-23 quick ql-20260923-007）：主轮收尾后扫 DB，补推「本地已达终态但
+  // 平台镜像滞后」的变更（session-fork 实证缺口）。幂等；主变更刚推过跳过；预算耗尽留下一轮。
+  try {
+    const pending = await collectTerminalSyncPending(cwd);
+    for (const name of pending) {
+      if (name === changeName) continue;
+      if (Date.now() + roundTimeoutMs > deadline) {
+        console.warn('[spec-sync-bg] 总预算用尽，终态补推剩余条目由下一轮 bg 接管');
+        break;
+      }
+      console.log(`[spec-sync-bg] 终态补推（本地终态未被平台镜像）: ${name}`);
+      try {
+        await triggerSync(cwd, name, platformOpts, { inline: true, timeoutMs: roundTimeoutMs });
+      } catch (e) {
+        console.warn(`[spec-sync-bg] 终态补推异常（best-effort，下轮重试）: ${(e && e.message) || e}`);
+      }
+    }
+  } catch (e) {
+    console.warn(`[spec-sync-bg] 终态补推扫描异常（best-effort）: ${(e && e.message) || e}`);
+  }
   console.log(`[spec-sync-bg] 后台同步完成 ${new Date().toISOString()}: ${changeName}`);
   removeBgSyncLock(runtimeRoot);
 }