@thincoder/core 0.10.3 → 0.10.4

package/agent/run-stages.mjs

@@ -13,7 +13,9 @@ import { pushManifestStateReminder } from "./setup-reminders.mjs"
 import { cleanupConsultSessions } from "../agent-tools/consult.mjs"
 import { logEvent, errText } from "../log.mjs"
 // ASYNC-RESULT-CONTAINER.md D1：池 accessor（absorb 双池——advisor 独立池无队列）
-import { getAsyncPool, releaseSettledEntry } from "../agent-tools/async-settle.mjs"
+import { carrierField, getAsyncPool, releaseSettledEntry } from "../agent-tools/async-settle.mjs"
+// §6.31 消化账务（批 digest-accounting · 2026-10-05 · 台账 #930）：见账 pass ∥ 回合分类单点
+import { accountDigestRound, isDigestRound } from "./digest-account.mjs"
 // 批 4 CLI-ASYNC-DISCARD（AGENT-LOOP-ASYNC-POOL.md §6.20）：中止分支「只清已死」收尾单点
 // （#9：+ 后台 bash 任务族——逐条杀树 + 出池 + 墓碑）
 import { discardAbortedPool, discardAbortedAdvisors, discardAbortedBgTasks } from "../agent-tools/async-discard.mjs"
@@ -23,10 +25,15 @@ import { flushPeerDomains } from "../peer-domains.mjs"
 // 第 30 批 D1（Stop 钩子——AGENT-LOOP.md §6.13）：主会话 run 终止事件（触发块见 finalizeAgentTurn）
 import { runHooks } from "../hooks.mjs"
 
+/** 结束信号缺席提醒（§6.31.7 F-DA5——逐字 = 父侧定稿；与「非 stop 异常」同面）。 */
+const FINISH_MISSING_REMINDER =
+  "[System reminder: the previous turn ended without a finish signal — the provider did not report how generation ended. If the response appears incomplete, continue from where it left off.]"
+
 /**
  * 响应后置提醒注入（2026-09-05 实践轮——自 runAgent 响应处理链提取，verbatim）：
  * 流规则 warning（warn 动作——流已完成——去重注入，模型下轮可见）+ 异常 finish
- * reason 警告（响应可能不完整/截断——reasonMap 人类化描述注入）。
+ * reason 警告（响应可能不完整/截断——reasonMap 人类化描述注入）+ 结束信号缺席提醒
+ * （§6.31.7 F-DA5——clean end 无 finishReason ⇒ 同面提醒 + 留痕）。
  */
 export function injectResponseReminders(agent, response) {
   // Stream rule warnings (action: "warn"): stream completed; inject de-duplicated
@@ -39,6 +46,14 @@ export function injectResponseReminders(agent, response) {
     })
   }
 
+  // §6.31.7 F-DA5（#929——批 digest-accounting）：结束信号缺席（clean end 且无 finishReason）
+  // ⇒ 不得静默当正常——同面异常提醒注入 + `ev:finish-missing` 留痕；partial / interrupted /
+  // ruleTriggered 径零触（网络断流既有 `_warnings` 已覆盖；ruleTriggered 在调用点之前分流）。
+  if (response.finishReason == null && !response.partial && !response.interrupted) {
+    agent.history.push({ role: "user", content: FINISH_MISSING_REMINDER })
+    logEvent("ev:finish-missing", { turn: agent._currentTurn ?? 0, auto: agent._inAutoTurn === true, child: agent._logId })
+  }
+
   // Warn on abnormal finish reasons — the response may be incomplete/truncated.
   if (response.finishReason && response.finishReason !== "stop" && response.finishReason !== "tool_calls") {
     const reasonMap = {
@@ -145,11 +160,12 @@ export async function injectTurnReminders(agent, ctx) {
  * 回合收尾（2026-09-05 实践轮——自 runAgent finally 提取，verbatim + 签名化）：写足迹
  * flush → Stop 钩子（第 30 批 D1——ctx.depth === 0 的主会话 run 终止事件，
  * fire-and-forget）→ consult 清理（无孤儿烧 token 的 consult children）→ async 池回合尾
- * 分流（Ctrl+C 清池不注入 / ContinueError 留池续跑 / 其余 collectSettledAsync）→ auto-turn
+ * 分流（Ctrl+C 清池不注入 / ContinueError 留池续跑 / 其余 collectSettledAsync）→
+ * **见账 pass（§6.31.5——消化轮收尾逐条机检账目覆盖；消化账务批）** → auto-turn
  * guard 标记继承（对象字段清单——正常结束才继承；中止丢弃；ContinueError 由续跑快照）。
  */
 export async function finalizeAgentTurn(agent, ctx) {
-  const { signal, autoTurn, suspDriven, thrownError, depth } = ctx
+  const { signal, autoTurn, upstreamTurn, timerTurn, suspDriven, thrownError, depth } = ctx
   // R10 L3（MULTI-INSTANCE-COLLAB §2a.5 D-L3a）：回合末登记 flush——本回合写足迹整写
   // 一次（首行执行：收尾链后续任何异常都不吞登记）；无写入 → 跳过（hot 窗口自然衰减）。
   flushPeerDomains(agent)
@@ -204,6 +220,7 @@ export async function finalizeAgentTurn(agent, ctx) {
     // （原 _pendingConsultResults/_pendingEscalateResults 同口径——VSC 同语义 filter）；
     // subagent/advisor 停靠保留（挂起期 settle 的已完成结果不随中止丢）。
     agent._pendingAsyncResults = (agent._pendingAsyncResults ?? []).filter((e) => e.role !== "consult" && e.role !== "escalate")
+    agent._unsettledDigests = [] // §6.31.5 清账面：会话中止 ⇒ 升级账本随 pending 一并清（用户全停 = 旧账不续）
   } else if (thrownError instanceof ContinueError) {
     // keep _asyncSubagents/_asyncAdvisors/_consultSessions — the resumed run continues them
   } else {
@@ -220,6 +237,12 @@ export async function finalizeAgentTurn(agent, ctx) {
       closeOpenCodeAdvisorRuns(agent)
     }
   }
+  // §6.31.5 见账面（消化轮收尾——finalize 单点；消化账务批 · 2026-10-05 · 台账 #930）：
+  // 恒达窗 = 正常 ∥ Abort-continue ∥ 异常抛三径同达；会话停止径不判（清场语义归 finishSuspension）。
+  if (isDigestRound({ autoTurn, upstreamTurn, timerTurn }) && carrierField(agent, "_daSession") === true
+      && !(signal?.aborted && !signal?.reason?.interrupt)) {
+    accountDigestRound(agent)
+  }
   agent._inAutoTurn = false
   // AGENT-LOOP-ASYNC-POOL.md §6.8 D-S6: auto-turn guard marks survive into the next USER run (restored at its
   // !resume reset above). Normal ends only — abort discards; ContinueError lets the

package/agent/run-start.mjs

@@ -30,14 +30,55 @@ export async function beginRun(agent, input, callbacks, {
   // +role——四族（subagent/advisor/escalate/consult）统一停靠；注入器按 role 分发
   // （consult → injectConsultResult；其余 → injectAsyncResult——族分支同 CONSULTATION.md §6.2 D-R17a/b）
   // ——单容器一处清，不再逐族三段。
+  // §6.31 消化账务（批 digest-accounting · 2026-10-05 · 台账 #930）：**投递 ≠ 销账**——
+  // 会话态（`_daSession`）投递留容器（覆盖才离容器 / 未见账经消化轮回路重投）；fallback
+  // （headless / 直连 runAgent）缺省条逐字沿用取尽语义（先离容后注入 ∥ `releaseSettledEntry` 面；
+  // 零账目动作——不销账 / 不重投），已投递未销账条同判据跳过且留容器（§6.31 出口缝② · 父侧裁定 2026-10-05）。
   const pendingAsync = agent._pendingAsyncResults
-  if (pendingAsync?.length) {
+  const { carrierField, releaseChildHold, releaseSettledEntry } = await import("../agent-tools/async-settle.mjs")
+  if (carrierField(agent, "_daSession") === true) {
+    const { armAccountRound, isDigestRound, shouldDeliverEntry, digestAccountRequirement } = await import("./digest-account.mjs")
+    armAccountRound(agent) // §6.31.5 落痕清位：会话态起跑即清（缺痕 ⇒ 全条未覆盖——安全方向）
+    if (pendingAsync?.length) {
+      const { injectAsyncResult } = await import("../agent-tools/subagent.mjs")
+      const { injectConsultResult } = await import("../agent-tools/consult.mjs")
+      const digestRound = isDigestRound({ autoTurn, upstreamTurn, timerTurn })
+      // 投递门控两态（§6.31.4）：首投任意回合 ∥ 重投仅消化轮；注入后**留容器**（不 splice）。
+      // 注入抛错 ⇒ 未投条目（`_daDelivered` 未置）留容器待下轮——收窄既有「splice 先取尽」的丢失窗。
+      for (const e of [...pendingAsync]) {
+        if (!shouldDeliverEntry(e, digestRound)) continue
+        if (e.role === "consult") await injectConsultResult(agent, e)
+        else await injectAsyncResult(agent, e)
+        e._daDelivered = true
+        e._daRetry = false
+        releaseChildHold(e) // 仅释放 `childAgent`——`report` 保留至销账 / 升级（重投需原文）
+      }
+      // 账目要求行（§6.31.3）：仅会话态消化轮且未销账清单非空时注入（先投递后拼清单——
+      // 含本回合首投 / 重投）；两档同发（手动 / AUTO）；transient（机器线独有）。
+      if (digestRound) {
+        const ids = pendingAsync.filter((e) => e._daDelivered === true).map((e) => e.id)
+        if (ids.length > 0) {
+          agent.history.push({ role: "user", content: digestAccountRequirement(ids), transient: true })
+        }
+      }
+    }
+  } else if (pendingAsync?.length) {
     const { injectAsyncResult } = await import("../agent-tools/subagent.mjs")
     const { injectConsultResult } = await import("../agent-tools/consult.mjs")
     // TUI-OOM-ROOTCAUSE（AGENT-LOOP.md §6.15 消费点②——run 起始 pending 注入）：
     // 注入完成后释放条目对子代理对象的持有（childAgent/report 置空——幂等 helper）。
-    const { releaseSettledEntry } = await import("../agent-tools/async-settle.mjs")
-    for (const e of pendingAsync.splice(0)) {
+    // §6.31 出口缝②（#44 披露①扩散面 · 父侧裁定 2026-10-05）：fallback 支同判据延伸——
+    // 注入前按投递账分区：已投递未销账条（`_daDelivered === true`——内容已在历史）不注入且
+    // 留容器（与 idle 清场同义——防重复 / 条目不离账务面）；`_daDelivered` 缺省条逐字沿用
+    // （先离容后注入的取尽窗 ∥ 注入顺序 ∥ `releaseSettledEntry` 面）。
+    const taken = []
+    let kept = 0
+    for (const e of pendingAsync) {
+      if (e?._daDelivered === true) pendingAsync[kept++] = e
+      else taken.push(e)
+    }
+    pendingAsync.length = kept
+    for (const e of taken) {
       if (e.role === "consult") await injectConsultResult(agent, e)
       else await injectAsyncResult(agent, e)
       releaseSettledEntry(e)
@@ -80,6 +121,11 @@ export async function beginRun(agent, input, callbacks, {
       agent._verifyPassed = undefined
       agent._calledAdvisorThisRun = false
       agent._touchedFiles = []
+      // #934（零落笔看门狗——AGENT-LOOP-UPSTREAM.md §6.32.6 载体重置）：streak / 闩与
+      // `_touchedFiles = []`（本块）同点复位——链起点；续跑（resume）不执行 ⇒ 「连续」
+      // 跨段存活（锚与分支差别注见 §6.32.2 ①）。
+      agent._zeroWriteStreak = 0
+      agent._zeroWriteAlerted = false
       agent._verifyRetries = 0
       agent._advisorRound = 0
       agent._advisorSession = null // advisor session is per-run: discard when the task ends, next task starts fresh

package/agent/suspension.mjs

@@ -5,11 +5,14 @@
  * 回合尾后台池仍 live → 挂起会话——池项 settle → 入 pending；pending 非空 **或存在未 drain 的
  * 上行 ask**（`upstreamWaiting`——F-UC7 / §6.27.12.4 ①）→ 合并消化轮 / 唤醒轮（auto-turn；旗标
  * `upstreamTurn` 仅供域文本选择）；挂起空闲用户输入优先于消化轮。池空 + pending 空 + 无待处理
- * 输入 → 自然退出（idle）。退出清场：abort = 清池不注入（陈旧结果不注入）；idle = 残余直注入（结果零丢失）。
+ * 输入 → 自然退出（idle）。退出清场：abort = 清池不注入（陈旧结果不注入）；idle = 残余直注入
+ * （结果零丢失；已投递未销账条按投递账过滤——留容器不注入，§6.31 出口缝）。
  *
  * 载体注入（端差面 = 池 / pending / 标志挂谁）：`ctx.carrier` = 字段集按核内异步面
  * 现行口径的对象（`_asyncSubagents` · `_asyncAdvisors` · `_consultSessions` ·
- * `_pendingAsyncResults` · `_suspended`；#9 后台 bash 任务池 `_bgTasks` 同列）
+ * `_pendingAsyncResults` · `_suspended`；#9 后台 bash 任务池 `_bgTasks` 同列；
+ * 消化账务批 · 2026-10-05 同列 `_daSession`（挂起会话标记——置位 / 复位单点）与
+ * `_unsettledDigests`（升级账本——中止清场））
  * ——CLI 形 = `agent` 对象；VSC 形 = depth-0
  * `history` 数组（附加属性不污染会话文件）。机制对载体零预设（空字段一律 `?.` 读）。
  *
@@ -112,12 +115,15 @@ function consultLiveCount(carrier) {
  *  - abort：**只清已死**（§6.20 口径——增补 D：`discardAbortedPool` ∕ `discardAbortedAdvisors`
  *    单点，与核 run-stages 回合尾中止同式；存活 ∕ 已 settle 条目留池——settled 报告沿后续
  *    回合边界注入到达，不静默丢）+ pending 单容器清 + 会诊会话清理标记；
- *  - idle：残余直注入（极端竞态残项——结果零丢失；注入器由宿主注入，缺省 no-op 保残项）。
+ *  - idle：残余直注入（极端竞态残项——结果零丢失；注入器由宿主注入，缺省 no-op 保残项）；
+ *    **已投递未销账条（`_daDelivered === true`）按投递账过滤**——内容已在历史（投递起跑窗）：
+ *    不注入且留容器（消化账务批出口缝 · #41 披露① · 父侧裁定 2026-10-05——状态面可见 / 可续账）。
  *
- * 返回 `{ injected, left, error }`（子代理面板批 · 2026-10-04 —— `hooks.reclaim` 恒达窗的退出半）：
- *  `left` = **离容全量**（splice 全取——注入失败条不缩水），供调用点 `reclaim(left)` 补发
- *  （「消费 ⇒ 必发 done」不变量——C2 零发射口）；注入循环 try/catch 收口 ⇒ `injected` = 成功
- *  前缀、`error` = 首错（调用点补发毕后重抛——fail-loud 保持）；abort ∥ 无注入器 ∥ 无残差 ⇒ 三键空值。
+ * 返回 `{ injected, left, error }`（子代理面板批 · 2026-10-04 —— `hooks.reclaim` 恒达窗的退出半；
+ *  消化账务批出口缝——`left` = **注入集离容全量**（离容全取——注入失败条不缩水；已投递未销账
+ *  跳过条不取、留容器），供调用点 `reclaim(left)` 补发（「消费 ⇒ 必发 done」不变量——C2 零发射口；
+ *  跳过条未消费、其 done 已在投递起跑窗落——不入补发面）；注入循环 try/catch 收口 ⇒ `injected` =
+ *  成功前缀、`error` = 首错（调用点补发毕后重抛——fail-loud 保持）；abort ∥ 无注入器 ∥ 无残差 ⇒ 三键空值。
  *  既有 C3/C4 快照径（中止冻结快照）零改。
  */
 export async function finishSuspension(carrier, { aborted = false, injectResidual = null } = {}) {
@@ -127,6 +133,7 @@ export async function finishSuspension(carrier, { aborted = false, injectResidua
     discardAbortedAdvisors(carrier)
     discardAbortedBgTasks(carrier) // #9 收尾档②：后台 bash 任务逐条杀树 + 出池 + 墓碑（杀 ⟺ 控制器已中止）
     carrier._pendingAsyncResults = []
+    carrier._unsettledDigests = [] // §6.31.5 清账面（消化账务批）：会话中止 ⇒ 升级账本随 pending 一并清（旧账不续）
     if (carrier._consultSessions instanceof Map) {
       const { cleanupConsultSessions } = await import("../agent-tools/consult.mjs")
       cleanupConsultSessions(carrier)
@@ -135,7 +142,18 @@ export async function finishSuspension(carrier, { aborted = false, injectResidua
   }
   const residual = carrier._pendingAsyncResults
   if (!residual?.length || typeof injectResidual !== "function") return { injected: [], left: [], error: null }
-  const left = residual.splice(0)
+  // §6.31 出口缝（#41 披露① · 父侧裁定 2026-10-05）：清场按投递账过滤——已投递未销账条
+  // （`_daDelivered === true`——内容已在历史）**不注入且不动容器**（状态面可见 / 可续账——防重复）；
+  // 判据 = 条目既有字段（调用窗 `_daSession` 已复位——不以其为门）；其余条逐字沿用。
+  // 单遍分区写法（#44 披露④ · 父侧裁定 2026-10-05）：一次遍历同出 `left`（离容集）与留容器集——
+  // 消除 `indexOf` 未命中 ⇒ `splice(-1,1)` 静默删尾的失败类；离容顺序 ∥ `left` 语义不缩水。
+  const left = []
+  let kept = 0
+  for (const e of residual) {
+    if (e?._daDelivered === true) residual[kept++] = e
+    else left.push(e)
+  }
+  residual.length = kept
   const injected = []
   for (const e of left) {
     try { await injectResidual(e) } catch (error) { return { injected, left, error } } // 首错收口（前缀 = injected）
@@ -217,6 +235,9 @@ export function startSuspension(ctx) {
 
   const done = (async () => {
     carrier._suspended = true
+    // §6.31.2 会话标记（消化账务批 · 2026-10-05 · 台账 #930）：挂起会话期 true——投递留容器 /
+    // 见账 / 重投回路的唯一判据；退出（finally）置 false ⇒ 会话外回 fallback 语义。
+    carrier._daSession = true
     hooks.onCounts?.(backgroundCounts(carrier))
     let aborted = false
     try {
@@ -298,6 +319,7 @@ export function startSuspension(ctx) {
       if (!finished) {
         finished = true
         carrier._suspended = false
+        carrier._daSession = false // §6.31.2 会话标记复位（退出即回 fallback 语义）
         latch.wake = null
         // §2.3 退出清场：abort 判定与实时信号合并（两端同式——Stop 落在 runTurn 内时
         // abort 以 AbortError 抛出、循环顶检查不会再执行——不合并会把清场误走 idle 注入）。

package/agent/turn-loop.mjs

@@ -49,8 +49,13 @@ export async function runTurnLoop(agent, {
 
   // SUBAGENT-UPSTREAM-CHANNEL（AGENT-LOOP-UPSTREAM.md §6.27.4 消费点）：子 → 父在飞消息的
   // 回合边界注入单点取用一次（模块缓存 ⇒ 每 run 一次代价）；动态 import = 零新增静态边
-  // （先例 = 上方 injectAsyncResult :113-117）。
+  // （同款先例 = run-start.mjs:43 ∥ :66——injectAsyncResult 动态 import）。
   const { drainChildUpstream } = await import("../agent-tools/parent-channel.mjs")
+  // #934（零落笔看门狗——AGENT-LOOP-UPSTREAM.md §6.32）：连续零写越阈 ⇒ 自动上行提醒（只推——
+  // 不杀 / 不转向）；单源叶 = zero-write-watch.mjs，动态 import 沿上条同款（零新增静态边）。
+  const { maybeZeroWriteAlert } = await import("../agent-tools/zero-write-watch.mjs")
+  // §6.31.5 落痕写点门（#939）：载体吸收经 `carrierField` 单点（§6.31.4 同式）；动态 import = 零新增静态边（沿上方两条同款）。
+  const { carrierField } = await import("../agent-tools/async-settle.mjs")
 
   // #417（撞帽载荷「本段零落盘轮数」——只报数：零阈值 / 零自动动作）：计数基线——回合环逐轮
   // 比对 `_touchedFiles` 增量（轮顶对上一轮结账；撞帽收尾轮在环外单结）。
@@ -70,7 +75,18 @@ export async function runTurnLoop(agent, {
     agent._maxTurns = frame.maxTurns
     // #417（撞帽载荷「本段零落盘轮数」——采集点与 `_turnSeq` 同源面）：上一轮至今 `_touchedFiles`
     // 零增 ⇒ 上一轮零落盘，计数 +1；mark 前移（收尾轮在环外结账——见下方 ContinueError 前）。
-    if (turn > 0 && agent._touchedFiles.length === agent._turnFilesMark) agent._zeroWriteTurns += 1
+    // #934（零落笔看门狗——§6.32.2 ① 单点采集）：streak 与越阈判定同点——上轮零写 ⇒ +1 并判越阈；
+    // 有写 ⇒ streak 归零 + 清闩（写后重臂——每连续零写段恰一条）。#417 计数语义逐字保持。
+    if (turn > 0) {
+      if (agent._touchedFiles.length === agent._turnFilesMark) {
+        agent._zeroWriteTurns += 1
+        agent._zeroWriteStreak += 1
+        maybeZeroWriteAlert(agent) // #934：连续零写越阈 ⇒ 自动上行提醒（只推——§6.32）
+      } else {
+        agent._zeroWriteStreak = 0
+        agent._zeroWriteAlerted = false // 写后重臂
+      }
+    }
     agent._turnFilesMark = agent._touchedFiles.length
     // D2 (AGENT-LOOP-SUBAGENT.md §6.7.2): depth>0 children emit a ⟦ev⟧turn progress token each turn —
     // single emit point covering all three spawn tools; phase=llm (tool/done progress rides
@@ -109,6 +125,13 @@ export async function runTurnLoop(agent, {
       systemPrompt, toolSchemas, streamOutput, callbacks, signal, streamRuleFired, autoTurn, depth, turn,
     })
 
+    // §6.31.5 落痕（消化账务批 · 2026-10-05 · 台账 #930 ∥ #939 收正）：本 run 内**逐轮追加**——
+    // 每模型轮返回即写（会话态）；首轮签收不为收口轮覆盖（见账取件读累积痕）。
+    // 落父字段（抗 `history` 整体替换——`context.mjs` `applyCompression`）；非会话零动作。
+    if (carrierField(agent, "_daSession") === true && response.content) {
+      agent._lastRunOutput = `${agent._lastRunOutput ?? ""}${response.content}\n`
+    }
+
     // 内置工具（Responses web_search）结果本地化：服务端已执行——入历史为 tool 消息；
     // 服务端 item id 是 msg_xxx 非 web_search_call_ 前缀——必须合成前缀（toItems 识别锚点），
     // 原始 id 存入 content（真机冒烟 2026-08-31 验证）。

package/agent/write-gate.mjs

@@ -6,8 +6,10 @@
  * （KD-M4-3）——本档承载三个单点：
  *
  * 1. `resolveReviewTargetPaths(agent)` —— 评审目标解析单点：读 manifest `docRoot`
- *    产出评审对象 / 被审文件的绝对路径集合（目录级；子键值形态 = 串 | 多根数组，
- *    展开走 `docRootPaths`）。缺 `docRoot` 键 → `readManifest`
+ *    产出评审对象 / 被审文件的绝对路径集合（目录级；子键值形态 = 串 | 多根数组）。
+ *    判定本体（`REVIEW_ROOT_KEYS` 键集 + `resolveReviewRootsFor(dir)`——2026-10-02 收口 ·
+ *    台账 #828 按用点形）自本档迁 `review-facts.mjs`（2026-10-04 · #921 · KD-2——本档同名
+ *    再出口保既有 import 面）；缺 `docRoot` 键 → `readManifest`
  *    的 fillDefaults 已补默认（架构 §2.3 E2 便利 fallback 落点）；整档缺失 / 非法 JSON →
  *    `{ok:false}` → 回退 DEFAULT_MANIFEST.docRoot（本函数是壳门之下的便利层——E2 的
  *    「整档缺失」由壳面 requireManifest 按用点处置（判 + 报明 / 建档，**不抛**——
@@ -15,8 +17,6 @@
  *    KD-M1-12）：CLI make-agent.mjs / VSC setup.mjs 同判）；读错（权限等）→ 上抛不伪装成缺失（manifest.mjs 契约）。
  *    M6 的 `advisor.mjs` design-review 分类分支消费本导出
  *    （KD-M6-1——同源不重复实现；落 dispatch.mjs 会让 advisor 反向 import 门禁簇成环）。
- *    **按用点形（2026-10-02 收口 · 台账 #828）**：`resolveReviewRootsFor(dir)`——同单点
- *    非第二实现（按目标目录 ∥ 所属项目根解析；多档锚下各文档按各自项目判定）。
  * 2. `freezeWindowConflict(agent, absPaths)` —— D5 冻结窗口判据组装：被审文件集 =
  *    声明文档集（`inflightDesignReviewConflict` 同源 docAbs 腿）+ 批次档（`run.batchDoc`
  *    腿——评审绑定批档在途时，写批档同样致 stale）。dispatch.mjs
@@ -30,7 +30,6 @@
  * 代码路径判定（conventions.mjs 单一权威分类——KD-M4-1 保留为代码路径判定用）。
  */
 import { basename, dirname, resolve } from "node:path"
-import { DEFAULT_MANIFEST, docRootPaths, readManifest } from "../manifest.mjs"
 // advisor-settle 无上游依赖本簇（dispatch → write-gate → advisor-settle 单向）。normAbs
 // 权威本体 = review-facts.mjs（第 33 批迁入），advisor-settle re-export；本档再 re-export
 // （指针链非副本），M6 经本档一行 import 取齐。
@@ -38,13 +37,17 @@ import { inflightDesignReviewConflict, normAbs } from "../agent-tools/advisor-se
 // 批次档路径单源（叶档——`BATCH-RECORD.md` §4.15）：批次档写门基底集取 `batchDocBases`。
 import { batchDocBases } from "../agent-tools/batch-paths.mjs"
 export { normAbs }
-
-/** 评审目标解析读的 docRoot 键集（评审对象/被审文件可住的所有文档层——M6 分类据此判定）。 */
-const REVIEW_ROOT_KEYS = ["requirements", "specs", "design", "modules", "batches"]
+// 2026-10-04（工具路径基面根治批 · #921 · KD-2 同名再出口）：REVIEW_ROOT_KEYS +
+// resolveReviewRootsFor 判定本体迁 `review-facts.mjs`（评审事实面——advisor-async 既有
+// import 面零新模块边）；本档同名再出口（指针非副本——normAbs 同款先例）——既有 import 面
+// （advisor.mjs / 测试）零改；本档消费点 `resolveReviewTargetPaths` 薄委托同名函数。
+export { REVIEW_ROOT_KEYS, resolveReviewRootsFor } from "../agent-tools/review-facts.mjs"
+import { resolveReviewRootsFor } from "../agent-tools/review-facts.mjs"
 
 /**
- * 评审目标解析单点（M4 §2.1#1）：读 manifest `docRoot` → 评审对象 / 被审文件的绝对路径
- * 集合（目录级，反斜杠归一；子键值形态 = 串 | 多根数组，逐键经 `docRootPaths` 展开）。
+ * 评审目标解析单点（M4 §2.1#1）：评审对象 / 被审文件的绝对路径集合（目录级）——
+ * 判定本体（manifest `docRoot` 读面 / 缺档回退 / 读错上抛语义）2026-10-04 迁
+ * `review-facts.mjs` 单源（KD-2——本档薄委托；详述见该档 resolveReviewRootsFor JSDoc）。
  * 缺 `docRoot` 键 → readManifest 已补默认；整档缺失 / 非法 →
  * `{ok:false}` → 回退 DEFAULT_MANIFEST.docRoot（便利层——E2 的「整档缺失」由壳面
  * requireManifest 按用点处置（判 + 报明 / 建档，**不抛**——启动侧恒不拒，KD-M1-25；**工程模式会话**口径——KD-M1-12），本函数不重复拦）；
@@ -56,21 +59,6 @@ export function resolveReviewTargetPaths(agent) {
   return resolveReviewRootsFor(agent?.cwd ?? process.cwd())
 }
 
-/** 同单点之**按用点解析**增量（2026-09-21「参数按用点解析」之裁收口 · 台账 #828）：按**目标目录**
- *  （其所属项目根——最近带档祖先）解析评审目标根集——多档锚下各文档按各自项目判定。
- *  @param {string} dir 目标目录（项目根——最近带档祖先）
- *  @returns {string[]} 评审目标目录绝对路径（去重）
- */
-export function resolveReviewRootsFor(dir) {
-  const man = readManifest(dir)
-  const root = man.ok && man.manifest?.docRoot && typeof man.manifest.docRoot === "object"
-    ? man.manifest.docRoot
-    : DEFAULT_MANIFEST.docRoot
-  const out = []
-  for (const key of REVIEW_ROOT_KEYS) out.push(...docRootPaths(root?.[key], dir))
-  return [...new Set(out)]
-}
-
 /**
  * D5 冻结窗口判据组装（M4 §2.1#2）：评审在途（点火 → 结算）期间父侧对被审文件集
  * （声明文档集 + 批次档）的写入 → 返回冲突 { id, path }；无冲突 → null。

package/agent-tools/advisor-async.mjs

@@ -47,13 +47,13 @@ export {
 // 第 11 批拆分（2026-09-11）：settle 记账 + 变更日志（noteMutations）+ 陈旧判定
 // （reviewIsStale）+ 冻结冲突（inflightDesignReviewConflict）迁 advisor-settle.mjs——
 // 既有 import 面（dispatch / subagent-async / escalate-async / 测试）经此 re-export 不变。
-import { normAbs, mutationSeqOf, settleAdvisorRun } from "./advisor-settle.mjs"
+import { mutationSeqOf, settleAdvisorRun } from "./advisor-settle.mjs"
 export {
   mutationSeqOf, noteMutations, reviewIsStale, settleAdvisorRun, inflightDesignReviewConflict,
 } from "./advisor-settle.mjs"
 // 第 33 批（评审失败护栏）：doc-set 键迁事实面档（实例续跑与陈旧判定同锚单源；原为私有——零 import 面）。
 // 本文件继续在实例解析 / 池 entries 上消费它。
-import { docSetKey } from "./review-facts.mjs"
+import { docSetKey, resolveReviewDocPaths, scopeAdvisorMirror } from "./review-facts.mjs"
 // F31（2026-09-18 顾问面治理批）：拒回文案对象标识行单源。
 import { withIdentityLine, scopeSummary } from "../advisor/notice.mjs"
 import { runAdvisorReview, resolveAdvisorProvider, ADVISOR_THINKING_PLACEHOLDER } from "../advisor/run.mjs"
@@ -65,6 +65,8 @@ import { deathLine } from "../abort-provenance.mjs"
 // ASYNC-RESULT-CONTAINER.md D3/D6：settle 公共收尾单点 + child signal 构建单点
 import { bindChildController, buildChildSignal, carrierField, getAsyncPool, settleAsyncEntry, tombstoneOf, writeTombstone } from "./async-settle.mjs"
 import { nextSubagentId, consumeSubagentToken, assertPoolKeyFree, entryTerminal } from "./subagent-scheduler.mjs"
+// #934（零落笔看门狗——AGENT-LOOP-UPSTREAM.md §6.32.6 触发接线②）：评审族推送单源（叶档——恒零抛）。
+import { pushAdvisorAlert } from "./zero-write-watch.mjs"
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Review-instance registry (_advisorRuns — per-review rounds/prior/cap)
@@ -161,9 +163,9 @@ export function resolveAdvisorLaunch(agent, reviewType, { documents = null } = {
       runs.set(reviewId, run)
     }
   }
-  // Scope the legacy mirror fields (message builder + run.mjs cap + displays).
-  agent._advisorRound = run.priorOutput ? run.round : 0
-  agent._lastAdvisorOutput = run.priorOutput
+  // Scope the mirror fields to THIS instance (message builder + run.mjs cap +
+  // displays; #949 ① — the queued-launch window is re-secured at entry.start).
+  scopeAdvisorMirror(agent, run)
   return { run, isNew: run.round === 0 && !run.priorOutput, reviewId: run.reviewId, designId: run.designId }
 }
 
@@ -390,8 +392,11 @@ export function launchAsyncAdvisor(parent, ctx, launch) {
     id, role: "advisor", reviewType, run,
     reviewId: run.reviewId, designId, designToken, documents, paths, object,
     launchSeq: mutationSeqOf(parent),
+    // docAbs 产出面同源归一（2026-10-04 · #921 · A 随件）：四腿单源 resolved（裸形/前缀形
+    // 命中候选项目根即归一为绝对路径）——冻结窗/陈旧判定对**裸形受理档**照护成立（否则 A
+    // 开冻结窗保护洞）；绝对形与旧 normAbs 面逐字等价。
     docAbs: reviewType === "design" && Array.isArray(documents)
-      ? documents.filter((d) => typeof d === "string").map((d) => normAbs(d, parent.cwd))
+      ? [...resolveReviewDocPaths(documents, parent.cwd).resolved.values()]
       : [],
     relayPrefix: `advisor#${id}/`,
     status: queued ? "queued" : "running", position: undefined,
@@ -420,9 +425,12 @@ export function launchAsyncAdvisor(parent, ctx, launch) {
     // Async mark + [model] — the TUI block opens at ACTUAL start (⏹ gating reads it).
     ctx?.callbacks?.onToken?.(entry.relayPrefix + "⟦ev⟧async\x1e")
     ctx?.callbacks?.onToken?.(entry.relayPrefix + "[model]" + (entry.model ?? ""))
+    // #949 ①：排队 / 延迟窗口封死——构建前按本评审实例复核镜像（消费点定域；幂等）。
+    scopeAdvisorMirror(parent, run)
     runAdvisorReview(parent, reviewType, {
       onOutput: (chunk) => relayAdvisorOutput(ctx?.callbacks, entry.relayPrefix, chunk),
       signal: entry.controller.signal,
+      onStall: (rounds) => pushAdvisorAlert(parent, `advisor#${id}`, rounds), // #934：连续无产出越阈 ⇒ 自动上行提醒（只推——§6.32）
     }, designToken, documents, paths, object, designId)
       .then((report) => { entry.report = report })
       // §6.12 第 3 条合成器（第 24 批）：原 message 前缀逐字保留 + 来源后缀

package/agent-tools/advisor.mjs

@@ -9,12 +9,11 @@
  */
 import { runAdvisorReview, advisorIncompleteMarker, ADVISOR_LAUNCH_REFUSAL_PREFIX } from "../advisor/run.mjs"
 import { resolveBatchDocPath } from "./batch.mjs"
-// M6（模块设计 §2.1 F3）：评审对象来源读 manifest docRoot（声明面）——复用 M4 的
-// write-gate.mjs 单一权威源（KD-M6-1），替代 v1 的逐档分类面（isDocPath）；
-// normAbs 同源 re-export（指针非副本）。不 import dispatch.mjs（簇间回边，环风险）。
-import { resolveReviewTargetPaths, resolveReviewRootsFor, normAbs } from "../agent/write-gate.mjs"
-import { owningProject } from "../manifest-discovery.mjs"
-import { sep } from "node:path"
+// M6（模块设计 §2.1 F3）：评审对象来源读 manifest docRoot（声明面）——单一权威源 =
+// review-facts.mjs 的 resolveReviewDocPaths（2026-10-04 · #921 · KD-2——分类四腿 + B 文案
+// 诊断数据单源；write-gate 同名再出口保 normAbs 面）。不 import dispatch.mjs（簇间回边，环风险）。
+import { normAbs } from "../agent/write-gate.mjs"
+import { resolveReviewDocPaths } from "./review-facts.mjs"
 import {
   generateDesignToken,
   settleDesignReview,
@@ -63,11 +62,11 @@ export const advisorTool = {
       documents: {
         type: "array",
         items: { type: "string" },
-        description: "Doc paths to review (design / requirements / referenced docs). The advisor reviews ONLY these — no git diff scan. Use for both review types to pass the task's docs list.",
+        description: "Doc paths to review (design / requirements / referenced docs). Relative paths resolve against the session cwd first, then candidate project roots (project-root-relative e.g. <repo>/docs/…, or absolute). The advisor reviews ONLY these — no git diff scan. Use for both review types to pass the task's docs list.",
       },
       batchDoc: {
         type: "string",
-        description: "Design review only: the in-flight batch record path — validated whenever passed (unreadable ⇒ refused, not ignored); the reviewer then also gets the `batch` write channel to record its findings + verdict. Omit when no batch record is in flight (no write channel — zero regression).",
+        description: "Design review only: the in-flight batch record path — validated whenever passed (unreadable ⇒ refused, not ignored); the reviewer then also gets the `batch` write channel to record its findings + verdict. Relative paths resolve against the session cwd first, then candidate project roots (project-root-relative e.g. <repo>/docs/batches/…, or absolute). Omit when no batch record is in flight (no write channel — zero regression).",
       },
     },
     required: ["type"],
@@ -112,34 +111,36 @@ export const advisorTool = {
       )
     }
 
-    // Design review: the review scope must be documentation files. Classification
-    // comes from the manifest-declared review-target roots (M4 write-gate.mjs single
-    // authority — FR12: no directory-name hardcoding; a project whose docs live
-    // elsewhere declares them in PROJECT-MANIFEST.json docRoot).
+    // Design review: the review scope must be documentation files. Classification =
+    // resolveReviewDocPaths (2026-10-04 · #921 · the four-leg single authority in
+    // review-facts.mjs): legs ① session-root set / ② owning-project root set keep the
+    // legacy behavior verbatim; leg ③ probes candidate project roots for bare
+    // project-root-relative forms; leg ④ disambiguates by readable-file uniqueness
+    // (fail-closed — criterion=scope-doc-ambiguous when ≥2 candidates are readable).
     if (reviewType === "design" && documents) {
-      const roots = resolveReviewTargetPaths(agent).map((r) => r.replace(/[\\/]/g, sep))
-      // 按用点解析（2026-09-21 之裁收口 · 台账 #828）：逐文档按**其所属项目**（最近带档祖先）
-      // 的 docRoot 判定；无主档文档回退会话根集判定（原行为零变）。
-      const ownerRootsCache = new Map()
-      const ownRoots = (abs) => {
-        const owner = owningProject(abs)
-        if (!owner) return []
-        let r = ownerRootsCache.get(owner)
-        if (!r) {
-          r = resolveReviewRootsFor(owner).map((x) => x.replace(/[\\/]/g, sep))
-          ownerRootsCache.set(owner, r)
-        }
-        return r
-      }
-      const invalidDocs = documents.filter((doc) => {
-        const n = normAbs(doc, agent.cwd).replace(/[\\/]/g, sep)
-        const under = (r) => n === r || n.startsWith(r + sep)
-        return !roots.some(under) && !ownRoots(n).some(under)
-      })
-      if (invalidDocs.length > 0) {
+      const { resolved, invalid, ambiguous, candidates } = resolveReviewDocPaths(documents, agent.cwd)
+      if (invalid.length > 0 || ambiguous) {
         if (ctx._toolCallId !== undefined) (agent._advisorRefusals ??= new Set()).add(ctx._toolCallId)
+        if (ambiguous) {
+          // 歧义拒（KD-4 独立判据——不混入 not-doc；列全部可读命中——fail-closed 不静默挑一）。
+          return withIdentityLine(
+            `Advisor: design review document is ambiguous — "${ambiguous.doc}" matches several candidate projects: ${ambiguous.hits.join(", ")}. Pass a project-root-relative or absolute path.`,
+            { type: reviewType, scope: scopeSummary(documents), round: "—", criterion: "scope-doc-ambiguous" },
+          )
+        }
+        // not-doc 拒：既有稳定前缀逐字（行首）+ 解析诊断尾（B 面根治——逐文档「解析后绝对
+        // 路径 ← 基面 = 会话 cwd」+ 候选项目根提示 cap 5 + 重试指引——纠正「误报因」缺陷）。
+        const invalidList = invalid.map((v) => v.doc).join(", ")
+        const attemptedList = invalid
+          .map((v) => `${v.doc} → ${v.attempted.length > 0 ? v.attempted.join(" | ") : normAbs(v.doc, agent.cwd)}`)
+          .join("; ")
+        const shown = candidates.slice(0, 5)
+        const more = candidates.length - shown.length
+        const candidateNote = shown.length > 0
+          ? `(candidates: ${shown.join(", ")}${more > 0 ? ` +${more} more` : ""}) — pass project-root-relative (e.g. ${shown[0]}/docs/…) or absolute paths`
+          : "— pass project-root-relative or absolute paths"
         return withIdentityLine(
-          `Advisor: design review documents must be documentation files (per the project's conventions). Invalid: ${invalidDocs.join(", ")}`,
+          `Advisor: design review documents must be documentation files (per the project's conventions). Invalid: ${invalidList}\nDiagnosis: resolved against session cwd ${agent.cwd} → ${attemptedList}; no candidate project docRoot contains it ${candidateNote}.`,
           { type: reviewType, scope: scopeSummary(documents), round: "—", criterion: "scope-not-doc" },
         )
       }

package/agent-tools/async-settle.mjs

@@ -134,6 +134,17 @@ export function parkAsyncPending(parent, entry) {
   pend.push(entry)
 }
 
+/**
+ * §6.31.5 升级账本写助手（消化账务批）：`_unsettledDigests` 追加一行
+ * （`{ id, role, failures, report, at }`）。载体吸收（父字段优先 / history 借用——形态同
+ * `parkAsyncPending`）；行序 = 升级序（读面 = `digest-account.mjs` `unsettledRows`）。
+ */
+export function appendUnsettledDigest(parent, row) {
+  const existing = carrierField(parent, "_unsettledDigests")
+  const list = (parent._unsettledDigests ??= Array.isArray(existing) ? existing : [])
+  list.push(row)
+}
+
 // ─── D4 守卫统一（严格版）+ D6 信号兜底单点 ──────────────────────────────────
 
 /** D4 settle 守卫统一（escalate 严格版）：父侧中止 = 回合 signal aborted（#98 VSC 侧
@@ -161,7 +172,9 @@ export function buildChildSignal(parent, ctx) {
  * 对子代理对象的引用（`childAgent`/`report`——条目前此从不显式释放，挂起期 = 分钟级驻留）。
  * 幂等（重入不抛）；池内/挂起未消化窗口语义零变（settle 时刻不释放——表 2 候选 2 否决：
  * status/observe 在窗口内仍读 child 摘要）。三消费点（回合尾收集 / run 起始 pending 注入 /
- * 挂起残差注入）在注入完成后调本 helper。
+ * 挂起残差注入）——fallback 面（无 `_daSession`）注入完成后调本 helper（逐字沿用）；会话态
+ * （`_daSession`）注入后改调 `releaseChildHold`（仅释放 `childAgent`——`report` 保留至销账 /
+ * 升级；§6.31.4 ∥ KD-DA7）。
  */
 export function releaseSettledEntry(entry) {
   if (!entry || typeof entry !== "object") return
@@ -169,6 +182,16 @@ export function releaseSettledEntry(entry) {
   entry.report = null
 }
 
+/**
+ * §6.31.4 投递面（消化账务批 · 2026-10-05 · 台账 #930）：会话态注入后**仅**释放 `childAgent`——
+ * `report` 保留至销账 / 升级（重投需原文；驻留增量以报告量级 ∥ 重投上限封顶）。fallback 面零调用
+ * （既有 `releaseSettledEntry` 逐字沿用——注入即释放）。
+ */
+export function releaseChildHold(entry) {
+  if (!entry || typeof entry !== "object") return
+  entry.childAgent = null
+}
+
 /**
  * D3 settle 共享 helper——四族 settle 回调公共收尾单点（ASYNC-RESULT-CONTAINER.md
  * AC1：settle 记账单点，无逐字重复）。流程：
@@ -273,10 +296,11 @@ export function settleAsyncEntry(parent, entry, opts = {}) {
       parkAsyncPending(parent, entry)
       pool?.delete(String(entry.id))
     }
-    // 发射单点（块到达时点归位批 · #746｜§6.8「settle 延迟冻结（两态统一）」）：settle 一律 ⟦ev⟧settled
-    // （区块头恒中间态「done · awaiting digestion」驻留面板）；⟦ev⟧done = 消费面补发（消费窗清单单源
-    // = §6.8）⇒ 冻结 ∥ 归档恒落消费时点——回合运行中零归档触发器（「S 不夹运行中回合」结构不变式）。
-    ctx?.callbacks?.onToken?.(`${entry.relayPrefix}⟦ev⟧settled\x1e0\x1e0\x1esettled\x1e`)
+  // 发射单点（块到达时点归位批 · #746｜§6.8「settle 延迟冻结（两态统一）」）：settle 一律 ⟦ev⟧settled
+  // （区块头恒中间态「done · awaiting digestion」驻留面板）；⟦ev⟧done = 消费面补发（消费窗清单单源
+  // = §6.8）⇒ 冻结 ∥ 归档恒落投递时点（消化账务批 · 2026-10-05——归档 ≠ 销账；销账后移见账 = §6.31）；
+  // 回合运行中零归档触发器（「S 不夹运行中回合」结构不变式）。
+  ctx?.callbacks?.onToken?.(`${entry.relayPrefix}⟦ev⟧settled\x1e0\x1e0\x1esettled\x1e`)
   }
   // ④ 公共尾部：settleSeq 递增 + _settle 唤醒（never rejects）+ 唤醒挂起驱动 waiter
   entry._settleSeq = (parent._asyncSettleSeq = (parent._asyncSettleSeq ?? 0) + 1)