@thincoder/core 0.10.3 → 0.10.5

package/agent/run-stages.mjs

@@ -13,20 +13,27 @@ 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"
+import { discardAbortedPool, discardAbortedAdvisors, discardAbortedBgTasks, discardAbortedBrowserTasks } from "../agent-tools/async-discard.mjs"
 // R10 L3 (MULTI-INSTANCE-COLLAB §2a.5 D-L3a)：回合末域登记 flush（写工具钩子累积 →
 // 整写一次本实例 peers 文件——无写入跳过；失败容忍不抛）
 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)
@@ -190,20 +206,23 @@ export async function finalizeAgentTurn(agent, ctx) {
     const subPool = getAsyncPool(agent, "subagent")
     const advPool = getAsyncPool(agent, "advisor")
     const bgPool = getAsyncPool(agent, "bg") // #9：后台 bash 任务池（第三域）
-    if ((subPool?.size ?? 0) > 0 || (advPool?.size ?? 0) > 0 || (bgPool?.size ?? 0) > 0) {
-      logEvent("ev:stopped", { poolN: (subPool?.size ?? 0) + (advPool?.size ?? 0) + (bgPool?.size ?? 0), where: "turn-end-abort" })
+    const brPool = getAsyncPool(agent, "browser") // 批 browser-async-fix：后台浏览器动作池（第四域）
+    if ((subPool?.size ?? 0) > 0 || (advPool?.size ?? 0) > 0 || (bgPool?.size ?? 0) > 0 || (brPool?.size ?? 0) > 0) {
+      logEvent("ev:stopped", { poolN: (subPool?.size ?? 0) + (advPool?.size ?? 0) + (bgPool?.size ?? 0) + (brPool?.size ?? 0), where: "turn-end-abort" })
     }
     // §6.20：只清已死条目（存活/已 settle 留池——收尾见 async-discard.mjs；原无条件清池已弃）；
     // #9：后台 bash 任务同面（杀 ⟺ 控制器已中止——逐条杀树 + 出池 + 墓碑）。
     discardAbortedPool(agent)
     discardAbortedAdvisors(agent)
     discardAbortedBgTasks(agent)
+    discardAbortedBrowserTasks(agent) // 批 browser-async-fix：后台浏览器动作同面（不杀浏览器）
     // R17: the consult family dies with the user stop (marked stopped — no digest).
     cleanupConsultSessions(agent)
     // ASYNC-RESULT-CONTAINER.md D2：pending 单容器——中止丢弃 consult/escalate 族停靠
     // （原 _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 +239,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,56 @@ 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 · §6.34 收窄）：首投**仅系统轮**（`autoTurn`——用户回合零注入）∥ 重投仅消化轮；
+      // 注入后**留容器**（不 splice）。
+      // 注入抛错 ⇒ 未投条目（`_daDelivered` 未置）留容器待下轮——收窄既有「splice 先取尽」的丢失窗。
+      for (const e of [...pendingAsync]) {
+        if (!shouldDeliverEntry(e, digestRound, autoTurn)) 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 +122,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/setup-reminders.mjs

@@ -34,7 +34,7 @@ import { peerInstances } from "../peer-instances.mjs"
 import { specForModel } from "../config.mjs"
 import { manifestFilePath, readManifest, projectView } from "../manifest.mjs"
 
-/** env-state line builder — 对入参 + 进程端名确定（§6.20 端名缝 sessionEnd()；setSessionEnd 注入 ⇒ 单测可用）。
+/** env-state line builder — 对入参 + 进程端名确定（§6.20 端名缝 sessionEnd()；setSessionEnd 注入 ⇒ 单元测试可用）。
  *  §6.11（F1）：slot 字段入行——位置在 model 后 resumed 前（N3：无绑定 → 显式 null——
  *  不读 manifest active 共享指针——粘性 _slot 才是"本 agent 之槽"）。 */
 export function envStateLine({ mode, model, slot, resumed }) {

package/agent/setup.mjs

@@ -110,10 +110,25 @@ export async function prepareRun(agent, input, callbacks, {
     // §6.10 修法 B（TUI 假死批）：回合召回注入 = **depth-0 门**——子代理（depth > 0）不注入
     // 相关文档 / 相关记忆两块（同函数其余自动注入全为 depth-0 门；需求锚 = F-M7 + 核 §4.11）。
     if (agent.memory && depth === 0) {
-      const docs = await docSearch(agent.memory, input, { limit: DOC_SEARCH_LIMIT })
+      // ── 文档检索注入：§6.15 origin 集 + #1100 声明源保底名额（两路分取——总上限 2×DOC_SEARCH_LIMIT）──
+      // 无声明源（origin 集 ≤1）⇒ 原单调用路径逐字保留；有声明源 ⇒ 两路 `Promise.all` 并行：
+      // 本仓路（origin = 项目）∥ 声明源路（集 − 本仓），各 DOC_SEARCH_LIMIT——合并序 = 本仓 ≤5 在前
+      // + 声明 ≤5 补位（两路 origin 集互斥 ⇒ 行不可能重复，无需去重）。配额机制 = `docs/core/design/AGENT-LOOP.md` §6.3。
+      const originSet = searchOrigins(agent.memory)
+      let docs
+      if (originSet.length > 1) {
+        const project = normalizeOrigin(agent.memory.codeOrigin)
+        const [localDocs, declaredDocs] = await Promise.all([
+          docSearch(agent.memory, input, { limit: DOC_SEARCH_LIMIT, origins: [project] }),
+          docSearch(agent.memory, input, { limit: DOC_SEARCH_LIMIT, origins: originSet.filter((o) => o !== project) }),
+        ])
+        docs = [...localDocs, ...declaredDocs]
+      } else {
+        docs = await docSearch(agent.memory, input, { limit: DOC_SEARCH_LIMIT })
+      }
       if (docs.length > 0) {
-        // §6.14 B3 + §6.15：origin 集限定 + 有界计数（子查询 LIMIT = WARN+1 形——越界回「20000+」；跨 origin 全扫不再回升）
-        const origins = searchOrigins(agent.memory)
+        // §6.14 B3 + §6.15：origin 集限定 + 有界计数（子查询 LIMIT = WARN+1 形——越界回「+」形（WARN 值）；跨 origin 全扫不再回升）
+        const origins = originSet
         const bound = INDEX_ORIGIN_ROW_WARN + 1
         const countFilter = origins.length === 1 ? " WHERE origin = ?" : origins.length > 1 ? ` WHERE origin IN (${origins.map(() => "?").join(", ")})` : ""
         const countRow = agent.memory.db.prepare(

package/agent/subagent-event.mjs

@@ -12,7 +12,7 @@
  * 文法：`⟦ev⟧<小写名>\x1e<字段…>`（字段以 RS 分隔）。终止符约束 load-bearing：正文含
  * `⟦ev⟧` 而无 RS 终止符 ⇒ 非事件形态 ⇒ null ⇒ 消费方照常转发（不吞真实正文）。
  * 逐事件字段序 = 发射侧单源（各发射点既有构造——本批零改发射侧）；投影映射以样本逐字
- * 钉住（批内件 T-862-1…6）——发射侧改字段序 = 契约面变更（设计档 §12.3）。
+ * 钉住（单元测试档 T-862-1…6）——发射侧改字段序 = 契约面变更（设计档 §12.3）。
  */
 
 /** 事件 token 哨兵串（D1）——LLM 正常内容混淆概率极低；字段分隔用 RS (\x1e)。 */

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` ∥ 批 browser-async-fix 池 `_browserTasks` 同列；
+ * 消化账务批 · 2026-10-05 同列 `_daSession`（挂起会话标记——置位 / 复位单点）与
+ * `_unsettledDigests`（升级账本——中止清场））
  * ——CLI 形 = `agent` 对象；VSC 形 = depth-0
  * `history` 数组（附加属性不污染会话文件）。机制对载体零预设（空字段一律 `?.` 读）。
  *
@@ -56,12 +59,14 @@ function consultRunningChildren(carrier) {
 /** 后台池存活判据（D-S2/F5 口径——CLI 为准）：running/queued 的池条目，或已 settle 未注入
  * （pending 非空 = D-S3「未注入」），或运行中 consult children（会诊跨回合）。回合尾与每次
  * 轮末都评估退出。**#9 三域并入**：`_bgTasks`（后台 bash 任务）在途亦为 live——settle 经
- * pending 停靠驱动消化轮（`bash-async.mjs` 恒停靠）。 */
+ * pending 停靠驱动消化轮（`bash-async.mjs` 恒停靠）；**批 browser-async-fix 第四域**：
+ * `_browserTasks` 同判（`browser-async.mjs` 恒停靠）。 */
 export function poolLive(carrier) {
   const sub = carrier?._asyncSubagents
   const adv = carrier?._asyncAdvisors
   const bg = carrier?._bgTasks
-  return (sub && sub.size > 0) || (adv && adv.size > 0) || (bg && bg.size > 0)
+  const br = carrier?._browserTasks
+  return (sub && sub.size > 0) || (adv && adv.size > 0) || (bg && bg.size > 0) || (br && br.size > 0)
     || (carrier?._pendingAsyncResults?.length ?? 0) > 0
     || consultRunningChildren(carrier) > 0
 }
@@ -108,25 +113,30 @@ function consultLiveCount(carrier) {
 }
 
 /**
- * 退出清场（单点——驱动 finally 与单测共用）：
+ * 退出清场（单点——驱动 finally 与单元测试共用）：
  *  - 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 } = {}) {
   if (aborted) {
-    const { discardAbortedPool, discardAbortedAdvisors, discardAbortedBgTasks } = await import("../agent-tools/async-discard.mjs")
+    const { discardAbortedPool, discardAbortedAdvisors, discardAbortedBgTasks, discardAbortedBrowserTasks } = await import("../agent-tools/async-discard.mjs")
     discardAbortedPool(carrier)
     discardAbortedAdvisors(carrier)
     discardAbortedBgTasks(carrier) // #9 收尾档②：后台 bash 任务逐条杀树 + 出池 + 墓碑（杀 ⟺ 控制器已中止）
+    discardAbortedBrowserTasks(carrier) // 批 browser-async-fix：后台浏览器动作同面（在飞中止 + 出池 + 墓碑——不杀浏览器）
     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 +145,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 +238,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 +322,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/timers.mjs

@@ -2,12 +2,15 @@
  * agent/timers.mjs — timer 到期件（载体①：在途 timer 的单一权威读面）+ 空闲唤醒机制（闩 ∕ 派发 ∕ 火策略）。
  *
  * 机制单源 = `docs/core/design/AGENT-LOOP-ASYNC-POOL.md` §6.30.2（载体定形 D-TW1）：
- * 读面三件纯函数住本档——最近到期时点 / 到期出列（幂等）/ 历史注入单点。消费面三处共用
+ * 读面纯函数住本档——最近到期时点 / 到期出列（幂等 · 含周期重排）/ 历史注入单点 / 下一到期时点
+ * （`nextFireAt`——§6.30.18）。消费面三处共用
  * 同一读点（零第二份过滤语义）：① 回合边界轮询（`agent/post-turn.mjs`——行为零变）；
  * ② 空闲闩 deadline；③ 挂起窗 deadline；显示面（状态行标记 / `/timers`）同读源。
  *
- * 载体仍在 agent 字段 `_pendingTimers`（条目形 `{ id, expiresAt, message }`）——**唯一写点** =
- * timer 工具 `thincoder-core/agent-tools/timer.mjs`；跨 run 存活 = 规范语义（D-TW3，无 per-run 复位）。
+ * 载体仍在 agent 字段 `_pendingTimers`（条目形 `{ id, expiresAt, message }` ＋ 可选 `everyMs` ∥ `daily`——§6.30.18；
+ * 绝对时刻条目另携 `at` 来源标记位（非载重——父侧裁定 2026-10-12）；一次性条目形逐字零变）；写点两处 = timer 工具 `thincoder-core/agent-tools/timer.mjs`
+ * （设 ∕ 取消）＋ 本档 `takeExpiredTimers` 内**到点重排**（出列＋重排原子——§6.30.18 D-TW10）；
+ * 跨 run 存活 = 规范语义（D-TW3，无 per-run 复位）。
  *
  * 空闲唤醒族（2026-09-28 流程批 R4 **上提核件** · 纯搬 + 转口 · 零语义改；上提源 = VSC
  * `thincoder-vscode/src/extension/timer-watch.mjs:46` ∕ `:73` ∕ `:94`——as-of 2026-09-28 R4 读数；两端现址（B3 收编后，实读 2026-09-29）=
@@ -21,6 +24,13 @@
  *  形态先例 = 队满「拒 + 提示 + 保留」）。与 CLI 排队容量 `QUEUED_MAX_ITEMS`（8）同值同形。 */
 export const TIMER_MAX_PENDING = 8
 
+/** `every` 间隔下限（毫秒——§6.30.18 D-TW16）：工具面**硬拒**低于此值（不静默钳制）；
+ *  核重排面不设界（防御 = 非有限正数 ⇒ `nextFireAt` 返 `null` 照消费——下限校验在工具面）。 */
+export const TIMER_MIN_EVERY_MS = 60_000
+
+/** 日历式 `HH:MM` 形判据（防御面——工具面为唯一生产者，两处同形）。 */
+const DAILY_RE = /^(?:[01]\d|2[0-3]):[0-5]\d$/
+
 /** 最近到期时点（毫秒）或 `null`（空在途）——端闩 / 挂起窗 deadline / 显示面共用同源（每帧活读）。 */
 export function pendingTimerDeadline(agent) {
   const timers = agent?._pendingTimers ?? []
@@ -33,13 +43,54 @@ export function pendingTimerDeadline(agent) {
   return min
 }
 
+/** 下一到期时点（毫秒）或 `null`（无重排）——§6.30.18「载体扩展 ∥ 重排」单源：
+ *  ① 固定间隔（`everyMs`）：基准 = `entry.expiresAt`（首设刻）；`k = max(1, floor((now − base) / everyMs) + 1)`；
+ *     返 `base + k × everyMs`——**零漂移** ∥ 错过任意拍直落下一格（**跳过不补投**——一次出列对一条至多一投）；
+ *  ② 日历式（`daily` = `HH:MM`）：宿主本地**严格 `> now`** 的下一 occurrence（今日该刻未过 ⇒ 今日，已过 ⇒
+ *     明日；秒位归零——DST 按宿主日历规则走，不作特例）；
+ *  ③ 一次性 ∥ 绝对时刻（无两字段）⇒ `null`；守卫：`everyMs` 非有限正数 ∥ 基准非有限 ∥ `daily` 形不合
+ *     ⇒ `null`（照消费——防御面；下限校验在工具面）。
+ *  首设换算同函数：`every` ⇒ `nextFireAt({ everyMs, expiresAt: now }, now)`（= 设时 + N）∥ `daily` ⇒
+ *  `nextFireAt({ daily }, now)`；`at` ⇒ 直解算（不经本函数）。 */
+export function nextFireAt(entry, now) {
+  const everyMs = entry?.everyMs
+  if (everyMs !== undefined && everyMs !== null) {
+    const base = entry.expiresAt
+    if (typeof everyMs !== "number" || !Number.isFinite(everyMs) || everyMs <= 0) return null
+    if (typeof base !== "number" || !Number.isFinite(base)) return null
+    const k = Math.max(1, Math.floor((now - base) / everyMs) + 1)
+    return base + k * everyMs
+  }
+  const daily = entry?.daily
+  if (daily !== undefined && daily !== null) {
+    if (typeof daily !== "string" || !DAILY_RE.test(daily)) return null
+    const [hh, mm] = daily.split(":").map(Number)
+    const at = new Date(now)
+    at.setHours(hh, mm, 0, 0) // 秒位归零（该刻整分投递）
+    if (at.getTime() <= now) {
+      at.setDate(at.getDate() + 1) // 已过 ⇒ 明日（跨日 = `Date` 日历运算承载——零特例代码）
+      at.setHours(hh, mm, 0, 0) // 跨日归一后再归零（DST 走宿主日历规则）
+    }
+    return at.getTime()
+  }
+  return null
+}
+
 /** 到期出列（**幂等**）：取走 `expiresAt <= now` 的条目并返回（在途表内移除）——二次调用零返
- *  （§6.30.3 成本闸②「到期即消费」——绝不重复投递）。未到期项原序保留。 */
+ *  （§6.30.3 成本闸②「到期即消费」——绝不重复投递）。未到期项原序保留。
+ *  携 `everyMs`/`daily` 的到期项**同 id 克隆回插**（新 `expiresAt = nextFireAt(t, now)`，严格 `> now`——
+ *  §6.30.18 重排：出列＋重排原子 ∥ 净零不触帽；重排先于交付 ⇒「到点即重排」与「交付幂等」互不依赖）；
+ *  一次性 ∥ 绝对时刻照旧被消费（无重排）。 */
 export function takeExpiredTimers(agent, now = Date.now()) {
   const timers = agent?._pendingTimers ?? []
   const expired = timers.filter((t) => t.expiresAt <= now)
   if (expired.length === 0) return []
-  agent._pendingTimers = timers.filter((t) => t.expiresAt > now)
+  const rest = timers.filter((t) => t.expiresAt > now)
+  for (const t of expired) {
+    const next = nextFireAt(t, now)
+    if (next !== null) rest.push({ ...t, expiresAt: next })
+  }
+  agent._pendingTimers = rest
   return expired
 }
 

package/agent/turn-loop.mjs

@@ -22,7 +22,7 @@ import {
 
 export async function runTurnLoop(agent, {
   maxTurns, threshold, toolSchemas, toolByName, systemPrompt,
-  depth, signal, autoTurn, streamOutput,
+  depth, signal, autoTurn, suspDriven, streamOutput,
   consumeInjected, consumeQueuedInput, callbacks, distillSignal,
 }) {
   let guardPushbacks = 0
@@ -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
@@ -89,7 +105,9 @@ export async function runTurnLoop(agent, {
     // consumeInjected 回调承载（异步子代理专属——缺省 null：主会话/阻塞子代理零开销）。
     consumeInjected?.(agent)
     // 子代理在飞消息（子 → 父；§6.27）：空队列 no-op；非空 ⇒ 恰一条合并 user 消息注入。
-    drainChildUpstream(agent)
+    // 批 async-delivery-formalize（§6.34.2 行 2）：驱动面收窄「交付轮轮首」（`turn === 0` ∧ `autoTurn`——
+    // 用户回合零 drain）；回退面（`!suspDriven`）逐字保持（每轮每步）。
+    if (!suspDriven || (turn === 0 && autoTurn === true)) drainChildUpstream(agent)
     // ③ 用户 → 主会话投递（步边界 pickup——queue-visible 批 fix 轮 2026-09-24 · F16）：循环头
     // 回合边界缝（核只给缝、不给策略——取批 / pushReal / 呈现归端侧闭包）；缺省 null，系统轮不传
     // （`AGENT-LOOP-ASYNC-POOL.md` §6.8「步边界 pickup」· 适用面 = 用户回合）。
@@ -109,6 +127,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 验证）。
@@ -237,7 +262,7 @@ export async function runTurnLoop(agent, {
     // Commit tool results (pairing, multimodal deferral, mutation accounting, reindex)
     await recordToolResults(agent, toolByName, results)
 
-    injectPostTurn(agent, results, recentCallSigs, callbacks, turn)
+    injectPostTurn(agent, results, recentCallSigs, callbacks, turn, { suspDriven })
   }
 
   // #417（撞帽载荷「本段零落盘轮数」）：收尾轮（撞帽轮）若零落盘同样计入——轮顶计数只

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,11 +17,9 @@
  *    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
+ *    声明文档集（`inflightDesignReviewConflict` 同源 docAbs 分支）+ 批次档（`run.batchDoc`
+ *    分支——评审绑定批档在途时，写批档同样致 stale）。dispatch.mjs
  *    只 import 消费，不再各自直连 `advisor-settle.mjs`。
  * 3. `batchRecordWriteConflict(agent, depth, absPaths)` —— 批次档写门判据组装（#309 ·
  *    `AGENT-LOOP-SUBAGENT.md` §6.29.1）：判据与拒绝文案同址（文案字面只出本档）。
@@ -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,27 +59,12 @@ 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。
- * 声明文档集腿 = `inflightDesignReviewConflict`（同 docAbs / 同 normAbs，仅 running
- * 未取消的设计条目）；批次档腿 = 同池条目 `run.batchDoc`（评审绑定批档在途时写批档
- * 同样致 stale——被审文件集合流点）。两腿同形返回，消费端拒绝文案零改。
+ * 声明文档集分支 = `inflightDesignReviewConflict`（同 docAbs / 同 normAbs，仅 running
+ * 未取消的设计条目）；批次档分支 = 同池条目 `run.batchDoc`（评审绑定批档在途时写批档
+ * 同样致 stale——被审文件集合流点）。两分支同形返回，消费端拒绝文案零改。
  * @param {Object} agent
  * @param {string[]} absPaths — 本次写将触碰的路径（ABS——调用方 resolve(agent.cwd, p)）
  * @returns {{id: string, path: string}|null} 命中评审 id + 冲突路径（ABS），无冲突 null
@@ -144,10 +132,10 @@ function isOwnBatchCompanion(targetKey, boundKey) {
 /**
  * 批次档写门判据（#309 · `docs/core/design/AGENT-LOOP-SUBAGENT.md` §6.29.1——containment；
  * 2026-09-29 收窄 · 台账 #545）：
- * 工程角色子代理（`depth > 0` ∧ `agent._batchDoc` 在场）对**批次档文件**的写 ⇒ 目标 ≠ 绑定档
+ * 携绑定的子代理（`depth > 0` ∧ `agent._batchDoc` 在场——工程角色 ∥ 普通面 coder，`BATCH-RECORD.md` §4.16）对**批次档文件**的写 ⇒ 目标 ≠ 绑定档
  * **且非绑定批次的伴随件**（见 `isOwnBatchCompanion`）⇒ 冲突（fail-closed；写自己绑定的档 ∥
  * 自身批次伴随件 = 正常面放行）。比较键 = 绝对路径 + win32 大小写归一。
- * 界面：depth 0（主 agent——跨档处置是父侧职责）· 无 `_batchDoc`（非工程绑定族）· 主基底外的
+ * 界面：depth 0（主 agent——跨档处置是父侧职责）· 无 `_batchDoc`（未携绑定族——普通面 coder 亦入绑定面）· 主基底外的
  * 普通文件写 —— 三种形态均不进本门（返回 null，行为零变）。判据集由调用方限定 = `FILE_MUTATORS`
  * （`file_ops` / 读类不在门内——§6.29.1 边界）。
  * 拒绝文案**单源 = 本档**（两端直取 `message`——零字面副本）。