sillyspec 3.28.3 → 3.28.5

package/src/archive-delta.js

@@ -34,6 +34,7 @@ import { parseDecisionDomains, loadModuleMap, deriveActualModules } from './desi
 import { parseModuleMapSimple } from './modules.js'
 import { scanBackendEndpoints } from './endpoint-extractor.js'
 import { diffEndpointSets } from './endpoint-baseline.js'
+import { resolveVerifyChangedFiles } from './verify-postcheck.js'
 
 // ---------------------------------------------------------------------------
 // 小工具（全部 fail-soft：读不到/解析失败 → null / []，不抛出）
@@ -460,3 +461,84 @@ export function writeLastDeltaSidecar(runtimeRoot, summary) {
     return { ok: false, reason: e && e.message ? e.message : String(e) }
   }
 }
+/**
+ * archive 三重核对（2026-09-09 ql-20260909-004，轮次经济学 §3.1 archive 收口机械化）：
+ * module-impact.md 矩阵记录 vs 真实变更文件 vs module-map 归属——机械比对 CLI 代算，
+ * agent 只裁决不一致项。只读，供 archive extract-module-impact 步 prompt 注入/命令消费。
+ * @returns {{ ok: boolean, mismatches: string[], impactFiles: string[], actualFiles: string[], summary: string }}
+ */
+export function auditModuleImpactAgainstDiff({ cwd, changeName, specDir = null }) {
+  const mismatches = []
+  const specBase = specDir || join(cwd, '.sillyspec')
+  const impactPath = join(specBase, 'changes', changeName, 'module-impact.md')
+  let impactText = null
+  try { impactText = readFileSync(impactPath, 'utf8') } catch { /* 缺失由降级路径处理 */ }
+  const actualFiles = (resolveVerifyChangedFiles(cwd, changeName, null, { includeWorkingTree: true, specBase: specDir || join(cwd, '.sillyspec') }) || [])
+    .map(f => String(f).replace(/\\/g, '/'))
+    .filter(f => !f.startsWith('.sillyspec/changes/'))
+  if (!impactText) {
+    return { ok: false, mismatches: ['module-impact.md 不存在（走 --init 降级路径）'], impactFiles: [], actualFiles, summary: `真实变更 ${actualFiles.length} 文件；无 module-impact 可核` }
+  }
+  // 矩阵反引号路径收集（启发式——advisory 注入用，非硬门真相源：无反引号表格格会漏，外部审核 P3-3）
+  const impactFiles = [...impactText.matchAll(/`([^`]+[.](?:js|mjs|ts|py|java|md|yaml))`/g)].map(m => m[1].split(String.fromCharCode(92)).join('/'))
+  const impactSet = new Set(impactFiles)
+  const actualSet = new Set(actualFiles)
+  const inDiffNotDoc = [...actualSet].filter(f => !impactSet.has(f))
+  const inDocNotDiff = [...impactSet].filter(f => !actualSet.has(f))
+  if (inDiffNotDoc.length > 0) mismatches.push(`diff 有而 module-impact 未列（${inDiffNotDoc.length}）：${inDiffNotDoc.slice(0, 5).join('、')}${inDiffNotDoc.length > 5 ? ' …' : ''}`)
+  if (inDocNotDiff.length > 0) mismatches.push(`module-impact 列而 diff 无（${inDocNotDiff.length}）：${inDocNotDiff.slice(0, 5).join('、')}${inDocNotDiff.length > 5 ? ' …' : ''}`)
+  // 第三重：module-map 归属一致性（2026-09-09 外部审核 P2-1——「三重核对」此前名实不符：
+  // 矩阵行的模块列 vs map 前缀推导——误标模块点名；未命中 map 的归 unmatched 提示不判红）
+  const moduleMisattrib = auditImpactModuleAttribution(impactText, specBase)
+  mismatches.push(...moduleMisattrib)
+  return {
+    ok: mismatches.length === 0,
+    mismatches,
+    impactFiles,
+    actualFiles,
+    summary: `module-impact ${impactFiles.length} 文件 × 真实 diff ${actualFiles.length} 文件 × map 归属：${mismatches.length === 0 ? '一致 ✓' : mismatches.length + ' 类不一致'}`,
+  }
+}
+
+/**
+ * 第三重核对（P2-1）：矩阵行「| <模块> | `文件` |」的模块列 vs _module-map.yaml 前缀推导。
+ * 只读 fail-soft：map 不可得 → 返回 []（前两重仍有效，注入文案会带 map 跳过注记）。
+ */
+function auditImpactModuleAttribution(impactText, specBase) {
+  try {
+    // 找 _module-map.yaml（docs/<p>/modules/ 扫描——detectModuleDocHealth 同款）
+    let mapText = null
+    const docsDir = join(specBase, 'docs')
+    if (existsSync(docsDir)) {
+      for (const d of readdirSync(docsDir)) {
+        const cand = join(docsDir, d, 'modules', '_module-map.yaml')
+        if (existsSync(cand)) { mapText = readFileSync(cand, 'utf8'); break }
+      }
+    }
+    if (!mapText) return []
+    const { parseModuleMapPaths } = require_module_impact()
+    const map = parseModuleMapPaths(mapText)
+    const deriveMod = (posixPath) => {
+      for (const [id, paths] of map) {
+        for (const pp of paths) {
+          if (pp.endsWith('/') ? posixPath.startsWith(pp) : (posixPath === pp || posixPath.startsWith(pp + '/'))) return id
+        }
+      }
+      return null
+    }
+    const out = []
+    for (const m of impactText.matchAll(/^\|\s*([^|]+?)\s*\|[^|]*`([^`]+)`/gm)) {
+      const recorded = m[1].trim()
+      const file = m[2].split(String.fromCharCode(92)).join('/')
+      if (recorded.startsWith('---') || recorded.startsWith('模块')) continue
+      const derived = deriveMod(file)
+      if (derived && recorded !== derived && recorded !== 'unmapped') {
+        out.push(`map 归属不一致：${file} 矩阵记「${recorded}」但 map 推导为「${derived}」——修正矩阵模块列或跑 modules rebuild`)
+      }
+    }
+    return out
+  } catch { return [] }
+}
+// 延迟引用（防环：module-impact 不反向依赖本模块）
+import * as _moduleImpactMod from './module-impact.js'
+function require_module_impact() { return _moduleImpactMod }

package/src/change-delete.js

@@ -9,7 +9,8 @@
  *   - DB：status='deleted'（与 archived 语义分离，DB 可直接审计区分，行保留不物理删）
  *   - 目录：changes/<name>/ 物理移除（git tracked 文件删除后照常 commit，历史仍可回溯）
  *   - worktree：复用 archiveWorktreeCleanup（有未 apply 变更时保留 worktree 只警告——
- *     不因删变更丢用户唯一副本的代码；顺带清 execute/stage-review runId marker）
+ *     不因删变更丢用户唯一副本的代码；顺带清 execute/stage-review runId marker
+ *     + 该变更的 runtime 取证（pruneArchivedChangeRuntime））
  *   - git：safeGit add -A 暂存目录删除（best-effort，对齐 archive CLI 下沉 git add）
  *   - 平台：triggerSync 推终态（sync.js 对 status='deleted' 上行墓碑，平台收敛软删）
  *

package/src/change-list.js

@@ -74,8 +74,13 @@ export function globMatch(str, pattern) {
  * @returns {boolean}
  */
 export function pathMatches(a, b) {
-  a = normalizePath(a)
-  b = normalizePath(b)
+  // 坑 platform-sync-progress-rollback-and-db-corruption 坑3：NEW: 前缀（待建文件标记）在
+  // 「比对」语义下剥除对齐——design 清单带 NEW: 的待建文件 vs task allowed_paths 裸路径 /
+  // 主仓脏文件，比的是目标文件而非「新建意图」，剥后两道门禁（brainstorm 幻觉核验要求加
+  // NEW: / plan 覆盖对账按裸路径匹配）不再互斥。仅在比对处剥：存在性核验（design-facts
+  // 的 NEW: 豁免）不走本函数、仍见原文前缀；target_files 解析器（plan-postcheck）本就剥。
+  a = normalizePath(a).replace(/^NEW:/, '')
+  b = normalizePath(b).replace(/^NEW:/, '')
   if (!a || !b) return false
   if (a === b) return true
   if (a.startsWith(b + '/') || b.startsWith(a + '/')) return true
@@ -254,7 +259,17 @@ function _parseFileListDetailed(designMdPath, { keepSillyspecDocs = false } = {}
     // 分类列表项：`- path` / `- \`path\``
     const listItem = line.match(/^\s*-\s+(.+)/)
     if (listItem) {
-      const filePath = normalizePath(listItem[1])
+      // 坑 brainstorm-gate-agent-unavailable-and-list-path-parse 坑2：列表项「路径：描述」
+      // 整行当路径 existsSync 假阴性（文件存在却报幻觉路径）——剥首个中/英冒号及之后描述。
+      // 仅列表分支剥、且冒号前段须 looksLikePath：normalizePath 全局剥会毁 Windows 绝对路径
+      // （C:\...），列表项是仓根相对路径无盘符，安全。
+      let rawItem = listItem[1]
+      const colonIdx = rawItem.search(/[：:]/)
+      if (colonIdx > 0) {
+        const head = rawItem.slice(0, colonIdx).trim()
+        if (looksLikePath(head)) rawItem = head
+      }
+      const filePath = normalizePath(rawItem)
       if (isPlaceholder(filePath) || (filePath.startsWith('.sillyspec/') && !(keepSillyspecDocs && filePath.startsWith('.sillyspec/docs/')))) continue
       if (!looksLikePath(filePath)) continue // 脏描述兜底
       const incidental = INCIDENTAL_RE.test(listItem[1])

package/src/change-risk-profile.js

@@ -5,6 +5,8 @@
  * 判定 5 级风险（doc-only / unit-sufficient / contract-required /
  * integration-critical / deployment-critical），产出门控验证需求。
  */
+import { readFileSync, statSync } from 'fs'
+import { join } from 'path'
 
 // ============ 向后兼容：旧的 INTEGRATION_CRITICAL_PATTERNS ============
 
@@ -292,10 +294,40 @@ export function checkIntegrationEvidence(verifyContent, requiredVerification, op
   const warnings = []
   const lower = (String(verifyContent || '') + '\n' + String(opts.extraEvidenceText || '')).toLowerCase()
 
-  // 字面证据正则从 VERIFICATION_NEEDS[k].literals 派生——与报错描述、prompt 事前契约严格同源,
-  // 杜绝历史上"描述说 A、正则查 B"的分叉(checkIntegrationEvidence 正则曾比 VERIFICATION_NEEDS
-  // 描述多匹配 集成测试/backend.*daemon/real.*integration 等)。literals 为空的 need
-  // (unit_tests/contract_tests)无字面校验,视为满足。
+  // ── v2 回执槽优先（2026-09-08-ir-verify-facts FR-04，D-003@v1）：「集成验证回执」槽在场时
+  // 走结构化一致性校验（绿判据：logPath 存在 × mtime ∈ verify 窗口 × 日志尾 200 行失败签名
+  // 扫描（噪声剔除）× exitCode===0），literals 降 legacy 回退（存量兼容）。
+  // extraEvidenceText（verify-services 回执注入）保留合并为补充候选文本。CLI 不代跑集成进程。──
+  if (Array.isArray(opts.runtimeEvidence) && opts.runtimeEvidence.length > 0) {
+    const greenReceipts = []
+    const receiptAudit = []
+    for (const r of opts.runtimeEvidence) {
+      const audit = auditRuntimeReceipt(r, opts)
+      receiptAudit.push(audit)
+      if (audit.green) greenReceipts.push(r)
+    }
+    const needsIntegration = requiredVerification.includes('real_daemon_backend_integration')
+    const needsLogEvidence = requiredVerification.includes('runtime_log_evidence')
+    const needsRealStartup = requiredVerification.includes('real_startup_once')
+    // 任一绿回执 = 结构化在场证据（claim 语义由 agent 声明，一致性由 CLI 校验）
+    const hasGreen = greenReceipts.length > 0
+    if (needsIntegration && !hasGreen) {
+      const bad = receiptAudit.filter(a => !a.green)
+      errors.push(`integration-critical 变更无绿回执（${bad.length} 条回执校验不过：${bad.map(a => a.reason).join('；') || '无有效回执'}）——绿判据：log 存在 × mtime ∈ verify 窗口 × 日志无失败签名 × exit 0`)
+    }
+    if (needsLogEvidence && !hasGreen) {
+      errors.push('integration-critical 变更的回执未通过一致性校验（Runtime Evidence 等价物）')
+    }
+    if (needsRealStartup && !hasGreen) {
+      errors.push('deployment-critical 变更无绿回执（真实启动验证）')
+    }
+    if (receiptAudit.some(a => !a.green && a.failSignatures > 0)) {
+      warnings.push('回执日志含失败签名（error/exception/traceback/fatal 行首命中，已剔除「0 errors」类良性行）——确认是否预期内失败')
+    }
+    return { ok: errors.length === 0, errors, warnings, receiptAudit, structured: true }
+  }
+
+  // ── legacy literals 回退（无槽存量格式）──
   const hasEvidence = (k) => {
     const n = VERIFICATION_NEEDS[k]
     if (!n || !n.literals || n.literals.length === 0) return true
@@ -335,5 +367,44 @@ export function checkIntegrationEvidence(verifyContent, requiredVerification, op
     }
   }
 
-  return { ok: errors.length === 0, errors, warnings }
-}
+  return { ok: errors.length === 0, errors, warnings, structured: false }
+}
+
+/**
+ * 单条回执一致性校验（FR-04 绿判据）。噪声剔除：签名行首匹配 + 剔除「0 errors」类良性行
+ * （本仓 verify-postcheck.js 测试输出解析先例同款）。fail-soft：校验依赖缺失（opts 无
+ * cwd/verifyStartAt）时只核 exitCode 与日志可读性，不假装跑了文件校验。
+ */
+function auditRuntimeReceipt(r, opts) {
+  const out = { claim: r && r.claim, logPath: r && r.logPath, green: false, logExists: null, mtimeInWindow: null, failSignatures: 0, exitCode: r && typeof r.exitCode === 'number' ? r.exitCode : null, reason: '' }
+  if (!r || !r.logPath) { out.reason = '回执缺 logPath'; return out }
+  let content = null
+  try {
+    const abs = opts.cwd ? join(opts.cwd, r.logPath) : r.logPath
+    content = readFileSync(abs, 'utf8')
+    out.logExists = true
+  } catch {
+    out.logExists = false
+    out.reason = `日志不存在：${r.logPath}`
+    return out
+  }
+  if (opts.verifyStartAt) {
+    try {
+      const startAt = new Date(opts.verifyStartAt).getTime()
+      out.mtimeInWindow = statSync(opts.cwd ? join(opts.cwd, r.logPath) : r.logPath).mtimeMs >= startAt - 60_000
+      if (!out.mtimeInWindow) { out.reason = `日志 mtime 早于 verifyStartAt（${r.logPath}）`; return out }
+    } catch { out.mtimeInWindow = null }
+  }
+  // 失败签名扫描（日志尾 200 行；行首匹配 + 良性计数行剔除）
+  const tail = content.split('\n').slice(-200)
+  const SIGNATURE_RE = /^(?:error|exception|traceback|fatal)\b/i
+  const BENIGN_RE = /\b0\s+(?:errors?|exceptions?|failures?)\b|no\s+(?:errors?|exceptions?)/i
+  for (const line of tail) {
+    if (SIGNATURE_RE.test(line.trim()) && !BENIGN_RE.test(line)) out.failSignatures++
+  }
+  if (out.failSignatures > 0) { out.reason = `日志含 ${out.failSignatures} 行失败签名（行首 error/exception/traceback/fatal，已剔除良性计数行）`; return out }
+  if (out.exitCode !== 0) { out.reason = `exitCode=${out.exitCode}（非 0 不可用作在场证据）`; return out }
+  out.green = true
+  out.reason = '绿回执（log 存在 × mtime 窗口 × 无失败签名 × exit 0）'
+  return out
+}

package/src/commit-suggest.js

@@ -18,7 +18,8 @@
  */
 import { existsSync, readdirSync, readFileSync, statSync } from 'fs'
 import { join } from 'path'
-import { gitQuiet } from './git-helper.js'
+import { DatabaseSync } from 'node:sqlite'
+import { gitQuiet, safeGit, stageArchiveArtifacts } from './git-helper.js'
 import { resolveSpecDir } from './run/shared.js'
 
 function listActiveChanges(specBase) {
@@ -222,3 +223,53 @@ export function collectCommitContext({ cwd, specDir = null }) {
     suggestion,
   }
 }
+
+
+/**
+ * archive 语境判定（P1-6，noai-ir-roadmap §4）：commit --apply 只在归档阶段内放行
+ * （changes.status=archived 或 current_stage=archive）——那里文件已验收、pathspec 显式
+ * （stageArchiveArtifacts 三路径）；其余阶段一律拒绝（agent 上下文「需人确认」是伪约束，
+ * 通用自动 git 在多会话仓是历史重灾区）。DB 直查避免 read 对注销变更的视图差异。
+ */
+export function resolveArchiveCommitScope({ cwd, specDir = null, changeName }) {
+  const specBase = resolveSpecDir(cwd, { specDir })
+  let status = null
+  let currentStage = null
+  try {
+    const db = new DatabaseSync(join(specBase, '.runtime', 'sillyspec.db'))
+    const row = db.prepare('SELECT status, current_stage FROM changes WHERE name = ?').get(changeName)
+    db.close()
+    if (row) { status = row.status; currentStage = row.current_stage }
+  } catch { /* DB 缺失/损坏 → 视为不可判定（拒绝） */ }
+  return { specBase, status, currentStage, inArchiveScope: status === 'archived' || currentStage === 'archive' }
+}
+
+/**
+ * 执行归档提交（P1-6）：语义来源（QUICKLOG/勾选 task → conventional message）× 显式
+ * pathspec（归档产物既有清单）。共享 index 安全：git add 用显式 pathspec（规则 18），
+ * git commit 带 `-- <paths>` pathspec 限定——同 main 并行会话暂存的其他文件不会被扫入
+ * （pathspec commit 只提交指定路径的内容，与暂存区其余部分无关）。
+ */
+export function applyArchiveCommit({ cwd, specDir = null, changeName }) {
+  const scope = resolveArchiveCommitScope({ cwd, specDir, changeName })
+  if (!scope.inArchiveScope) {
+    return { ok: false, reason: `变更 ${changeName} 不在归档语境（status=${scope.status}, current_stage=${scope.currentStage}）——commit --apply 只限归档阶段内使用（文件已验收 + pathspec 显式）；其余阶段请手写 message 手动提交` }
+  }
+  const cc = collectCommitContext({ cwd, specDir })
+  if (!cc.suggestion || !cc.suggestion.subject) {
+    return { ok: false, reason: '无语义来源（QUICKLOG/勾选 task 均无新条目）——请结合 git status 手写 message 后手动提交' }
+  }
+  const art = stageArchiveArtifacts(cwd)
+  const paths = (art.staged || []).filter((p) => existsSync(p))
+  if (paths.length === 0) {
+    return { ok: false, reason: '无归档产物路径可提交（stageArchiveArtifacts 候选全部不存在）' }
+  }
+  const add = safeGit(cwd, ['add', '--', ...paths])
+  if (add.error) return { ok: false, reason: `git add 失败: ${add.error}` }
+  const commitArgs = ['commit', '-m', cc.suggestion.subject]
+  if (cc.suggestion.body) commitArgs.push('-m', cc.suggestion.body)
+  commitArgs.push('--', ...paths)
+  const commit = safeGit(cwd, commitArgs)
+  if (commit.error) return { ok: false, reason: `git commit 失败: ${commit.error}`, paths }
+  return { ok: true, subject: cc.suggestion.subject, paths, output: commit.value }
+}

package/src/config-cat.js

@@ -1,3 +1,5 @@
+import { homedir } from 'os'
+import { sep } from 'path'
 /**
  * config-cat.js — local.yaml 实际值读取的权威路径解析器（`sillyspec config cat` 数据源）。
  *
@@ -39,9 +41,23 @@ export function resolveLocalYaml(dir, opts = {}) {
     candidates.push({ path: key, source })
   }
 
+  // home 拒绝守卫（e4f2855 resolveSpecDir 同款，2026-09-09 补到 local.yaml 候选链）：
+  // 起点在 home 子树内（如 Temp 下的测试 fixture）时，祖先链走到 home 层不得命中
+  // ~/.sillyspec/local.yaml——那是用户全局配置，不是本项目配置；register-repo 写侧
+  // 经 resolveLocalYamlWriteTarget 同链解析，误命中会把项目注册静默写进全局配置
+  // （local-register.test.mjs 实证）。
+  const home = homedir()
+  const originBelowHome = start !== home && start.startsWith(home + sep)
   if (opts.specBase) push(join(opts.specBase, 'local.yaml'), 'spec 根（--spec-dir/平台 pointer/最近 .sillyspec）')
+  let passedHome = false
   for (let d = start; ; d = dirname(d)) {
-    push(join(d, '.sillyspec', 'local.yaml'), 'cwd 祖先链（worktree 内向上命中主仓）')
+    // passedHome：经过 home 后不再入候选（resolveSpecDir e4f2855 同款语义）——套件隔离下
+    // HOME 与 fixture 可能同根（HOME=suiteTmp、fixture=suiteTmp/x），遍历越过 home 层后
+    // 仍会撞真实 home 的 ~/.sillyspec/local.yaml，须整段截断。
+    if (!(passedHome || (originBelowHome && d === home))) {
+      push(join(d, '.sillyspec', 'local.yaml'), 'cwd 祖先链（worktree 内向上命中主仓；home 层受守卫跳过）')
+    }
+    if (d === home) passedHome = true
     const parent = dirname(d)
     if (parent === d) break
   }

package/src/constants.js

@@ -93,7 +93,9 @@ export const AUXILIARY_STAGES = Object.freeze([
 // 供 command.js 判断 status/doctor 等查询型辅助阶段执行只读短路（FR-04 / D-005@v2）。
 export const READONLY_AUXILIARY_STAGES = Object.freeze([
   'status',
-  'doctor',
+  // doctor 移出（2026-09-09-doctor-noai D-001@v1）：阶段形态走状态机（noAI 诊断步 +
+  // agent 修复步——只读短路使 _cliAction 不可达）；顶层 sillyspec doctor 命令的只读
+  // 语义由 index.js case 头部拦截保真（--json/--status 先行分流）。
 ])
 
 // ── IR 严格模式闸门（change: 2026-09-07-ir-hardening，D-001@v1）──

package/src/decision-distill.js

@@ -69,8 +69,8 @@ function dispositionOf(entry) {
 /** decisions.md 列表字段标签 → entry 字段（兼容中英标签与中英冒号；其余字段仅留在 raw） */
 function applyField(entry, label, value) {
   switch (label) {
-    case 'type': entry.type = firstToken(value); break
-    case 'status': entry.status = firstToken(value); break
+    case 'type': case '类型': entry.type = firstToken(value); break
+    case 'status': case '状态': entry.status = firstToken(value); break
     case 'question': case '问题': entry.question = value; break
     case 'answer': case '答案': entry.answer = value; break
     case '锚点': case 'anchor': entry.anchor = value; break
@@ -111,6 +111,11 @@ export function parseDecisions(changeDir) {
     entries.push(cur)
   }
   for (const line of content.replace(/\r\n/g, '\n').split('\n')) {
+    // 条目开头两形态（坑 decision-flat-list-silent-zero，2026-09-10 驾驭小结第四批②，用户实证：
+    // 扁平列表格式 decisions.md 解析 0 条静默放行）：
+    //   ①标题式（模板正统）：`## D-001@v2 标题`，正文行 `- 字段：值`
+    //   ②扁平列表式（agent 实际产出）：`- D-001@v2：标题` 或 `- D-001@v2 | 状态：implemented | 模块域：x`
+    //     ——行内 ｜ 分段即字段；后续缩进子项 `  - 字段：值` 同样进字段
     const h = line.match(/^##\s+(D-\d+)(?:@v(\d+))?\s*(.*)$/)
     if (h) {
       flush()
@@ -118,15 +123,44 @@ export function parseDecisions(changeDir) {
       cur = { id: `${h[1]}@v${version}`, number: h[1], version, title: h[3].trim(), rawLines: [line] }
       continue
     }
+    const b = line.match(/^[-*]\s+(D-\d+)(?:@v(\d+))?\s*(?:[：:]\s*|\s+—\s*|\s*——\s*|\s*\|\s*)?\s*(.*)$/)
+    if (b) {
+      flush()
+      const version = b[2] ? parseInt(b[2], 10) : 1
+      cur = { id: `${b[1]}@v${version}`, number: b[1], version, title: '', rawLines: [line] }
+      // 行内 ｜ 分段字段：`- D-001@v1 标题 ｜ 状态：implemented ｜ 模块域：core`
+      // 首个非「字段：值」形态的分段为标题；每段独立过 applyField（未知标签忽略）。
+      const rest = (b[3] || '').trim()
+      const segs = rest.split(/[｜|]/).map(s => s.trim()).filter(Boolean)
+      const nonFieldSegs = []
+      for (const seg of segs) {
+        const inline = seg.match(/^([^：:]{1,20})[：:]\s*(.*)$/)
+        if (inline && FIELD_LABEL_RE.test(inline[1].trim())) {
+          applyField(cur, inline[1].trim().toLowerCase(), inline[2].trim())
+        } else {
+          nonFieldSegs.push(seg)
+        }
+      }
+      cur.title = nonFieldSegs.join(' ｜ ')
+      continue
+    }
     if (!cur) continue
     cur.rawLines.push(line)
-    const f = line.match(/^-\s+([^\s：:]+)\s*[：:]\s*(.*)$/)
-    if (f) applyField(cur, f[1].toLowerCase(), f[2].trim())
+    // 字段行：标题式条目的顶格 `- 字段：值` + 扁平式条目的缩进子项 `  - 字段：值`（缩进至多 4 空格，
+    // 不吞正文嵌套散文——字段标签白名单外的行不进字段，见 applyField default 忽略）
+    const f = line.match(/^(?: {1,4})?[-*]\s+([^\s：:]{1,20})\s*[：:]\s*(.*)$/)
+    if (f && FIELD_LABEL_RE.test(f[1])) applyField(cur, f[1].toLowerCase(), f[2].trim())
   }
   flush()
-  return { entries, missing: false }
+  // 0 条告警素材（消费方 distillIntoKnowledge 据此显式 warn，不再静默放行）：
+  // 文件非空、正文出现 D-xxx 形态却一条都没解析出 = 格式两种都不匹配，必须可见
+  const hasDecisionLike = /D-\d+/.test(content)
+  return { entries, missing: false, zeroWithContent: hasDecisionLike && entries.length === 0 }
 }
 
+/** applyField 认识的字段标签白名单（行内 ｜ 分段与缩进子项只按白名单进字段，散文误伤为零） */
+const FIELD_LABEL_RE = /^(type|types|status|question|问题|answer|答案|锚点|anchor|模块域|模块|domains|domain|否决理由|reject_reason|rejectreason|复潮条件|revisit_when|revisitwhen|supersedes|impacts|影响|normalized_requirement|状态|类型)$/i
+
 // ---------------------------------------------------------------------------
 // 域三级兜底（FR-03）
 // ---------------------------------------------------------------------------
@@ -434,6 +468,12 @@ export function distillIntoKnowledge(changeDir, knowledgeRoot, headHash, moduleI
   if (parsed.missing) {
     return { written: [], skipped: `decisions.md 不存在（${join(changeDir, 'decisions.md')}），零输出`, needsWait: null }
   }
+  // 0 条告警（坑 decision-flat-list-silent-zero，2026-09-10 驾驭小结第四批②）：文件有内容、
+  // 正文含 D-xxx 形态却 0 条可解析 = 标题式/扁平列表式两种格式都不匹配——此前静默放行
+  // （skipped 文案还误导成「解析 0 条，0 条入选」），决策知识凭空丢失不可见。显式 warn 留痕。
+  if (parsed.zeroWithContent) {
+    console.warn(`⚠️ decisions.md 存在且含 D-xxx 条目形态，但 0 条可解析（既非「## D-xxx」标题式、也非「- D-xxx@vN」扁平列表式）——格式不识别，本次提炼零输出；请核对格式（标题式 \`## D-001@v1 标题\` + 正文 \`- 字段：值\`，或扁平式 \`- D-001@v1：标题 ｜ 状态：implemented\`）`)
+  }
   const selected = parsed.entries.filter(e => e.selected)
   if (selected.length === 0) {
     return { written: [], skipped: `无入选条目（解析 ${parsed.entries.length} 条，0 条入选：scope/非五类 type/非 confirmed|accepted|rejected 状态均不入选），零输出`, needsWait: null }

package/src/decisions-io.js

@@ -0,0 +1,96 @@
+/**
+ * decisions-io.js（P1-5，noai-ir-roadmap §4）：decisions.md 的 CLI 单一写入者。
+ *
+ * 背景：decisions.md 此前由 agent 手拼自由 markdown，13 处解析点里它占两处
+ * （decision-distill parseDecisions × design-facts 镜像），历史事故全在「手写格式走样」：
+ * 扁平列表静默 0 条（decision-flat-list-silent-zero）、CRLF 状态行恒失败、字段标签拼写漂移。
+ * 单一写入者 = canonical 格式只此一家：标题式条目（`## D-001@v2 标题` + `- 字段：值`，
+ * 字段标签用 applyField 白名单的中文正统名），读取侧 parseDecisions 零改动双向兼容。
+ *
+ * 语义：
+ *   - upsertDecision：同 id@v 条目整块替换（幂等，重跑同输入零 diff）；新条目追加文末。
+ *     不碰 frontmatter 与其他条目；EOL 跟随原文件；原子写。
+ *   - 校验：number 形态 D-xxx、version 正整数、status/type 白名单外的值拒绝
+ *     （fail-fast——写入者先于解析者挡格式错误，这正是单一写入者的意义）。
+ *   - agent 仍可手写正文散文（决策动机等），但结构化字段一律走本写入者。
+ */
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { writeAtomicSync } from './fs-atomic.js'
+
+const STATUS_VALUES = new Set(['confirmed', 'accepted', 'implemented', 'rejected', 'proposed', 'superseded', 'draft'])
+const TYPE_VALUES = new Set(['architecture', 'compatibility', 'boundary', 'definition', 'process', 'scope'])
+
+/**
+ * canonical 条目渲染（正文散文行原样保留在 body 数组）。
+ * @param {{ number: string, version: number, title: string, body?: string[], status?: string, type?: string, question?: string, answer?: string, anchor?: string, domains?: string[], rejectReason?: string, revisitWhen?: string, supersedes?: string, impacts?: string, normalizedRequirement?: string }} d
+ * @returns {string} 条目 markdown 块（不含首尾空行）
+ */
+export function renderDecisionEntry(d) {
+  if (!d || !/^D-\d+$/.test(d.number || '')) throw new Error(`决策编号形态非法（期望 D-xxx，实得 ${JSON.stringify(d && d.number)}）`)
+  const version = parseInt(d.version, 10)
+  if (!Number.isInteger(version) || version < 1) throw new Error(`决策版本非法（期望正整数，实得 ${JSON.stringify(d.version)}）`)
+  if (d.status && !STATUS_VALUES.has(d.status)) throw new Error(`status 白名单外：${d.status}（合法：${[...STATUS_VALUES].join(' / ')}）`)
+  if (d.type && !TYPE_VALUES.has(d.type)) throw new Error(`type 白名单外：${d.type}（合法：${[...TYPE_VALUES].join(' / ')}）`)
+  const lines = [`## ${d.number}@v${version} ${String(d.title || '').trim()}`]
+  if (d.status) lines.push(`- 状态：${d.status}`)
+  if (d.type) lines.push(`- 类型：${d.type}`)
+  if (Array.isArray(d.domains) && d.domains.length > 0) lines.push(`- 模块域：${d.domains.join(', ')}`)
+  if (d.question) lines.push(`- 问题：${d.question}`)
+  if (d.answer) lines.push(`- 答案：${d.answer}`)
+  if (d.anchor) lines.push(`- 锚点：${d.anchor}`)
+  if (d.supersedes) lines.push(`- supersedes：${d.supersedes}`)
+  if (d.impacts) lines.push(`- 影响：${d.impacts}`)
+  if (d.rejectReason) lines.push(`- 否决理由：${d.rejectReason}`)
+  if (d.revisitWhen) lines.push(`- 复潮条件：${d.revisitWhen}`)
+  if (d.normalizedRequirement) lines.push(`- normalized_requirement：${d.normalizedRequirement}`)
+  for (const prose of (Array.isArray(d.body) ? d.body : [])) {
+    if (typeof prose === 'string' && prose.trim() !== '') lines.push(prose.trimEnd())
+  }
+  return lines.join('\n')
+}
+
+/**
+ * upsert 一条决策：同 id@v 整块替换，否则文末追加。返回 { path, action: 'replaced'|'appended' }。
+ * 文件不存在 → 以新文件创建（含空 frontmatter 占位不写——decisions.md 可无 frontmatter，
+ * 但本仓惯例有 author/created_at；创建时写最小 frontmatter 由调用方 flag 补充）。
+ */
+export function upsertDecision(changeDir, decision) {
+  const filePath = join(changeDir, 'decisions.md')
+  const block = renderDecisionEntry(decision)
+  const id = `${decision.number}@v${parseInt(decision.version, 10)}`
+  if (!existsSync(filePath)) {
+    const content = `# 决策记录\n\n${block}\n`
+    writeAtomicSync(filePath, content)
+    return { path: filePath, action: 'appended' }
+  }
+  const raw = readFileSync(filePath, 'utf8')
+  const eol = raw.includes('\r\n') ? '\r\n' : '\n'
+  const normalized = raw.replace(/\r\n/g, '\n')
+  const lines = normalized.split('\n')
+  const header = `## ${id} `
+  const startIdx = lines.findIndex((l) => l.startsWith(`## ${id} `) || l.trim() === `## ${id}`)
+  if (startIdx === -1) {
+    const next = normalized.replace(/\n*$/, '\n') + '\n' + block + '\n'
+    writeAtomicSync(filePath, eol === '\n' ? next : next.replace(/\n/g, '\r\n'))
+    return { path: filePath, action: 'appended' }
+  }
+  let endIdx = lines.length
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    if (lines[i].startsWith('## ')) { endIdx = i; break }
+  }
+  // 保留原条目正文散文（非「- 字段：值」白名单行）随替换块回填——CLI 拥有字段，散文归作者
+  const preservedProse = []
+  for (const line of lines.slice(startIdx + 1, endIdx)) {
+    const t = line.trim()
+    if (t === '' ) continue
+    if (/^(?: {1,4})?[-*]\s+(状态|类型|模块域|问题|答案|锚点|否决理由|复潮条件|影响)\s*[：:]/.test(t)) continue
+    if (/^(?: {1,4})?[-*]\s+(supersedes|impacts|normalized_requirement|status|type|domains|domain|question|answer|anchor|reject_reason|revisit_when)\s*[：:]/i.test(t)) continue
+    preservedProse.push(line)
+  }
+  const merged = { ...decision, body: [...(decision.body || []), ...preservedProse] }
+  const mergedBlock = renderDecisionEntry(merged)
+  const next = [...lines.slice(0, startIdx), ...mergedBlock.split('\n'), '', ...lines.slice(endIdx)].join('\n')
+  writeAtomicSync(filePath, eol === '\n' ? next : next.replace(/\n/g, '\r\n'))
+  return { path: filePath, action: 'replaced' }
+}

package/src/design-facts.js

@@ -261,6 +261,9 @@ export function generateDesignSkeleton({ changeName, decisionsText, author, now
   lines.push('---')
   lines.push(`author: ${String(author || '').trim() || 'TODO（git 用户名）'}`)
   lines.push(`created_at: ${String(now || '').trim() || 'TODO（ISO 时间）'}`)
+  // P2-e provenance 戳（noai-ir-roadmap §5）：CLI 骨架出品的可审计标记——铁律 8 收窄为
+  //「骨架优先，仅手写补文档才手填元数据」的依据（validateMetadata 未来可据此只认 CLI 戳）
+  lines.push(`generated_by: sillyspec-design-init`)
   lines.push('scale: large')
   lines.push('---')
   lines.push('')

package/src/dispatch/probe.js

@@ -128,26 +128,31 @@ export function detectPathAFromTools(tools) {
  *                                       拿（task-12 #5），拿不到则跳过越界校验（不判 unavailable）
  * @param {number} [opts.ttlMs]        - 负面缓存 TTL 覆盖（优先于 local.yaml）
  * @param {number} [opts.totalTimeoutMs] - 总超时覆盖（默认 25s，HUB-12a）
- * @returns {Promise<{ available: boolean, reason?: string }>}
+ * @param {string} [opts.cwd]           - local.yaml/env 定位根（默认 process.cwd()）。测试
+ *                                        注入干净 tmp 目录隔离「dev 仓自身已连平台」的环境
+ *                                        （坑 probe-no-config-cwd-leak：本仓 local.yaml 带 mcp
+ *                                        段时 no-config 用例读到真配置，同步快速路径判定漂移）
+ * @returns {Promise<{ available: boolean, reason?: string, daemonOnline?: boolean|null }>}
  */
-export async function probeSillyHub({ client, worktreePath, rootPath, ttlMs, totalTimeoutMs } = {}) {
+export async function probeSillyHub({ client, worktreePath, rootPath, ttlMs, totalTimeoutMs, cwd } = {}) {
+  const probeCwd = cwd || process.cwd();
   // 1. 同步快速路径：无 local.yaml mcp 段且 env 缺凭据即 unavailable（不发网络，零回归关键）。
   //    readMcpConfig 纯 fs + env 读（best-effort 不抛不发网络），返回 null = 两源都缺 → no-config。
-  if (!readMcpConfig(process.cwd())) {
+  if (!readMcpConfig(probeCwd)) {
     return { available: false, reason: 'no-config' };
   }
 
   // 2. 负面缓存命中（未过 TTL）→ 直接返回，不发网络（R-06 抖动期免反复探测）
-  const fp = configFingerprint(process.cwd());
+  const fp = configFingerprint(probeCwd);
   const cached = negativeCache.get(fp);
   if (cached && cached.expiresAt > Date.now()) {
     return cached.result;
   }
 
-  const cli = client || new SillyHubMcpClient({ cwd: process.cwd() });
+  const cli = client || new SillyHubMcpClient({ cwd: probeCwd });
   const cacheNegative = (reason) => {
     const result = { available: false, reason };
-    const ttl = resolveTtl(ttlMs, process.cwd());
+    const ttl = resolveTtl(ttlMs, probeCwd);
     negativeCache.set(fp, { result, expiresAt: Date.now() + ttl });
     return result;
   };
@@ -202,6 +207,23 @@ export async function probeSillyHub({ client, worktreePath, rootPath, ttlMs, tot
       setPathAProbeResult(false);
     }
 
+    // 3.6 daemon 在线层（2026-09-10 平台侧 P1-3 新工具 get_daemon_status）：daemon_online
+    // =false 是确定性「派了也无人认领」信号（spike 实证：无 daemon 认领时 worker 0.2s
+    // 快速失败 no_online_daemon）——正面探明，替代「真派发一次才知道」的浪费。fail-open
+    // 三态：true/false 明确；null（无工具=旧 backend / token 缺 read scope / 调用异常）不判
+    // unavailable，回退旧口径（可用性未知按可用走）。不进负面缓存（活状态随 daemon 起停
+    // 变化，与 worktree-outside-root 同类，非网络派生）。
+    let daemonOnline = null;
+    try {
+      if (typeof cli.getDaemonStatus === 'function') {
+        const st = await cli.getDaemonStatus();
+        if (st && typeof st.online === 'boolean') daemonOnline = st.online;
+      }
+    } catch { daemonOnline = null; }
+    if (daemonOnline === false) {
+      return { available: false, reason: 'daemon-offline', daemonOnline };
+    }
+
     if (worktreePath) {
       let effectiveRoot = rootPath;
       if (effectiveRoot === undefined) {
@@ -221,8 +243,9 @@ export async function probeSillyHub({ client, worktreePath, rootPath, ttlMs, tot
       }
     }
 
-    // 5. 全通过：不缓存正面结果，下次重新探测（让 daemon 恢复/退化及时反映）
-    return { available: true };
+    // 5. 全通过：不缓存正面结果，下次重新探测（让 daemon 恢复/退化及时反映）；
+    //    daemonOnline 透传（true/null——调用方可区分「探明在线」与「未知」）
+    return { available: true, daemonOnline };
   })();
 
   let timeoutId = null;