sillyspec 3.28.6 → 3.28.8

package/src/run/gates.js

@@ -485,8 +485,14 @@ export async function enforceReviewJsonGate(stageName, cwd, changeName, step, st
  * 若校验失败不回滚，DB 会与真实产物不一致（hook/doctor/下游阶段全部误判），
  * 且所有步骤都是 completed 时 agent 无法重新 --done（"没有待完成的步骤"）。
  * 此处将 stage 回滚为 in-progress，最后一步重置为 pending，供修复产物后重做。
+ *
+ * 批量乐观标记一并回滚（坑 execute-batch-rollback-half-state，2026-08-29 用户实证）：execute
+ * 批量完成（detectExecuteBatchFinish）把剩余步骤批量标 completed 后任一收尾 gate 失败，原先只
+ * 回滚 currentIdx → 落库「步骤 11 pending + 12-16 completed」半套状态，步骤序倒挂、要再补一次
+ * --done 才对齐。批量标记打 _batchAligned 戳（内存字段不落库），gate 失败 = 批量完成整体不成立，
+ * 戳上的步骤随当前步一起回滚 pending，下次 --done 满足条件再重新批量标记。
  */
-function rollbackStageCompletion(stageData, steps, currentIdx) {
+export function rollbackStageCompletion(stageData, steps, currentIdx) {
   // 辅助阶段在 validator 前已被重置为 pending（steps 也换成了新数组），不要覆盖
   if (stageData.status === 'completed') {
     stageData.status = 'in-progress'
@@ -496,6 +502,14 @@ function rollbackStageCompletion(stageData, steps, currentIdx) {
     steps[currentIdx].status = 'pending'
     steps[currentIdx].completedAt = null
   }
+  for (const s of steps) {
+    if (!s) continue
+    if (s._batchAligned && s.status === 'completed') {
+      s.status = 'pending'
+      s.completedAt = null
+    }
+    s._batchAligned = false
+  }
 }
 
 /**
@@ -511,7 +525,7 @@ function rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx,
   // friction 尾参（friction-signal-hint task-02）：gate 失败摩擦埋点标签 {type, detail}——各调用点
   // 按所属 gate 段传来源标签（审查两段走 review_rejected），未传兜底通用 gate-cascade。
   // recordFrictionEvent 自带静默降级（非法类型/写失败返回 null），不影响回滚/返回语义。
-  recordFrictionEvent({ cwd, changeName, platformOpts, ...(friction || { type: 'gate_rollback', detail: 'gate-cascade' }) })
+  void recordFrictionEvent({ cwd, changeName, platformOpts, ...(friction || { type: 'gate_rollback', detail: 'gate-cascade' }) })
   rollbackStageCompletion(stageData, steps, currentIdx)
   progress.lastActive = new Date().toLocaleString('zh-CN', { hour12: false })
   pm._write(cwd, progress, changeName)
@@ -646,7 +660,7 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
         const { createVerifyGateSnapshot } = await import('./gate-snapshot.js')
         verifyGateSnap = await createVerifyGateSnapshot({ cwd, changeName, specBase, platformOpts })
         if (verifyGateSnap) {
-          console.log(`🧪 Verify 实测隔离快照：HEAD + 本变更 ${verifyGateSnap.changeFileCount} 个文件${verifyGateSnap.sourceRoot ? '（overlay 自 worktree——本变更分支内容定向跑）' : ''}（并行会话脏文件不参与门判定）`)
+          console.log(`🧪 Verify 实测隔离快照（根：${verifyGateSnap.snapshotRoot}）：HEAD + 本变更 ${verifyGateSnap.changeFileCount} 个文件${verifyGateSnap.sourceRoot ? '（overlay 自 worktree——本变更分支内容定向跑）' : ''}（并行会话脏文件不参与门判定）`)
         }
       } catch { /* 快照链路异常 → 主仓现行为 */ }
     }
@@ -679,7 +693,11 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
       }
     } catch { /* fail-soft：回填失败不影响门禁 */ }
     if (testCheck.status === 'failed') {
-      if (verifyGateSnap) { try { verifyGateSnap.cleanup() } catch {} ; verifyGateSnap = null }
+      if (verifyGateSnap) {
+        try { const { printSnapshotFailureHint } = await import('./gate-snapshot.js')
+          printSnapshotFailureHint(verifyGateSnap) } catch { /* 提示失败不影响阻断 */ }
+        try { verifyGateSnap.cleanup() } catch {} ; verifyGateSnap = null
+      }
       console.error('\n❌ verify 阶段被阻断：verify-result.md 自报告通过，但 CLI 实测测试失败。')
       // 并行 WIP 归因鉴别（坑 verify-reconcile-foreign-wip）：单一实现迁至 verify-quality-scan.js
       // renderVerifyTestAttribution（P0-1 前置二：noAI 质量扫描失败路径与本 --done 路径共用，
@@ -700,13 +718,21 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
     if (lintCheck) {
       console.log(`\n♻️ Verify lint 对账：复用 noAI 质量扫描步的实测结果（代码指纹匹配，免重跑）`)
     } else {
-      lintCheck = runVerifyLintCheck({ cwd: gateCwd, specBase: gateSpecBase })
+      lintCheck = runVerifyLintCheck({ cwd: gateCwd, specBase: gateSpecBase, timeoutMs: verifyGateSnap ? 5 * 60 * 1000 : undefined })
+    // 快照 lint 超时回退主仓（2026-09-12 dogfood 两连实证：junction I/O 病态慢，3min/5min 均被
+    // 超时杀——主仓 60~110s 正常。按用户建议「自动回退」而非假败/advisory：主仓复跑保硬门，
+    // 并行噪声混入时失败输出带归属鉴定提示）
+      if (verifyGateSnap && lintCheck.status === 'failed' && /超时/.test(String(lintCheck.reason || ''))) {
+        console.warn('⚠️ 快照 lint 超时（node_modules junction I/O 慢）→ 主仓复跑 lint（并行噪声可能混入——失败先做归属鉴定）')
+        lintCheck = runVerifyLintCheck({ cwd, specBase })
+      }
       if (lintCheck.status !== 'skipped') {
         console.log(`\n⏳ Verify lint 对账：CLI 亲自执行 local.yaml 的 commands.lint…`)
       }
     }
     // 快照收尾（test+lint 两检查都已完成；parity/删除探针走主仓 git 事实不依赖快照）
     const usedSnapshot = Boolean(verifyGateSnap)
+    const usedSnapInfo = verifyGateSnap ? { snapshotRoot: verifyGateSnap.snapshotRoot, changeFileCount: verifyGateSnap.changeFileCount, sourceRoot: verifyGateSnap.sourceRoot } : null
     if (verifyGateSnap) { try { verifyGateSnap.cleanup() } catch {} ; verifyGateSnap = null }
     printVerifyLintCheck(lintCheck)
     // lint 硬门（2026-09-09 升硬：观察期 14 次 5 败全真阳性，pre-push 本就硬拦——fail-fast 前移；
@@ -714,6 +740,10 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
     const { shouldBlockVerifyLint } = await import('../verify-postcheck.js')
     if (shouldBlockVerifyLint(lintCheck)) {
       console.error('\n❌ verify 阶段被阻断：CLI 亲自实测 lint 失败（agent 的 lint 自报告与实测不符时以实测为准）。')
+      if (usedSnapInfo) {
+        try { const { printSnapshotFailureHint } = await import('./gate-snapshot.js')
+          printSnapshotFailureHint(usedSnapInfo) } catch { /* 提示失败不影响阻断 */ }
+      }
       if (lintCheck.outputTail) {
         const tail = lintCheck.outputTail.split('\n').slice(-8).join('\n')
         console.error('   输出（末尾）：')

package/src/run/prompt.js

@@ -22,7 +22,8 @@ import { basename, join } from 'node:path'
 import { existsSync, readFileSync, mkdirSync, readdirSync } from 'node:fs'
 import { writeAtomicSync } from '../fs-atomic.js'
 import { stageRegistry } from '../stages/index.js'
-import { resolvePromptIncludes, resolveRuntimeRoot, safeGit, WAIT_MARKER_RE, QUICK_SID_RE } from './shared.js'
+import { resolvePromptIncludes, resolveRuntimeRoot, safeGit, parsePorcelainPath, WAIT_MARKER_RE, QUICK_SID_RE, triggerStepStartSync } from './shared.js'
+import { renderSemanticGuardBlock, readSemanticGuardEnabled } from '../semantic-guard.js'
 import { renderStageContract } from '../stage-contract-spec.js'
 import { nowWallClock } from '../datetime.js'
 import { parseModuleMapSimple } from '../modules.js'
@@ -181,6 +182,44 @@ export function buildQuickContextDigest(specBase, projectName) {
   }
 }
 
+/**
+ * quick step1 语义护栏进场注入拼装（task-05，FR-03，D-001@v1 模块四）：开关 → 候选文件采集 →
+ * renderSemanticGuardBlock 反查。候选 = 会话声明文件（guard.allowedFiles，readQuickGuardField
+ * 同源读取：session guard 优先 / legacy 单文件回退）∪ git status --porcelain 脏文件
+ * （parsePorcelainPath 同款解析口径：引号剥离 / -> rename / 反斜杠归一），反斜杠归一去重封顶 20。
+ * 返回 ''（开关关 / 无候选 / 双零命中——prompt 与现状字节一致，零命中静默）或 advisory 段；
+ * 全链 fail-soft：异常返回单行降级说明，不阻断 quick 启动。导出供注入单测直测
+ * （test/semantic-guard-prompt-inject.test.mjs）。
+ */
+export function buildQuickSemanticGuardInjection({ specBase, cwd, changeName } = {}) {
+  try {
+    // 开关首行（Grill X-012）：false 直接零输出——不采候选文件、不跑反查（开关语义全停非半停）
+    if (!readSemanticGuardEnabled(specBase)) return ''
+    // 会话声明文件（--files 落 guard.allowedFiles；缺失 / 形态异常按空）
+    const declaredRaw = readQuickGuardField(changeName, specBase, 'allowedFiles')
+    const declared = Array.isArray(declaredRaw) ? declaredRaw : []
+    // git 脏文件：porcelain 解析同源 quick-audit（trim:false——首列前导空格是状态码，trim 会削掉
+    // 致 parsePorcelainPath 丢首字符；.sillyspec/ 运行时产物过滤同款——候选面是代码文件）
+    let dirty = []
+    const statusResult = safeGit(cwd, ['status', '--porcelain'], { trim: false })
+    if (!statusResult.error) {
+      dirty = (statusResult.value || '').split('\n').filter(Boolean)
+        .map(l => parsePorcelainPath(l))
+        .filter(Boolean)
+        .filter(f => !f.startsWith('.sillyspec/'))
+    }
+    // 去重（反斜杠归一后；renderSemanticGuardBlock 内侧亦有同款归一，此处为封顶前的口径）
+    // 封顶 20 —— 与 collectRecentForeignDelivery 内侧文件封顶同数
+    const candidateFiles = [...new Set(
+      [...declared, ...dirty].map(f => String(f || '').trim().replace(/\\/g, '/')).filter(Boolean)
+    )].slice(0, 20)
+    if (candidateFiles.length === 0) return ''
+    return renderSemanticGuardBlock({ specBase, cwd, candidateFiles, currentChange: changeName })
+  } catch (e) {
+    return `【语义护栏】注入失败（${e && e.message ? e.message : e}）——跳过反查，不阻断本步骤；需要时自查 knowledge/INDEX.md 与 git log`
+  }
+}
+
 // parseModuleMapSimple 复用 modules.js 的 canonical 实现（合并历史 copy-paste 副本，2026-08-07；
 // 无循环依赖：modules.js 仅 import fs/path/db.js，prompt.js → modules.js 单向）。
 /**
@@ -270,6 +309,14 @@ export async function outputStep(stageName, stepIndex, steps, cwd, changeName, d
     return false
   }
 
+  // X3 渲染侧接线（2026-08-29-change-delete-closure-and-spec-pull 遗留活跃坑收口；曾因并行
+  // 会话提交丢弃一次，2026-09-12 复检重接）：步骤 prompt 渲染即步骤起点——补推一次 progress
+  // 刷新平台 last_pushed_at（停滞判定不再把长步骤误报为「停滞」）。不 await：prompt 渲染不被
+  // 网络阻塞；未连接平台静默 / quick 会话降级跳过 / 8s 熔断 / 失败只 warn，契约全在
+  // triggerStepStartSync 内（shared.js docstring 即本接线点的说明），Node 事件循环保证在飞
+  // POST 落地后进程才退出。
+  triggerStepStartSync(cwd, changeName, platformOpts)
+
   // ── 首个 agent 可见步索引（「首步一次建立」类注入的锚点）──
   // step0 为 noAI（brainstorm/execute/verify 的 step1「进度确认」，2026-09-07）时不渲染 prompt，
   // persona/护栏/完成契约/铁律/平台路径约束等 step0 专属注入须顺延到首个渲染步，否则整段丢失
@@ -1061,6 +1108,19 @@ export async function outputStep(stageName, stepIndex, steps, cwd, changeName, d
     }
   }
 
+  // ── 语义护栏进场注入（task-05，FR-03，D-001@v1 模块四）──
+  // 判定口径独立：与上方模块上下文注入同锚（quickFirstStep——quick step1「理解任务」），不嵌进
+  // {QUICK_CONTEXT_DIGEST} 占位符守卫内——模板改版去占位符时护栏静默失效（plan 审查 N2）。
+  // 非空追加到 step1 prompt 末尾；空串（开关关 / 零命中）prompt 与现状字节一致（零命中静默）。
+  // 渲染层注入，src/stages/quick.js 模板零变更（design 明确不改清单）。全链 fail-soft 见 helper。
+  if (quickFirstStep) {
+    const sgSpecBase = resolvePromptSpecBase(platformOpts, cwd)
+    const semanticGuardBlock = buildQuickSemanticGuardInjection({ specBase: sgSpecBase, cwd, changeName })
+    if (semanticGuardBlock) {
+      promptText = promptText + '\n\n' + semanticGuardBlock
+    }
+  }
+
   // 平台模式 prompt 自检：确保没有裸相对输出路径
   // 只匹配正向写入指令中的裸路径，避免误杀「禁止写入 .sillyspec/」等安全说明
   if ((platformOpts?.specRoot || platformOpts?.runtimeRoot) && stageName === 'scan') {

package/src/run/quick-audit.js

@@ -13,6 +13,7 @@
  */
 import { join } from 'node:path'
 import { parsePorcelainPath, safeGit } from './shared.js'
+import { collectRecentForeignDelivery, detectAssertionRewrites, readSemanticGuardEnabled } from '../semantic-guard.js'
 
 /**
  * 打印 quick 完成审计结论（按 review.status 输出 SAFE/WARNING/BLOCKED）。
@@ -136,6 +137,17 @@ export function printQuickAuditReview(review) {
     }
     console.warn(`   quick 不强制文档同步，欠账已随本条 QUICKLOG「审计：」行落盘（可事后追溯）。若改动触及接口/契约，建议顺手同步模块文档。`)
   }
+  // spec 共享面他者噪声（坑 foreign-spec-churn-fail-closed）：并行会话归档移动/文档收尾的
+  // 删除与 EOL-only 假 M——软警告点名归因，不再逼 --allow-delete/--allow-new 解锁。
+  if (review.foreignSpecChurn && review.foreignSpecChurn.length > 0) {
+    console.warn(`⚠️ spec 共享面 ${review.foreignSpecChurn.length} 个非本会话声明的删除（.sillyspec/ docs/，疑似并行会话归档移动/收尾——归其会话收口，本会话不阻断）：`)
+    for (const f2 of review.foreignSpecChurn.slice(0, 6)) console.warn(`   - ${f2}`)
+    if (review.foreignSpecChurn.length > 6) console.warn(`   … 共 ${review.foreignSpecChurn.length} 个`)
+  }
+  if (review.eolOnlyFiles && review.eolOnlyFiles.length > 0) {
+    console.warn(`⚠️ ${review.eolOnlyFiles.length} 个文件仅行尾重写（内容零变化，gen:types/编辑器 CRLF 假 M——已剔出本会话审计）：${review.eolOnlyFiles.slice(0, 5).join('、')}${review.eolOnlyFiles.length > 5 ? ' 等' : ''}`)
+    console.warn(`   根治：.gitattributes 声明 text=auto eol=lf（或按文件类型钉死），生成器重写不再制造假 M`)
+  }
   if (review.docsCheckHint && review.docsCheckHint.invalid > 0) {
     console.warn(`\n📎 文档引用失效（docs check）：本次改动的文档含 ${review.docsCheckHint.invalid}/${review.docsCheckHint.total} 处失效 file:line 引用。`)
     // 逐条指名（2026-09-11 用户实证：只报计数不指名哪处，四轮复现才定位——门禁输出
@@ -242,6 +254,32 @@ export async function resolveQuickLinkedChanges({ pm, cwd, specDir, quickFiles,
 
 // ============ quick --done test+lint 硬门禁（2026-09-02 跨 agent 工单 P0-2）============
 
+/**
+ * 语义护栏命中组装（change: 2026-09-11-cross-change-decision-guard，task-06，FR-04，
+ * D-001@v1）：断言重写检测 ∩ 近因他者交付归因 → hits 清单，gate 内一行调用拼进返回对象。
+ * 单独抽出导出是为了可测性（runQuickTestLintGate 会真跑 test/lint 命令，检测组装层
+ * 独立测可避免测试里真跑 npm test——卡内可测性豁免）。
+ * - 步骤 0 总开关：readSemanticGuardEnabled false → 跳过检测，hits 恒空（fail-open 同 task-03）
+ * - 纯新增断言（detect 不命中）/ 无他者归因标记 / 非测试文件 → 落不到 hits
+ * - WARNING 级非阻断：本函数只组装数据，不参与 gate action/failed 判定
+ * @param {{ cwd?: string, specBase?: string, files?: string[], changeName?: string|null }} opts
+ * @returns {{ hits: Array<{ file: string, deliveredBy: string, sampleLines: string[] }> }}
+ */
+export function buildSemanticGuardHits({ cwd, specBase, files, changeName } = {}) {
+  if (!readSemanticGuardEnabled(specBase)) return { hits: [] }
+  const rewrites = detectAssertionRewrites({ cwd, files: Array.isArray(files) ? files : [] })
+  if (Object.keys(rewrites).length === 0) return { hits: [] }
+  // 归因只查断言命中文件（省 git log 调用；collectRecentForeignDelivery 内部封顶 20 文件）
+  const delivery = collectRecentForeignDelivery({ cwd, files: Object.keys(rewrites), currentChange: changeName })
+  const hits = []
+  for (const file of Object.keys(rewrites)) {
+    // 无归因不点名：纯新增断言 / 无标记提交 / 交付者是本变更（currentChange 透传跳过）同落空
+    if (!delivery[file]) continue
+    hits.push({ file, deliveredBy: delivery[file], sampleLines: rewrites[file] })
+  }
+  return { hits }
+}
+
 /**
  * quick --done 内置 test+lint 实测门禁：把 CLAUDE.md 规则 8「触及 src/test 的改动先
  * npm test + npm run lint」从 agent 自律下沉为 CLI 卡点。
@@ -265,8 +303,11 @@ export async function resolveQuickLinkedChanges({ pm, cwd, specDir, quickFiles,
  * @param {string} opts.specBase - .sillyspec 目录（local.yaml 读取源，信任边界见 runVerifyTestCheck SEC-02 注释）
  * @param {string[]} [opts.changedFiles] - 审计口径的本轮变更文件（仓库根相对 POSIX 路径；空/null → 回退 declaredFiles）
  * @param {string[]} [opts.declaredFiles] - 会话声明边界（guard.allowedFiles；changedFiles 为空时的兜底判定源）
- * @param {string} [opts.changeName] - quick 会话名（evidence-auto 策略解析用）
- * @returns {Promise<{action:'pass'|'fail'|'skip', failed:string[], reason:string, test:object|null, lint:object|null}>}
+ * @param {string} [opts.changeName] - quick 会话名（evidence-auto 策略解析用 + 语义护栏归因 currentChange 透传）
+ * @returns {Promise<{action:'pass'|'fail'|'skip', failed:string[], reason:string, test:object|null, lint:object|null,
+ *   semanticGuard?:{hits:Array<{file:string,deliveredBy:string,sampleLines:string[]}>}}>}
+ *   semanticGuard 仅检测跑过（三条早退 skip 路径不跑检测、无字段）时挂载；WARNING 级
+ *   非阻断——action/failed 判定不受它影响（调用方 complete-handlers.js 只读 action/failed，零改动）。
  */
 export async function runQuickTestLintGate({ cwd, specBase, changedFiles = [], declaredFiles = [], changeName = null }) {
   if (process.env.SILLYSPEC_QUICK_TEST_GATE === 'skip') {
@@ -284,6 +325,13 @@ export async function runQuickTestLintGate({ cwd, specBase, changedFiles = [], d
     return { action: 'skip', failed: [], reason: `纯 doc/配置改动（${files.length} 个文件均未触及 src/test，规则 8 语义跳过 test+lint）`, test: null, lint: null }
   }
 
+  // ── 语义护栏检测（task-06，FR-04 断言重写 WARNING，D-001@v1 非阻断）──
+  // 三条早退（env skip / 无文件 / 纯 doc）已在上文 return，检测不跑——语义一致。
+  // 检测对主仓 cwd 执行而非 gateCwd 隔离快照（下方才建快照）：检测对象是本会话工作树
+  // 未提交改动（git diff HEAD 须见它），快照语义是 test/lint 实测隔离——两者不同层
+  // （Grill X-001 附注）。specBase 同理用主仓的（快照副本 local.yaml 不参与开关判定）。
+  const semanticGuard = buildSemanticGuardHits({ cwd, specBase, files, changeName })
+
   const { runVerifyTestCheck, runVerifyLintCheck } = await import('../verify-postcheck.js')
 
   // ── 隔离快照执行（2026-09-10 驾驭小结第六批②，用户实证「lint 实测对账在主仓跑被并行
@@ -301,16 +349,28 @@ export async function runQuickTestLintGate({ cwd, specBase, changedFiles = [], d
       if (snapshot) {
         gateCwd = snapshot.snapshotRoot
         gateSpecBase = join(snapshot.snapshotRoot, '.sillyspec')
-        console.log(`🧪 门禁隔离快照：HEAD + 本会话 ${snapshot.overlaid} 个文件（并行会话脏文件不参与判定）`)
+        console.log(`🧪 门禁隔离快照（根：${snapshot.snapshotRoot}）：HEAD + 本会话 ${snapshot.overlaid} 个文件（并行会话脏文件不参与判定）`)
       }
     } catch { /* 快照链路异常 → 主仓现行为 */ }
   }
   try {
     const test = runVerifyTestCheck({ cwd: gateCwd, specBase: gateSpecBase, changeName })
-    const lint = runVerifyLintCheck({ cwd: gateCwd, specBase: gateSpecBase })
+    let lint = runVerifyLintCheck({ cwd: gateCwd, specBase: gateSpecBase, timeoutMs: snapshot ? 5 * 60 * 1000 : undefined })
+    // 快照 lint 超时回退主仓（2026-09-12 dogfood 两连实证：junction I/O 病态慢，3min/5min 均被
+    // 超时杀——主仓 60~110s 正常。按用户建议「自动回退」而非假败/advisory：主仓复跑保硬门，
+    // 并行噪声混入时失败输出带归属鉴定提示）
+    if (snapshot && lint.status === 'failed' && /超时/.test(String(lint.reason || ''))) {
+      console.warn('⚠️ 快照 lint 超时（node_modules junction I/O 慢）→ 主仓复跑 lint（并行噪声可能混入——失败先做归属鉴定）')
+      lint = runVerifyLintCheck({ cwd, specBase })
+    }
     const failed = []
     if (test.status === 'failed') failed.push('test')
     if (lint.status === 'failed') failed.push('lint')
+    if (failed.length > 0 && snapshot) {
+      try { const { printSnapshotFailureHint } = await import('./gate-snapshot.js')
+        printSnapshotFailureHint({ snapshotRoot: snapshot.snapshotRoot, changeFileCount: snapshot.overlaid, sourceRoot: snapshot.sourceRoot || null }, { offEnv: 'SILLYSPEC_QUICK_GATE_SNAPSHOT_OFF' })
+      } catch { /* 提示失败不影响门禁语义 */ }
+    }
     return {
       action: failed.length > 0 ? 'fail' : 'pass',
       failed,
@@ -319,6 +379,8 @@ export async function runQuickTestLintGate({ cwd, specBase, changedFiles = [], d
         : `触及 src/test 共 ${codeFiles.length} 个文件，test+lint 实测通过（或未配置命令自动跳过）${snapshot ? '（隔离快照口径：并行会话脏文件不计入）' : ''}`,
       test,
       lint,
+      // 语义护栏 WARNING（task-06）：只增可选字段，action/failed 判定与调用方读取面均不受影响
+      semanticGuard,
     }
   } finally {
     if (snapshot) { try { snapshot.cleanup() } catch { /* 清理失败不连坐门禁结论 */ } }
@@ -350,4 +412,18 @@ export function printQuickTestLintGate(gate) {
   } else {
     console.log(`\n✅ quick test+lint 门禁 — PASS（${gate.reason}）`)
   }
+
+  // 语义护栏 WARNING（task-06 / FR-04，非阻断——D-001@v1：误报校准数据为零先 advisory，
+  // 复潮条件：误报率实证后可升 block）：他者近因交付的测试文件既有断言行被改 → 点名
+  // 文件 + 交付变更 + 被改样例行（上游 detectAssertionRewrites 已封顶 5/文件，渲染侧
+  // 再 slice(0,5) 兜底）。hits 空 / 字段缺失（三条早退 skip 路径不跑检测）→ 零输出。
+  const sgHits = gate.semanticGuard && Array.isArray(gate.semanticGuard.hits) ? gate.semanticGuard.hits : []
+  if (sgHits.length > 0) {
+    console.warn(`\n⚠️ 语义护栏 — 断言重写 WARNING（非阻断）：他者近因交付的测试文件既有断言被改`)
+    for (const h of sgHits) {
+      console.warn(`   - ${h.file} ← ${h.deliveredBy} 交付`)
+      for (const s of (h.sampleLines || []).slice(0, 5)) console.warn(`       被改: ${String(s).trim()}`)
+    }
+    console.warn(`   ➜ 若确需重写：重写理由写进 quicklog --solution（--done 四参数收尾）；并复查 ${[...new Set(sgHits.map(h => h.deliveredBy))].join('、')} 的关联决策——勿以改断言重定义绿灯。`)
+  }
 }

package/src/run/shared.js

@@ -299,7 +299,7 @@ export function detectWorktreeSpecDrift(specBase) {
   const seg = resolve(specBase).split(sep)
   // specBase 恒以 .sillyspec 结尾(command.js specBase=join(cwd,'.sillyspec'))。worktree 副本形如
   // <mainRepo>/.sillyspec/.runtime/worktrees/<change>/.sillyspec —— 尾段也须是 .sillyspec,
-  // 否则 worktree 根目录本身(<.../worktrees/<change>)会被误判(它不是 spec,不会作 specBase 传入)。
+  // 否则 worktree 根目录本身(<.../worktrees/<change>>)会被误判(它不是 spec,不会作 specBase 传入)。
   if (seg[seg.length - 1] !== '.sillyspec') return null
   for (let i = 0; i + 3 < seg.length; i++) {
     if (seg[i] === '.sillyspec' && seg[i + 1] === '.runtime' && seg[i + 2] === 'worktrees') {
@@ -317,6 +317,33 @@ export function detectWorktreeSpecDrift(specBase) {
   return null
 }
 
+/**
+ * 判定「目录在 sillyspec 管理的隔离 worktree 内」（坑 worktree-cwd-silent-split，2026-08-29 用户实证：
+ * Bash cwd 残留两次误在 worktree 内跑 sillyspec——第一次走 status 类命令完全静默，进度险些写进
+ * worktree 副本 .sillyspec 与主仓进度库分裂）。
+ *
+ * 与 detectWorktreeSpecDrift 的分工：那边判 specBase（恒以 .sillyspec 结尾，runCommand 内自动
+ * 锚定用，只覆盖 plan/execute/verify/archive 四 stage）；这边判任意目录（CLI 入口硬拦用，目录
+ * 可以是 worktree 根或其任意子目录，无尾段要求）。
+ *
+ * @param {string} dir 目标目录（通常为 process.cwd() 或 --dir 显式值）
+ * @returns {{ changeName: string, mainRepoRoot: string, worktreeRoot: string } | null} null=不在 worktree 内
+ */
+export function detectCwdInsideWorktree(dir) {
+  if (!dir) return null
+  const seg = resolve(dir).split(sep)
+  for (let i = 0; i + 3 < seg.length; i++) {
+    if (seg[i] === '.sillyspec' && seg[i + 1] === '.runtime' && seg[i + 2] === 'worktrees' && seg[i + 3]) {
+      return {
+        changeName: seg[i + 3],
+        mainRepoRoot: seg.slice(0, i).join(sep),
+        worktreeRoot: seg.slice(0, i + 4).join(sep),
+      }
+    }
+  }
+  return null
+}
+
 /**
  * 统一解析 .runtime 根目录（坑 execute-runs-isolation）。
  *
@@ -791,14 +818,15 @@ export async function triggerSync(cwd, changeName, platformOpts = {}, opts = {})
  * 与 triggerSync 同款契约：quick 会话降级跳过（无 progress 实体）、未连接平台在
  * sync() 内部静默跳过、8s 总熔断（raceWithAbort + abort 在飞请求）、失败只 warn 不抛。
  *
- * 接线说明（本变更 allowed_paths 约束）：步骤 prompt 渲染点（run/stage.js outputStep
- * 前段 / run/prompt.js）不在本变更可改文件集内——本导出即「步骤开始钩子」本体，
- * 渲染侧一行 `triggerStepStartSync(cwd, changeName, platformOpts)` 的接线由后续
- * 变更补上；execute 阶段的任务粒度信号已由 X4（stages/execute.js Wave prompt
+ * 接线说明：已接线——run/prompt.js outputStep 步骤渲染前段 fire-and-forget 调用本钩子
+ * （task-13 当时 allowed_paths 不含渲染层，遗留活跃坑由 2026-08-29 docs/sillyspec
+ * 定期收口补上）；execute 阶段的任务粒度信号另由 X4（stages/execute.js Wave prompt
  * 每任务上报指引）覆盖。
  */
 export async function triggerStepStartSync(cwd, changeName, platformOpts = {}, opts = {}) {
   try {
+    // 无 changeName（渲染层个别路径/测试 fixture）直接静默——sync(null) 只会打 warn 噪音
+    if (!changeName) return
     const tsSpecBase = platformOpts?.specRoot || join(cwd, '.sillyspec')
     if (changeName && QUICK_SID_RE.test(changeName) && !existsSync(join(tsSpecBase, 'changes', changeName))) {
       return // quick 会话无 progress 实体（与 triggerSync 同判），无步骤可报
@@ -948,16 +976,20 @@ export function warnApprovalUnknown(cwd, changeName, reason) {
 /**
  * 审批检查：execute 阶段启动前检查（W6 Step8a 从 run.js 搬入，runStage + runAutoMode 共用）。
  * 平台模式走自己的链路，跳过；否则 await import sync.js。
+ * 返回语义：null = 平台模式有意跳过；{status:'unknown'} = 检查链路意外失败——调用方走
+ * warnApprovalUnknown 横幅 + approval-unknown.log 留痕（HUB-07）。异常折叠成 null 会绕过
+ * unknown 留痕静默放行（2026-09-11 审查）。
  * @returns {{ status: string, reason?: string } | null}
- */export async function checkApproval(cwd, changeName, platformOpts = {}) {
+ */export async function checkApproval(cwd, changeName, platformOpts = {}, { loadSyncMod = null } = {}) {
   // 平台模式不需要 CLI 内置审批检查；自指回环（repo-native junction）按本地模式处理
   if (isPlatformMode(platformOpts, cwd)) return null
+  const load = loadSyncMod || (() => import('../sync.js'))
   try {
-    // shared.js 在 src/run/，sync.js 在 src/ → 退一层
-    const syncMod = await import('../sync.js')
+    // shared.js 在 src/run/，sync.js 在 src/ → 退一层；loadSyncMod 为测试缝（注入抛错验证 unknown 路由）
+    const syncMod = await load()
     return await syncMod.checkApproval(changeName, cwd)
   } catch (e) {
-    return null
+    return { status: 'unknown', reason: `审批检查异常: ${e?.message || e}` }
   }
 }
 
@@ -1249,6 +1281,23 @@ export async function auditQuickCompletion(cwd, guard, options = {}) {
     // 不对整段 .trim()：会削首行前导空格致首文件路径丢首字符（见 parsePorcelainPath 注释）。
     const currentEntries = gitStatus.split('\n').filter(Boolean)
 
+    // EOL-only 噪声过滤（坑 eol-rewrite-fake-mtime-noise，2026-09-12 驾驭第十六批②，用户实证
+    // gen:types 重写行尾制造假 M）：git diff --ignore-cr-at-eol HEAD 的变更名单是「真实内容变更」
+    // 集——tracked 修改出现在 porcelain 但不在此集 = 纯行尾重写。单次对照调用，剔出 changedFiles
+    // 归 eolOnlyFiles 软警告（.gitattributes 指引），不再计入文件行/触发各门。
+    // 注意：gitQuiet 不在本模块 import 面（safeGit 才是）——首版用 gitQuiet 触发
+    // ReferenceError 被 catch 吞成 null，又被 new Set(null) 包装成空集 → 全部 tracked 修改
+    // 被误判 EOL-only 剔除（audit-quick-completion 回归抓出）。改用 safeGit（已 import，
+    // 返回 {value,error}），失败显式落 null 透传不过滤。
+    const eolRawList = (() => {
+      try {
+        const res = safeGit(cwd, ['diff', '--name-only', '--ignore-cr-at-eol', 'HEAD'], { timeout: 30000 })
+        if (!res || res.error) return null
+        return String(res.value || '').split('\n').filter(Boolean).map(p => p.replace(/\\/g, '/'))
+      } catch { return null }
+    })()
+    const eolRealChanged = eolRawList === null ? null : new Set(eolRawList)
+
     const normalizeGitPath = (p) => p.replace(/\\/g, '/')
     // step1 启动时记录的全量脏文件 = 预存改动（非本次 quick 产生）。审计必须排除它们，
     // 否则脏工作区下预存文件持续留在 git status → 命中 baselineFiles → 误判「覆盖 baseline」
@@ -1321,6 +1370,14 @@ export async function auditQuickCompletion(cwd, guard, options = {}) {
         continue
       }
 
+      // EOL-only（坑 eol-rewrite-fake-mtime-noise）：tracked 修改但真实内容零变化（仅行尾重写）
+      // → 剔出审计归属（changedFiles/各门），归 eolOnlyFiles 软警告。untracked（??）不经此径。
+      if (eolRealChanged instanceof Set && status !== '??' && rawStatus[0] !== 'D' && rawStatus[1] !== 'D'
+        && !eolRealChanged.has(file)) {
+        result.eolOnlyFiles = result.eolOnlyFiles || []
+        result.eolOnlyFiles.push(file)
+        continue
+      }
       result.changedFiles.push(file)
       if (rawStatus[0] === 'D' || rawStatus[1] === 'D') result.deletedFiles.push(file)
       if (status === '??') result.newFiles.push(file)
@@ -1357,8 +1414,28 @@ export async function auditQuickCompletion(cwd, guard, options = {}) {
     }
 
     // 检查 deleted files（--allow-delete 显式放行：删除是破坏性操作，默认 fail-closed，flag 即知情 opt-in）
+    // spec 共享面降级（坑 foreign-spec-churn-fail-closed，2026-09-12 驾驭第十六批①，用户实证
+    // 并行会话归档移动 docs/sillyspec + changes/ 被拦只能 --allow-delete）：.sillyspec/ 与 docs/
+    // 是多会话共享 spec 面——非本会话声明的删除在此面发生时，归因「并行他者 spec 收尾/归档移动」
+    // 降级软警告不阻断（src/test 交付面删除仍 fail-closed——那是本会话可支配域）。
+    const isSpecSharedPath = (p) => {
+      const n = p.replace(/\\/g, '/')
+      return n.startsWith('.sillyspec/') || n.startsWith('docs/')
+    }
     if (!allowDelete) {
+      const stillBlocked = []
       for (const f of result.deletedFiles) {
+        if (isSpecSharedPath(f) && !ownDeclaredNorm.has(f.replace(/\\/g, '/'))) {
+          result.foreignSpecChurn = result.foreignSpecChurn || []
+          result.foreignSpecChurn.push(f)
+          continue
+        }
+        stillBlocked.push(f)
+      }
+      // 整栈退（对齐 linkedChangeLeftovers 模式）：归他者的 spec 面删除从 deletedFiles 移除——
+      // 下方 status 判定与 --allow-delete 渲染均不再见它（否则 blocked-with-empty-reasons）
+      result.deletedFiles = stillBlocked
+      for (const f of stillBlocked) {
         result.reasons.push(`删除文件: ${f}`)
       }
     }
@@ -1374,7 +1451,18 @@ export async function auditQuickCompletion(cwd, guard, options = {}) {
     if (!allowNew) {
       for (const f of result.newFiles) {
         if (!isQuickMetadata(f, guard.linkedChanges)) {
-          result.reasons.push(`新增文件（需 --allow-new）: ${f}`)
+          // mtime 归因（坑 foreign-spec-churn-fail-closed 配套，用户建议「按 quick 启动后
+          // mtime 软判定」）：早于会话启动 = 预存残留（baseline 漏记或并行会话预存，非本
+          // 会话窗口新建）——reason 标注供裁决，门语义不变（新增本就 warning 档）。
+          let mtimeNote = ''
+          try {
+            const st = statSync(join(cwd, f))
+            const startedAtMs = guard.startedAt ? new Date(guard.startedAt).getTime() : 0
+            if (startedAtMs && st.mtimeMs < startedAtMs) {
+              mtimeNote = '（mtime 早于会话启动——预存残留/并行预存，非本会话新建；--files 声明归属或忽略）'
+            }
+          } catch { /* stat 失败无注记 */ }
+          result.reasons.push(`新增文件（需 --allow-new）: ${f}${mtimeNote}`)
         }
       }
     }

package/src/run/verify-quality-scan.js

@@ -276,7 +276,7 @@ export async function executeVerifyQualityScan({ cwd, specBase, changeName, plat
       const { createVerifyGateSnapshot } = await import('./gate-snapshot.js')
       snap = await createVerifyGateSnapshot({ cwd, changeName, specBase, platformOpts })
       if (snap) {
-        console.log(`🧪 noAI 扫描隔离快照：HEAD + 本变更 ${snap.changeFileCount} 个文件${snap.sourceRoot ? '（overlay 自 worktree——本变更分支内容定向跑）' : ''}（并行会话脏文件不参与判定）`)
+        console.log(`🧪 noAI 扫描隔离快照（根：${snap.snapshotRoot}）：HEAD + 本变更 ${snap.changeFileCount} 个文件${snap.sourceRoot ? '（overlay 自 worktree——本变更分支内容定向跑）' : ''}（并行会话脏文件不参与判定）`)
       }
     } catch { /* 快照链路异常 → 主仓现行为 */ }
   }
@@ -292,7 +292,14 @@ export async function executeVerifyQualityScan({ cwd, specBase, changeName, plat
   try {
     testCheck = runVerifyTestCheck({ cwd: gateCwd, specBase: gateSpecBase, changeName })
     printVerifyTestCheck(testCheck)
-    lintCheck = runVerifyLintCheck({ cwd: gateCwd, specBase: gateSpecBase })
+    lintCheck = runVerifyLintCheck({ cwd: gateCwd, specBase: gateSpecBase, timeoutMs: snap ? 5 * 60 * 1000 : undefined })
+    // 快照 lint 超时回退主仓（2026-09-12 dogfood 两连实证：junction I/O 病态慢，3min/5min 均被
+    // 超时杀——主仓 60~110s 正常。按用户建议「自动回退」而非假败/advisory：主仓复跑保硬门，
+    // 并行噪声混入时失败输出带归属鉴定提示）
+    if (snap && lintCheck.status === 'failed' && /超时/.test(String(lintCheck.reason || ''))) {
+      console.warn('⚠️ 快照 lint 超时（node_modules junction I/O 慢）→ 主仓复跑 lint（并行噪声可能混入——失败先做归属鉴定）')
+      lintCheck = runVerifyLintCheck({ cwd, specBase })
+    }
   if (lintCheck.status !== 'skipped') {
     console.log(`\n⏳ noAI 质量扫描：CLI 亲自实测 commands.lint…`)
   }
@@ -315,9 +322,13 @@ export async function executeVerifyQualityScan({ cwd, specBase, changeName, plat
   // lint 失败（SILLYSPEC_VERIFY_LINT_GATE=advisory 时不 throw）同样是摩擦信号，计数不应随
   // 逃生阀漂移。recordFrictionEvent 自带静默降级，不影响本步推进/throw 语义。
   if (testFailed || lintCheck.status === 'failed') {
-    recordFrictionEvent({ cwd, changeName, platformOpts, type: 'verify_run_failed', detail: testFailed ? 'test' : 'lint' })
+    await recordFrictionEvent({ cwd, changeName, platformOpts, type: 'verify_run_failed', detail: testFailed ? 'test' : 'lint' })
   }
   if (testFailed || lintBlocked) {
+    if (snap) {
+      try { const { printSnapshotFailureHint } = await import('./gate-snapshot.js')
+        printSnapshotFailureHint(snap) } catch { /* 提示失败不影响阻断 */ }
+    }
     const runtimeRoot = resolveRuntimeRoot(platformOpts, specBase)
     await renderVerifyTestAttribution({ cwd, changeName, specBase, runtimeRoot })
     const which = testFailed ? '测试' : 'lint'