@thincoder/core 0.10.10 → 0.10.11

package/session-lifecycle.mjs

@@ -39,7 +39,9 @@ import { mergeAdjacentAssistantEchoes } from "./context.mjs"
 // 打开态读数公式（§6.24 判据句 2——与 CLI 状态行 / VSC 同式；零新公式，只组合）。
 import { historyPercent } from "./token-window.mjs"
 import { scheduleSessionGC } from "./session-gc.mjs"
-import { restoreEngTokens } from "./token-ttl.mjs"
+import { restoreEngTokens, tokenExpired } from "./token-ttl.mjs"
+// 槽事件（docs/core/design/SESSION-OBSERVABILITY.md §3.1）：`slot:new` 走核日志单一通道。
+import { logEvent } from "./log.mjs"
 import { clearPlanMode } from "./agent-tools/plan.mjs"
 import { bindRecordStore, unbindRecordStore, RECORD_WINDOW_MESSAGES } from "./session-store.mjs"
 // 会话级档位（§6.21 判据句 4）判据单源：off 形族（`think-off.mjs`）+ 逐模型枚举
@@ -73,8 +75,9 @@ function stripTruncatedToolArgs(m) {
   return changed ? { ...m, tool_calls } : m
 }
 
-/** Apply loaded session data onto an agent object; returns true if the runtime composite
- *  was switched. 2026-08-31 会诊 F1：清空 _slot/_slotMtime 缓存——切换后下次保存重新认领。
+/** Apply loaded session data onto an agent object; returns `{ switched, droppedDesignTokens }`
+ *  （`switched` = 运行态渠道是否被切——原布尔值；`droppedDesignTokens` = 离开本会话的未过期
+ *  设计凭证数，设计档 §3.2）。2026-08-31 会诊 F1：清空 _slot/_slotMtime 缓存——切换后下次保存重新认领。
  *
  *  MODEL-MERGE-SESSION（F-4）applySession 重写为两支 + 删旧支（评审 #7/#9 措辞——防
  *  "三支"误读）：
@@ -121,8 +124,8 @@ export function applySession(agent, data, opts = {}) {
   agent.goal = data.goal ?? null
   agent._pendingReminders = data.pendingReminders ?? []
   agent._sessionStart = data.sessionStart ?? null
-  // R16 token 字段恢复（过期过滤——见 token-ttl.mjs restoreEngTokens）
-  restoreEngTokens(agent, data)
+  // R16 token 字段恢复（过期过滤——见 token-ttl.mjs restoreEngTokens）；返回值 = 离开集计数（§3.2）
+  const restored = restoreEngTokens(agent, data)
   // engineering is session-level (2026-08-29): the slot value is the CLI session's authority
   // — config.json is only the initial default / cross-end mirror. A legacy slot without the
   // field keeps whatever config.json seeded (unchanged behavior).
@@ -207,11 +210,11 @@ export function applySession(agent, data, opts = {}) {
         agent.provider.reasoningEffort = data.effort
       }
     }
-    return switched
+    return { switched, droppedDesignTokens: restored.droppedDesignTokens }
   }
   // ② 槽无 key ∥ 不在册 → D-S3 保留——静默保持现状（落 config 链：config 统一解析产物已是
   //    `agent.provider`；不报错不纠正——两方都无效由调用侧复验 validateProvider 弹重选）
-  return false
+  return { switched: false, droppedDesignTokens: restored.droppedDesignTokens }
 }
 
 /**
@@ -266,6 +269,7 @@ export async function newSession(cwd, opts = {}) {
   writeSessionFile(slotPath(cwd, slot), data)
   // 摘要 `ts` 地板入参（#503 同族随动——保存面写后取 mtime；`slotMtime` 读失败 ⇒ null ⇒ 裸墙钟）
   m.slots[slot] = slotDigest(data, slotMtime(cwd, slot))
+  const prevSlot = Number.isInteger(m.active) ? m.active : null // 覆盖前 active（无则 null）
   m.active = slot
   // 2026-08-31 advisor round1 🟡：与 ensureActive 认领模型一致——立即记录新 slot 所有权，
   // 否则 /new 后到首次保存之间并发方（VS Code/另一 CLI）会把新 active 槽当"空闲可恢复"
@@ -287,19 +291,29 @@ export async function newSession(cwd, opts = {}) {
   saveManifest(cwd, m, deletions, opts.releaseStale ? { setActive: true, release: [slot] } : { setActive: true })
   // 2026-09-05 §6.10 D-4：/new 落点写本端记录（显式切换跟随——T-M8）
   writeEndMarker(cwd, slot)
+  // 槽事件（设计档 §3.1）：落定后一行——字段闭集，不带标题 / 路径。
+  logEvent("slot:new", { slot, prevSlot, reason: "new-session" })
   return slot
 }
 
 /** 清空会话运行态（/new 用，2026-08-31 会诊 F3）：_fullHistory/title/_sessionStart 等
  *  全部会话级状态 + 一次性注入标志必须全清——否则新会话首次落盘把旧会话完整人类线 +
  *  旧标题写进新槽（实锤 .19/.3 双副本）；注入标志不清则 /new 后新会话永不注入
- *  OS/cwd reminder（2026-09-01 会诊 glm 🟡）。autoApprove 是用户偏好，跨会话保留（有意）。 */
+ *  OS/cwd reminder（2026-09-01 会诊 glm 🟡）。autoApprove 是用户偏好，跨会话保留（有意）。
+ *  返回 `{ droppedDesignTokens }`（设计档 §3.2）——重建 Map 前数一遍的未过期凭证数。 */
 export function resetSessionState(agent) {
   agent._fullHistory = []
   agent.history = []
   agent.title = ""
   agent.tasks = []
   agent._sessionStart = null
+  // 设计档 §3.2（R2）：重建 Map 前数一遍「未过期」条目——返回值 = 端壳报明口径（离开集）
+  let droppedDesignTokens = 0
+  if (agent._engDesignTokens instanceof Map) {
+    for (const t of agent._engDesignTokens.values()) {
+      if (!(typeof t === "string" && tokenExpired(t))) droppedDesignTokens++
+    }
+  }
   // DESIGN-TOKEN-SETTLEMENT D3（2026-09-08）：单值镜像 `_engDesignToken` 退役——不再维护
   agent._engDesignTokens = new Map() // multi-design slots die with the session (2026-09-01 fix #2)
   agent._compressFailures = 0
@@ -322,6 +336,7 @@ export function resetSessionState(agent) {
   agent._lastEngState = false
   // /new 或切换：记录存储解绑（新槽由 cmd-new / 首保存补绑重新挂载——§6.14 绑定与对账）
   unbindRecordStore(agent)
+  return { droppedDesignTokens }
 }
 
 /** Switch the manifest active pointer to a slot. Returns the slot's session data

package/session-segments.mjs

@@ -41,6 +41,7 @@ export function slimForDisplay(m) {
   if (m && m.role === "assistant" && Array.isArray(m.tool_calls)) {
     let changed = false
     const tool_calls = m.tool_calls.map((tc) => {
+      if (!tc || typeof tc !== "object") return tc // 空元素原样带走：读取侧不许崩（#31）
       const args = tc.function?.arguments
       if (typeof args === "string" && args.length > 300) {
         changed = true

package/session-slot-claims.mjs

@@ -22,6 +22,8 @@ import { probeOwnersSync, ownerState, filterDeadOwners } from "./process-probe.m
 import { getSessionId, manifestPath, slotPath } from "./session-slots.mjs"
 // 清单读写（落盘单源住原档——静态环见头注；反向 re-export 保 import 面）。
 import { loadManifest, saveManifest } from "./session-slots-manifest.mjs"
+// 槽事件（docs/core/design/SESSION-OBSERVABILITY.md §3.1）：分到全新号时落 `slot:allocate`。
+import { logEvent } from "./log.mjs"
 
 /** 本进程**残留认领集**（F-CR1 释放谓词 —— **判据单源** · SESSION.md §6.2 / §6.16）：
  *  「释放 A ⟺ `slotSessions[A]` 为本进程 ∧ `A ∉ 保留集`」。`keep` = 保留集 = 落点槽 ∪ 本进程
@@ -177,9 +179,11 @@ export function allocateFresh(cwd, m, deadParam = null, bundle = null) {
   }
   let newSlot = allSlots.length > 0 ? allSlots[allSlots.length - 1] + 1 : 1
   while (liveClaimed(newSlot) || existsSync(slotPath(cwd, newSlot))) newSlot++
+  const prevSlot = Number.isInteger(m.active) ? m.active : null // 分配前 active（无则 null）
   m.active = newSlot
   m.slotSessions[newSlot] = mySessionId
   saveManifest(cwd, m, deadParam?.() ?? null, { setActive: true })
+  logEvent("slot:allocate", { slot: newSlot, prevSlot, reason: "all-slots-live" })
   return newSlot
 }
 

package/session-slot-write.mjs

@@ -26,6 +26,8 @@ import { existsSync, readFileSync, renameSync, statSync } from "node:fs"
 
 import { getSessionId, loadManifest, saveManifest, slotDigest, slotPath, writeSessionFile, sessionEnd } from "./session-slots.mjs"
 import { loadSlotFile, isLegacyTransient } from "./session.mjs"
+// 槽事件（docs/core/design/SESSION-OBSERVABILITY.md §3.1）：走核日志单一通道 `logEvent`。
+import { logEvent } from "./log.mjs"
 // token 形态单源（格式校验 + 到期时刻）——本档的保存面合并规则复用同一判定。
 import { tokenExpiryMs } from "./token-ttl.mjs"
 // 会话级偏好写面（§6.21 判据句 3）的判据单源——档位值域（`specForModel(...).reasoningEffortEnum`）
@@ -77,9 +79,11 @@ function rotateIfForeign(p, slot, data) {
     const diskLonger = Array.isArray(disk?.history) && Array.isArray(data?.history) &&
       disk.history.filter((m) => !isLegacyTransient(m)).length > data.history.length
     if (!(diskIsNewer || diskForeign || (diskStart && diskStart !== myStart) || diskLonger)) return null
+    const reason = diskIsNewer ? "newer-version" : diskForeign ? "foreign-cwd" : diskLonger ? "longer-record" : "other-session"
     const bak = `${p}.bak-${Date.now()}`
     renameSync(p, bak)
     console.error(`[session] slot ${slot} holds ${diskIsNewer ? `a newer-version file (v${disk.version})` : diskForeign ? `a foreign-cwd file (${disk.cwd})` : diskLonger ? `a longer record (${disk.history.length} > ${data.history.length} messages — concurrent append)` : `another session (start ${diskStart}, ours ${myStart})`} — preserved as ${bak}`)
+    logEvent("slot:rotate", { slot, reason, bak: true, via: "write" })
     return bak
   } catch (e) {
     // 文件存在但不可读（损坏 / 半写）：改名保留现场，不覆盖
@@ -89,6 +93,8 @@ function rotateIfForeign(p, slot, data) {
     }
     // 排障面：区分「现场不可读」与「轮转失败」——静默会让半写/占用现场无从定位。
     console.error(`[session] slot ${slot}: pre-write rotation check failed (${e?.message ?? e}) —${preserved ? " preserved as .corrupted" : " the scene could NOT be preserved"}`)
+    // 判别式（设计档 §3.1）：已保全 ⇒ unreadable；未保全 ⇒ rotate-failed（同一个 catch 的两个现场）。
+    logEvent("slot:rotate", { slot, reason: preserved ? "unreadable" : "rotate-failed", bak: false, via: "write" })
     return null
   }
 }

package/session-slots-manifest.mjs

@@ -37,6 +37,8 @@ import { getSessionId, manifestPath, slotPath, writeSessionFile } from "./sessio
 // 认领面（2026-09-28 拆分外提——见头注）：本档 import `staleClaims` 供 dropStaleClaims 取用，
 // 并在下方 re-export 全族保既有 import 面。
 import { staleClaims } from "./session-slot-claims.mjs"
+// 槽事件（docs/core/design/SESSION-OBSERVABILITY.md §3.1）：拒写 / 读回失败两处写时点。
+import { logEvent } from "./log.mjs"
 
 /** Extract slot metadata from history (shared by slotDigest and loadSlotMeta) */
 export function extractSlotMeta(history, activeProvider, updatedAt, title = "") {
@@ -145,6 +147,7 @@ export function ledgerHealth(cwd) {
 function refuseManifestWrite(p, reason, preserved = null) {
   noteRefusal(reason, p)
   console.error(`[session] saveManifest: write refused (reason=${reason}) path=${p}${preserved ? ` preserved=${preserved}` : ""}`)
+  logEvent("slot:refuse", { reason })
   return false
 }
 
@@ -162,6 +165,7 @@ function writeManifestBase(p, m) {
   if (trusted) return true
   noteRefusal("readback-failed", p)
   console.error(`[session] saveManifest: readback-failed path=${p} preserved=${preserveScene(p)}`)
+  logEvent("slot:refuse", { reason: "readback-failed" })
   return false
 }
 

package/token-ttl.mjs

@@ -129,6 +129,13 @@ export function engTokenSlotFields(agent) {
  *  残留——一次性语义。镜像若已过期/畸形 → 不迁移（drop——与 Map 过期项同处理，
  *  清盘闭环）。永不写 agent._engDesignToken。 */
 export function restoreEngTokens(agent, data) {
+  // 设计档 §3.2（R2）：整体替换前快照旧 Map 的「未过期 id 集」，落定后求差 = 离开集（非集合大小差）。
+  const before = new Set()
+  if (agent._engDesignTokens instanceof Map) {
+    for (const [id, t] of agent._engDesignTokens) {
+      if (!(typeof t === "string" && tokenExpired(t))) before.add(id)
+    }
+  }
   const map = new Map()
   if (data.engDesignTokens && typeof data.engDesignTokens === "object" && !Array.isArray(data.engDesignTokens)) {
     for (const [id, t] of Object.entries(data.engDesignTokens)) {
@@ -144,6 +151,9 @@ export function restoreEngTokens(agent, data) {
   }
   if (map.size > 0) agent._engDesignTokens = map
   else delete agent._engDesignTokens
+  let droppedDesignTokens = 0
+  for (const id of before) if (!map.has(id)) droppedDesignTokens++
+  return { droppedDesignTokens }
 }
 
 // ── 会话槽权威台账 I/O（DESIGN-TOKEN-SETTLEMENT D1/D2/D3——槽文件 = 权威结算台账） ──

package/tool-docs/advisor.md

@@ -1,9 +1,28 @@
-Run an independent review of your work. `type` is REQUIRED — one of exactly two values: 'design' reviews design / requirement documents BEFORE implementation (documents=[...] with the explicit doc paths — relative paths resolve against the session cwd first, then candidate project roots (project-root-relative e.g. <repo>/docs/…, or absolute; relative forms are also tried against the session cwd's ancestor directories); plus batchDoc when a batch record is in flight); 'code' reviews the code you changed AFTER implementation (paths=[...] to scope files/directories; documents=[...] adds acceptance-criteria context). A call without a type (or with a conflicting object.type) is refused — no default, no silent fallback.
+Run an independent review of your work. `type` is REQUIRED — one of exactly two values, no default and no silent fallback.
 
-The advisor is an independent read-only sub-agent (explores the codebase, reads files, traces callers via grep/lsp). Code review converges: round 1 full review → round 2 verifies the agent's fix claims → round 3+ re-checks only the fix claims. Design review is a single pass against methodology and requirements. Criteria come from .thincoder/advisor.md (if present) or sensible defaults. After the review you MUST produce a response table (format = discipline rules); on all-clear, call verify.
+- `type="design"` — design review: reviews design / requirement documents BEFORE implementation. Pass `documents=[...]` (the explicit list), plus `batchDoc` when a batch record is in flight.
+- `type="code"` — code review: reviews the code you changed AFTER implementation. Pass `paths=[...]` to scope files/directories; `documents=[...]` adds acceptance-criteria context.
 
-object={type,target,status,reason,exclude} optionally anchors the review target — mechanically injected at the start of the review message; absent = no injection.
+`documents` — one rule: a relative path resolves against the session project root (e.g. `docs/core/design/ADVISOR-GUARDS.md`); an absolute path is used as-is.
 
-ASYNC (depth 0 only): the review runs in the BACKGROUND by default — ack immediately, the report arrives automatically in a digest turn. One shared pool (agent.poolLimits.advisor, default 4 — configurable via /config 并发池 or config.json; pool-full and same-scope launches are refused stating the current limit) — launch reviews one at a time. Inside a child (depth>0) reviews are always synchronous (async:true rejected).
+The relative form needs the session anchor to be inside a project. When the anchor is a workspace root (several projects below it, no manifest of its own) there is no single project root to resolve against, and a relative path is refused with `no-project-root` — write the absolute path there.
 
-Returns the verdict: all-clear (call verify) or a findings list to fix.
+Accepted = an existing `.md` file anywhere inside a project — a doc sitting at the repo root counts. Anything else is refused with the resolved path, the reason and the two expected forms.
+
+A call without a type (or with a conflicting `object.type`) is refused.
+
+The advisor is an independent read-only sub-agent (explores the codebase, reads files, traces callers via grep/lsp).
+
+- Code review converges: round 1 full review → round 2 verifies the agent's fix claims → round 3+ re-checks only the fix claims.
+- Design review is a single pass against methodology and requirements.
+- Criteria come from `.thincoder/advisor.md` (if present) or sensible defaults.
+- After the review you MUST produce a response table (format = discipline rules); on all-clear, call `verify`.
+
+`object={type,target,status,reason,exclude}` optionally anchors the review target — mechanically injected at the start of the review message; absent = no injection.
+
+ASYNC (depth 0 only): the review runs in the BACKGROUND by default — ack immediately, the report arrives automatically in a digest turn.
+
+- One shared pool: `agent.poolLimits.advisor`, default 4 — configurable via `/config` 并发池 or config.json. Pool-full and same-scope launches are refused stating the current limit; launch reviews one at a time.
+- Inside a child (depth>0) reviews are always synchronous (`async:true` rejected).
+
+Returns the verdict: all-clear (call `verify`) or a findings list to fix.

package/tool-docs/doc_check.md

@@ -1,53 +1,59 @@
 Run a built-in documentation-discipline check on a project and report its findings.
 Read-only. In the default `report` mode it is non-gating: it reports, it never blocks, never sets an exit code, and its output is never a reason to refuse a task or a user instruction.
-When the engine files are newer than this session's start time (or unreadable), `report` prefixes its output with one
-`[doc_check note]` line naming the stale files — that reading came from an engine loaded at startup and is not usable as
-delivery evidence. Nothing else changes: `report` still produces no verdict and no existing line is altered (no stale files ⇒
-the report is byte-identical).
 
 What it checks — exactly two criteria, both built into the engine:
 - Anchors — every documentation pointer (a `*.md` token, optionally carrying directory segments, optionally followed by a section
   indicator `§N` / `§N.M` / `§N.M.K`) must resolve: the file must exist on disk (`档缺` when it does not), and when a section
   indicator is given the target file must carry a heading numbered with it (`节缺` when it does not). Line-number coordinates
+
   (`<doc>:12`) are not section references and are not judged as such. Files inside fenced code blocks and executable lines
   (command / pattern code spans) are skipped whole.
 
 ~~~text
-  **Operand names.** Six names count as operands rather than documents: the model writes them, or reads a file by that name. On
-  the prompt face (`thincoder-core/prompts/**`) they are stripped from a line before extraction. On other faces four of the six are
+  **Operand names.** Seven names count as operands rather than documents: the model writes them, or reads a file by that name. On
+  the prompt face (`thincoder-core/prompts/**`) they are stripped from a line before extraction. On other faces four of the seven are
+
   exempt as file-name classes — `AGENTS.md`, `SKILL.md`, `.thincoder/advisor.md`, `project_rules.md` — while `README.md` and
-  `MANIFEST.md` are still judged as pointers. The six:
+  `MANIFEST.md` are still judged as pointers. `RTM.md` is stripped on the prompt face; on other faces it is judged as a pointer — write it path-qualified (e.g. `test/RTM.md`) so it resolves. The seven:
 
   ```text
-  AGENTS.md  SKILL.md  README.md  MANIFEST.md  .thincoder/advisor.md  project_rules.md
+  AGENTS.md  SKILL.md  README.md  MANIFEST.md  .thincoder/advisor.md  project_rules.md  RTM.md
   ```
 ~~~
 
-- Line width — a line whose character count (CJK counts as 1) exceeds the built-in threshold, unless it is a table row, inside a
-  fenced code block, an executable line, a quote-block line, or inside an exempt zone.
+- Paragraph length — on a document face, adjacent non-blank body lines merge into one paragraph whose total character
+  count (CJK counts as 1) is judged against the built-in threshold; blank lines, table rows, headings, list items,
+  quote-block lines and fenced code blocks do not count into a paragraph and break it, and lines inside an exempt zone
+
+  are excluded. Breaking a paragraph into more lines changes nothing — only splitting it into more paragraphs or
+  writing it shorter passes.
+- Line length — a prompt-face file (`thincoder-core/prompts/**`) is judged line by line: the model reads raw text, so
+  one line is one block, and any single line over the threshold counts with no structural exemption.
 
 It cannot — in `report` mode — write anything, gate anything, or turn a finding into a refusal.
 
 Arguments — `target` (optional): the project root to check; defaults to the session anchor, relative paths resolve against it.
 A workspace target (several projects below it) is reported with the full candidate list — pass the project root you mean.
+
 `mode` (optional) — `report` (default: a non-gating report over the documents you list) or `gate` (the delivery gate below).
 `docs` (required) — the documents to judge, as paths relative to the project root or absolute; each is judged whole and nothing
+
 else is read except the targets those documents point at. Omitted in `gate` mode ⇒ the Markdown documents this session wrote.
 There is no default range in `report` mode: omitting `docs`, or passing an empty list, is refused rather than widened — nothing
+
 is scanned unless you name it. A path that is not on disk or is not a Markdown document is an error in `report` mode and nothing
 is judged; in `gate` mode such paths are listed as skipped instead. A pointer resolves against the project root (full path) or
+
 against the pointing document's own directory — bare names are not resolved across other directories.
 
 Delivery gate — `mode: "gate"`, for the end of a design or development round. Every listed doc is judged **whole**: a
-pre-existing dangling pointer or overlong line anywhere in it counts, not only this round's edited lines. The first line is the
+pre-existing dangling pointer or overlong paragraph / line anywhere in it counts, not only this round's edited lines. The first line is the
+
 machine-readable verdict — `DOC-CHECK GATE: PASS` / `DOC-CHECK GATE: REFUSED（命中 K 条）` / `DOC-CHECK GATE: ERROR（reason）` —
 and consumers judge by that prefix; the hits are fixed in the same round and are never booked to the ledger. The gate refuses
+
 **one delivery**, not a user instruction: an explicit user go-ahead is followed, with the hits written into the delivery.
-Before running the criteria the gate checks engine-version consistency: the six engine files (`doc-check/index.mjs` /
-`doc-check/anchors.mjs` / `doc-check/width.mjs` / `doc-check/version.mjs` / `agent-tools/doc-check.mjs` / this tool description) each have their mtime
-compared with this process's start time — newer, or unreadable, ⇒ `DOC-CHECK GATE: ERROR（引擎已更新…）` instead of a PASS,
-because a session keeps the engine modules it loaded at startup. `ERROR` is fail-closed (no PASS means not passed): restart the
-session and re-run; a multi-project workspace ⇒ name the project root, per the stated cause.
+`ERROR` is fail-closed (no PASS means not passed): a multi-project workspace ⇒ name the project root, per the stated cause.
 
 Do not wire it as a gate or CI step in `report` mode, and do not treat a finding as a reason to refuse an instruction — a
 machine check never outranks a user instruction.
@@ -59,6 +65,7 @@ Side effects and permissions — none. The tool is read-only: no writes, no appr
 
 Parameters and scope — both criteria run on built-in constants (`DOC_CHECK_BUILTINS`: threshold 300 characters, no exempt zones,
 no exemptions), and the judged set is the document list the caller passes — the judged set and the resolution set are the same
+
 documents, so there is no scan-dir / domain / root / exclude surface and no whole-repository scan. Changing a criterion or a
 threshold is a code change and goes through review; no project declaration changes these readings.
 

package/tool-docs/ledger.md

@@ -1,8 +1,8 @@
 台账统一入口——action = add / update / close / query / count。query / count 只读全角色；add / update / close 写仅主 agent。
 - add：新增条目入待讨论。kind = requirement（需求池）/ tech_todo（技术待办）；trigger = 归批 / 条件 / 认账不排期（可空）；resume_when = 复启条件句（可空；值非空——空串 / 全空白拒；句内可带锚 `@YYYY-MM-DD`（机判到期）或 `@事件件名`（机器不判））。task_book 写门（add ∥ update 同判，判本笔写入面）：结果行 在途 / 待核销 ∥ trigger = 归批 ⇒ task_book 必填（缺 / 空串 / 全空白拒）；本笔新写 task_book（非空值）∥ 本笔新写 trigger = 归批 ⇒ 该指针的文件部分（首个 `§` 前子串）须可解析且指出的档在盘，否则拒。本笔不动指针 ⇒ 零判零阻——旧指针所指档已被清理不阻 status / evidence / 其它字段更新（「档在不在盘」是读数 taskBookOnDisk，不是门）。
-- update：按六态允许表迁移：待讨论→待设计 / 待设计→在途 / 在途→待核销 / 待核销→已核销 / 任意态→已废弃；表外拒。id ∥ batch 恰携其一。status 缺省 = 仅更新字段；executor 缺省 = 进入待设计 / 在途自动写本会话，出在途 / 撤回清空；resume_when 同 update 可空字段（缺省 = 不变）。evidence 传入 = 追加（旧值非空 ⇒ 拼接 `旧｜新`——「｜」零空格；旧空直写）；`evidenceReplace: true` 与 evidence 同传 = 整段替换；旗独传（无新文）∥ 新值全空白 ⇒ 拒。
+- update：按六态允许表迁移：待讨论→待设计 / 待设计→在途 / 在途→待核销 / 待核销→已核销 / 任意态→已废弃；表外拒；迁移入 已核销 时结果行标题携「收尾链待跑」同拒（同笔携清标记 title 放行）。id ∥ batch 恰携其一。status 缺省 = 仅更新字段；executor 缺省 = 进入待设计 / 在途自动写本会话，出在途 / 撤回清空；resume_when 同 update 可空字段（缺省 = 不变）。evidence 传入 = 追加（旧值非空 ⇒ 拼接 `旧｜新`——「｜」零空格；旧空直写）；`evidenceReplace: true` 与 evidence 同传 = 整段替换；旗独传（无新文）∥ 新值全空白 ⇒ 拒。
 - update --batch：批级批量迁移（batch = 批档指针，与该档 task_book 同址的行一次处理）——携 status ⇒ 逐行按迁移表重判；不携 status ⇒ 纯字段补丁（status 零写）。回执 { batch, status, applied, skipped }；被跳过的行逐行点名 { id, from, why }（why = 逐行拒因原文），其余行照落；事务级失败整批回滚。batch 值须可解析且批档在盘，否则拒。
-- close：勾销（待核销 → 已核销）；追认核销（待讨论 / 待设计 → 已核销，须有 evidence——可随本调用传入（一跳核销），判结果值：缺 / 全空白拒）；在途 → 已核销 不可跳；撤回（任意态 → 已废弃）。软删除（写 closed_at，行保留）。id ∥ batch 恰携其一。evidence 传入 = 追加（旧值非空 ⇒ 拼接 `旧｜新`；旧空直写）；`evidenceReplace: true` 同传 = 整段替换；旗独传 / 新值全空白 ⇒ 拒；缺省 = 判行值。
+- close：勾销（待核销 → 已核销）；追认核销（待讨论 / 待设计 → 已核销，须有 evidence——可随本调用传入（一跳核销），判结果值：缺 / 全空白拒）；在途 → 已核销 不可跳；核销标记门：结果行标题携「收尾链待跑」⇒ 拒（收尾链未跑完，不许核销——先跑收尾全链，再由父侧清标记）；撤回（任意态 → 已废弃）不拦。软删除（写 closed_at，行保留）。id ∥ batch 恰携其一。evidence 传入 = 追加（旧值非空 ⇒ 拼接 `旧｜新`；旧空直写）；`evidenceReplace: true` 同传 = 整段替换；旗独传 / 新值全空白 ⇒ 拒；缺省 = 判行值。
 - close --batch：批级批量结算——只销已到 待核销 的行（勾销）；待讨论 / 待设计 逐行点名跳过（追认核销不入批量面，转单行 close），在途 逐行点名跳过（不可跳）；已核销 / 已废弃 行静默不计。status 可不给（缺省 = 已核销），给了只能是 已核销。
 - query：SQLite 行集，等值过滤（status / kind / board / trigger / task_book）缺省 = 全部行；行集逐行携 aged（未决四态 ∧ 行龄 > 30 天）/ evidenceOversize（evidence 超软上限 300 字——读数非拒写）/ taskBookOnDisk（task_book 文件部分解析成立 ∧ 该档在盘 ⇒ true；缺指针 / 不可解析 / 不在盘 ⇒ false——读数非门，不拦任何写入）/ overdue（出口态字串 ∥ null：resume_due / dangling / unlabeled / aged，首中优先）。六态 = 待讨论 / 待设计 / 在途 / 待核销 / 已核销 / 已废弃。
 - count：回报 { count, overdue, evidenceOversize }——count = 未决四态（待讨论 / 待设计 / 在途 / 待核销）行数；overdue = 其中命中出口态的行数；evidenceOversize = 其中 evidence 超限行数。task_book 等值过滤。

package/tool-docs/subagent.md

@@ -1,36 +1,61 @@
 ONE tool, NINE actions — pick by what you need:
 
 - action:'spawn' (DEFAULT): run a sub-agent in its own isolated context — its reads, searches and tool calls never reach your history; only the final report comes back. Spawn MULTIPLE subagents in the SAME response for parallel work — they run concurrently.
-- action:'status': NON-BLOCKING progress query — returns immediately, consumes nothing, never fetches. Pass the spawn id for one child (role, state: running|queued|done, model, elapsed, turn, position, plus a touched-files summary — first 5 + a count) or omit it for a pool overview — see what a running child has changed BEFORE cancelling it. Background advisor reviews share this surface (pass the review id — role:'advisor', reviewType/round/elapsedSec, same shape).
-- action:'observe': SEE what a running async subagent is DOING right now (progress vs stuck) — pass the id; returns state, turn, the tool(s) executing right now (omitted when none), and the last N one-line turn summaries, newest first (default 5, via recent). Readonly; running/queued/done all answer — queued returns a placeholder, done gives the activity summary only, NOT the report (it rides the auto channel). Judge stuck vs progressing BEFORE cancelling or steering.
-- action:'send': STEER a running async subagent mid-flight — id + message (a direction, e.g. "check X, don't fixate on Y"). The child consumes it at its next turn boundary as an ORDINARY user instruction (non-interrupting; its discipline is unchanged — guidance, not a deviation waiver); returns {id, status:'delivered', queued}. Only RUNNING async children are targetable — sync/queued/settled/unknown error clearly; if the child settles first, its report carries an 'undelivered' note.
-- action:'escalate' (飞刀): hand an implementation task to a STRONGER model from your consult models; it gets WRITE access and does the work itself, then returns a post-op report (what changed, why, verification). Escalate EARLY, when the task calls for stronger hands (complex refactors, intractable bugs, intricate algorithms — or beyond your comfortable ability). Not available in engineering mode (implementation goes through eng-coder). Default-async at depth 0: ack {id, role:'escalate', status:'running'} returns immediately; the report arrives automatically with its mutations merged into your bookkeeping (pooled with the other role-domain spawns).
-- action:'cancel': STOP ONE background subagent — the id from the spawn return is REQUIRED (a blanket cancel is unsupported; Ctrl+C stops everything). Running aborts immediately ({id, status:'cancelled'}); queued is removed ({id, status:'cancelled', was:'queued'}; later positions shift). Other children and the session keep running. Cancel is a last resort: verify alarming signals with reliable checks (git/node — not guesses) first, and prefer scoped recovery — a running child's in-flight work dies with it, partial changes stay unmerged and unaudited. Background advisor reviews cancel the same way (pass the review id — no token is issued for a cancelled review).
-- action:'consume-design' (engineering mode, parent side): chain-terminal token consumption — after the delivery is verified and the chain closes out, consume this design's token slot. Selectors — pass exactly ONE: designId (a single slot; optional for a single-design session), designIds (an explicit non-empty list), expired:true (every expired slot), or olderThanDays:N (every slot older than N days). A consumed slot mechanically rejects further spawns for the same designId — new work (deviation fixes included) needs a fresh design review and token. Idempotent (unknown/already-consumed = a no-op notice); batch calls report per-slot lines + a `consumed N` count line. Do NOT call while the chain is still open — fix rounds reuse the same slot.
-- action:'design-slots' (engineering mode, parent side): READ-ONLY inventory of this session's approved design token slots — one line per slot (designId, live|expired, ageDays, expiresAt, batch, designToken), oldest first, ending with a total/live/expired count line. Nothing is written. Use it to see what still holds a slot before consuming; the expired / olderThanDays selectors act on the same set.
-  Every row carries its designToken value (expired ones included — status marks them; a malformed record shows designToken=—). Pass designId to filter to a single slot (trimmed exact match; unknown = refused with the held id list; empty string = no filter). Take designId + designToken verbatim onto the eng-coder spawn — the gate checks exact equality.
-- action:'panel': DIAGNOSE + fix the subagent panel (the collapsible blocks the user sees; headless/VS Code degrade to a 'no panel' pool view). view (default): the live blocks (key, role, status: running|done|awaitingDigest) exactly as the user sees them — digested-stuck entries carry digested:true. freeze: pass a digested-stuck block key (e.g. 'eng-coder#9' — {action:'panel', freeze:'role#N'}) to reclaim it into the conversation — passes ONLY for awaitingDigest blocks with no live pool entry and no pending report (a still-pending report would break the digestion order — refused).
+- action:'status': NON-BLOCKING progress query — returns immediately, consumes nothing, never fetches. Pass the spawn id for one child (role, state: running|queued|done, model, elapsed, turn, position, plus a touched-files summary — first 5 + a count) or omit it for a pool overview — see what a
+  running child has changed BEFORE cancelling it. Background advisor reviews share this surface (pass the review id — role:'advisor', reviewType/round/elapsedSec, same shape).
+- action:'observe': SEE what a running async subagent is DOING right now (progress vs stuck) — pass the id; returns state, turn, the tool(s) executing right now (omitted when none), and the last N one-line turn summaries, newest first (default 5, via recent). Readonly; running/queued/done all answer
+  — queued returns a placeholder, done gives the activity summary only, NOT the report (it rides the auto channel). Judge stuck vs progressing BEFORE cancelling or steering.
+- action:'send': STEER a running async subagent mid-flight — id + message (a direction, e.g. "check X, don't fixate on Y"). The child consumes it at its next turn boundary as an ORDINARY user instruction (non-interrupting; its discipline is unchanged — guidance, not a deviation waiver); returns {id,
+  status:'delivered', queued}. Only RUNNING async children are targetable — sync/queued/settled/unknown error clearly; if the child settles first, its report carries an 'undelivered' note.
+- action:'escalate' (飞刀): hand an implementation task to a STRONGER model from your consult models; it gets WRITE access and does the work itself, then returns a post-op report (what changed, why, verification). Escalate EARLY, when the task calls for stronger hands (complex refactors, intractable
+  bugs, intricate algorithms — or beyond your comfortable ability). Not available in engineering mode (implementation goes through eng-coder). Default-async at depth 0: ack {id, role:'escalate', status:'running'} returns immediately; the report arrives automatically with its mutations merged into
+  your bookkeeping (pooled with the other role-domain spawns).
+- action:'cancel': STOP ONE background subagent — the id from the spawn return is REQUIRED (a blanket cancel is unsupported; Ctrl+C stops everything). Running aborts immediately ({id, status:'cancelled'}); queued is removed ({id, status:'cancelled', was:'queued'}; later positions shift). Other
+  children and the session keep running. Cancel is a last resort: verify alarming signals with reliable checks (git/node — not guesses) first, and prefer scoped recovery — a running child's in-flight work dies with it, partial changes stay unmerged and unaudited. Background advisor reviews cancel
+  the same way (pass the review id — no token is issued for a cancelled review).
+- action:'consume-design' (engineering mode, parent side): chain-terminal token consumption — after the delivery is verified and the chain closes out, consume this design's token slot. Selectors — pass exactly ONE: designId (a single slot; optional for a single-design session), designIds (an
+  explicit non-empty list), expired:true (every expired slot), or olderThanDays:N (every slot older than N days). A consumed slot mechanically rejects further spawns for the same designId — new work (deviation fixes included) needs a fresh design review and token. Idempotent
+  (unknown/already-consumed = a no-op notice); batch calls report per-slot lines + a `consumed N` count line. Do NOT call while the chain is still open — fix rounds reuse the same slot.
+- action:'design-slots' (engineering mode, parent side): READ-ONLY inventory of this session's approved design token slots — one line per slot (designId, live|expired, ageDays, expiresAt, batch, designToken), oldest first, ending with a total/live/expired count line. Nothing is written. Use it to
+  see what still holds a slot before consuming; the expired / olderThanDays selectors act on the same set.
+  Every row carries its designToken value (expired ones included — status marks them; a malformed record shows designToken=—). Pass designId to filter to a single slot (trimmed exact match; unknown = refused with the held id list; empty string = no filter). Take designId + designToken verbatim onto
+  the eng-coder spawn — the gate checks exact equality.
+- action:'panel': DIAGNOSE + fix the subagent panel (the collapsible blocks the user sees; headless/VS Code degrade to a 'no panel' pool view). view (default): the live blocks (key, role, status: running|done|awaitingDigest) exactly as the user sees them — digested-stuck entries carry digested:true.
+  freeze: pass a digested-stuck block key (e.g. 'eng-coder#9' — {action:'panel', freeze:'role#N'}) to reclaim it into the conversation — passes ONLY for awaitingDigest blocks with no live pool entry and no pending report (a still-pending report would break the digestion order — refused).
 
 Why delegate? The child's noise never reaches your window — delegation keeps your context lean and the child focused; parallel children save wall-clock time, and coder/eng-coder children self-review (verify + advisor) before their reports arrive.
 
 Available roles (exposed per mode; the role is REQUIRED for action:'spawn' — a missing or misspelled role is refused):
 - explore — read-only search & analysis (read/search family); no git context — evidence comes from reads and the task book; its report must list what it searched and what it did NOT find. Say quick / medium / thorough (default medium).
 - plan — read-only planning; NEVER edits; returns a step-by-step plan.
-- coder — full implementation; the parent's complete read/write/execute toolset plus verify and advisor self-review. Its report carries a delivery table, one row per requirement (Done / Simplified / Not done — no deferred column). Normal mode: may optionally carry `batchDoc` — binds this spawn's §5 record-write channel (unbound ⇒ the main agent records §5 on its behalf); when provided the path must resolve to a readable file.
-- eng-coder — engineering mode only (replaces coder): same toolset plus the design-driven methodology overlay; its delivery protocol (implementation → audit → self-fix → advisor re-review → converged delivery) runs fully inside the child. REQUIRES a valid designToken from a passed advisor(type='design') review — pass the exact value from that review, or copy it verbatim from the action:'design-slots' row (the text after designToken=): missing or mismatched = the spawn is refused, and an expired token is refused with expired named (its reply also echoes a designId — pass it: required to pick between concurrent designs, optional for one; echo it back in the delivery report). REQUIRES a batchDoc — the batch record path, the task book this spawn implements (refused without it or when it does not resolve to a readable file).
-- eng-designer — engineering mode only: the SOLE author of the requirements/design documents and of the batch record's design section. Writes no implementation code, does not edit prompts, does not fire reviews, needs NO designToken. Surveys on its own; may only spawn read-only explore children (sync, ≤6 per batch). REQUIRES a batchDoc (same gate as eng-coder).
+- coder — full implementation; the parent's complete read/write/execute toolset plus verify and advisor self-review. Its report carries a delivery table, one row per requirement (Done / Simplified / Not done — no deferred column). Normal mode: may optionally carry `batchDoc` — binds this spawn's §5
+  record-write channel (unbound ⇒ the main agent records §5 on its behalf); when provided the path must resolve to a readable file.
+- eng-coder — engineering mode only (replaces coder): same toolset plus the design-driven methodology overlay; its delivery protocol (implementation → audit → self-fix → advisor re-review → converged delivery) runs fully inside the child. REQUIRES a valid designToken from a passed
+  advisor(type='design') review — pass the exact value from that review, or copy it verbatim from the action:'design-slots' row (the text after designToken=): missing or mismatched = the spawn is refused, and an expired token is refused with expired named (its reply also echoes a designId — pass it:
+  required to pick between concurrent designs, optional for one; echo it back in the delivery report). REQUIRES a batchDoc — the batch record path, the task book this spawn implements (refused without it or when it does not resolve to a readable file).
+- eng-designer — engineering mode only: the SOLE author of the design documents and of the batch record's design section (requirement docs stay with the main agent). Writes no implementation code, does not edit prompts, does not fire reviews, needs NO designToken. Surveys on its own; may only spawn
+  read-only explore children (sync, ≤6 per batch). REQUIRES a batchDoc (same gate as eng-coder).
 
-Task book (every spawn role): four core structured parameters — goal (goal & why), knownFacts (the facts you already verified), acceptance (machine-verifiable criteria), reportFormat (delivery-report format) — plus ONE fifth parameter named by role: designPoints (design points & forbidden scope) for eng-coder/eng-designer, scope (scope & forbidden scope — what to read / what not to touch) for explore/plan/coder. All five are required: a missing, blank or non-string value is refused with the parameter named, and one role's fifth name never substitutes for the other's. They are composed into the child's brief in that order. A free-text task is an optional supplement, never the whole brief; round (initial|fix) is mandatory for eng-coder/eng-designer. An eng-coder spawn also carries designToken — the write credential (the exact value from the review, or copied verbatim from the action:'design-slots' row, the text after designToken=): missing or mismatched = the spawn is refused.
+Task book (normal-mode roles: explore / plan / coder): four core structured parameters — goal (goal & why), knownFacts (the facts you already verified), acceptance (machine-verifiable criteria), reportFormat (delivery-report format)
+— plus scope (scope & forbidden scope — what to read / what not to touch).
+All five are required: a missing, blank or non-string value is refused with the parameter named.
+A free-text task is an optional supplement, never the whole brief.
+Engineering roles (eng-coder / eng-designer) take their task book from the batch record: batchDoc (the record path) and round (initial|fix), plus files / dependsOn for scheduling; the child reads §2 of that record itself — no other task text is passed.
+An eng-coder spawn also carries designToken — the write credential (the exact value from the review, or copied verbatim from the action:'design-slots' row, the text after designToken=), and designId when several designs are open: missing or mismatched = the spawn is refused.
 
 Pass one parameter per field — contents only (the runtime adds the labels):
-subagent(role="eng-coder", round="initial", goal="…", knownFacts="…", designPoints="…", acceptance="…", reportFormat="…", batchDoc="<batch record>", designToken="…")
+subagent(role="eng-coder", round="initial", batchDoc="<batch record>", designToken="…", files=[…])
 subagent(role="explore", goal="…", knownFacts="…", scope="…", acceptance="…", reportFormat="…")
 
 Mode filtering: normal mode exposes explore/plan/coder; engineering mode exposes explore/eng-designer/eng-coder — off-mode roles are refused mechanically (enums filtered at assembly; the spawn gate re-checks).
 
-Async spawn: top-level spawns are async by default — never pass async:false at depth 0 (the spawn returns {id, status:"running"} immediately; the report arrives automatically; if your next step needs it, end the turn and let the digest deliver it — do not poll; the explicit async:false is a mechanism parameter, not for model use). Inside subagents (depth>0) spawns are always synchronous. Async spawns are pooled per role domain — 4 concurrent eng-coders plus 4 concurrent other-role spawns by default (agent.poolLimits overrides both); a full domain queues further spawns with a position while the other keeps starting.
+Async spawn: top-level spawns are async by default — never pass async:false at depth 0 (the spawn returns {id, status:"running"} immediately; the report arrives automatically; if your next step needs it, end the turn and let the digest deliver it — do not poll; the explicit async:false is a
+mechanism parameter, not for model use). Inside subagents (depth>0) spawns are always synchronous. Async spawns are pooled per role domain — 4 concurrent eng-coders plus 4 concurrent other-role spawns by default (agent.poolLimits overrides both); a full domain queues further spawns with a position
+while the other keeps starting.
 
-Task scheduling: declare files (the file paths this task will modify) and dependsOn (ids from prior async returns whose outcome this task needs) to let the scheduler order your spawns. Overlapping-file tasks serialize and dependents start in order: a conflicting/dependent spawn queues (position/reason) and auto-starts when the conflict clears / the dependency settles (cancel to drop). A cancelled/failed dependency leaves it queued marked "dependency cancelled" until you decide (AUTO sessions auto-start). Unknown ids error; a consumed id counts as satisfied. Omit both for a plain immediate spawn (no scheduler involvement).
+Task scheduling: declare files (the file paths this task will modify) and dependsOn (ids from prior async returns whose outcome this task needs) to let the scheduler order your spawns. Overlapping-file tasks serialize and dependents start in order: a conflicting/dependent spawn queues
+(position/reason) and auto-starts when the conflict clears / the dependency settles (cancel to drop). A cancelled/failed dependency leaves it queued marked "dependency cancelled" until you decide (AUTO sessions auto-start). Unknown ids error; a consumed id counts as satisfied. Omit both for a plain
+immediate spawn (no scheduler involvement).
 
 Writing the prompt:
 - The child starts with zero context — brief it like a colleague who just walked in: goal, what you already know, the specifics.

package/tools/web-deepseek.mjs

@@ -9,8 +9,9 @@
  *
  * The tools never fail because of this backend: every export returns a pure value
  * (`{ status: "ok" | "empty" | "failed" | "unavailable" }`) and never throws.
- * 401/402/403/404 trip a per-agent breaker (WeakSet); 408/429/5xx retry once (500 ms);
- * everything else falls back to the caller's existing chain.
+ * 401/402/403 trip a per-agent breaker for `BREAKER_TTL_MS` (10 min — auto-unseals, no restart);
+ * 404 does NOT trip (the target page is missing — not a credential failure, D-WB3); 408/429/5xx
+ * retry once (500 ms); everything else falls back to the caller's existing chain.
  */
 import { URL } from "node:url"
 import { truncate, isPrivateHost } from "./shared.mjs"
@@ -27,7 +28,8 @@ const DEEPSEEK_HOST = "api.deepseek.com"
 const TIMEOUT_MS = 15_000
 const RETRY_DELAY_MS = 500 // D-WB5: fixed single backoff (no Retry-After parsing)
 const COST_PER_CALL = 0.00075 // $0.75 / 1000 successful requests — `count` does not change the price
-const TRIP_STATUS = new Set([401, 402, 403, 404])
+const TRIP_STATUS = new Set([401, 402, 403]) // 404 = 目标页面的状态，不是凭据失效（D-WB3）
+const BREAKER_TTL_MS = 600_000 // 熔断限时 10 分钟——到期自动放行（改完 key 无需重启会话）
 const RETRY_STATUS = (() => {
   const codes = new Set([408, 429])
   for (let code = 500; code <= 599; code++) codes.add(code)
@@ -35,11 +37,16 @@ const RETRY_STATUS = (() => {
 })()
 
 let _transport = proxyFetch
-let _breaker = new WeakSet()
+let _now = Date.now
+let _breaker = new WeakMap() // agent → expiresAtMs（单域——search ∥ fetch 共享，D-WB3）
 
-/** Test seam (CONFIG.md §6.2 ③ — paired): swap the transport; reset also clears the breaker. */
+/** Test seam (CONFIG.md §6.2 ③ — paired): swap the transport ∥ the clock; reset also clears the breaker. */
 export function _setDeepseekTransportForTest(fn) { _transport = typeof fn === "function" ? fn : proxyFetch }
-export function _resetDeepseekTransportForTest() { _transport = proxyFetch; _breaker = new WeakSet() }
+export function _setDeepseekClockForTest(fn) { _now = typeof fn === "function" ? fn : Date.now }
+export function _resetDeepseekTransportForTest() { _transport = proxyFetch; _now = Date.now; _breaker = new WeakMap() }
+
+/** 熔断名单只读面（用例断言 404 零命中——D-WB3）。 */
+export const _TRIP_STATUS_FOR_TEST = Object.freeze([...TRIP_STATUS])
 
 /** `local` skips the DeepSeek backend; anything else (missing ∥ misspelled ∥ non-string) = `auto` (fail-open). */
 export function backendMode(cfg, key) {
@@ -66,11 +73,19 @@ function deepseekChannel(cfg) {
   return null
 }
 
-const tripped = (agent) => agent !== null && typeof agent === "object" && _breaker.has(agent)
+/** 熔断未到期？到期 ⇒ 删条目并放行（判活读时钟——改完 key 不必重启会话）。 */
+function tripped(agent) {
+  if (agent === null || typeof agent !== "object") return false
+  const expiresAt = _breaker.get(agent)
+  if (typeof expiresAt !== "number") return false
+  if (expiresAt > _now()) return true
+  _breaker.delete(agent)
+  return false
+}
 
-/** Break the backend for this agent identity (single domain — search ∥ fetch share it, D-WB3). */
+/** Break the backend for this agent identity for `BREAKER_TTL_MS` (single domain — search ∥ fetch share it, D-WB3). */
 function trip(agent) {
-  if (agent !== null && typeof agent === "object") _breaker.add(agent)
+  if (agent !== null && typeof agent === "object") _breaker.set(agent, _now() + BREAKER_TTL_MS)
 }
 
 /** One POST. Returns `{ kind: "ok", data }` | `{ kind: "http", status }` | `{ kind: "net", timeout }` | `{ kind: "json" }`. */
@@ -95,7 +110,7 @@ async function postOnce(url, body, apiKey, proxyUri) {
   } finally { clearTimeout(timer) }
 }
 
-/** One logical call: retry once (408/429/5xx), trip on 401/402/403/404, otherwise fall back. */
+/** One logical call: retry once (408/429/5xx), trip on 401/402/403, otherwise fall back. */
 async function request(url, body, apiKey, proxyUri, tool, agent) {
   const started = Date.now()
   let r = await postOnce(url, body, apiKey, proxyUri)
@@ -107,7 +122,7 @@ async function request(url, body, apiKey, proxyUri, tool, agent) {
   if (r.kind === "http" && TRIP_STATUS.has(r.status) && agent !== null && typeof agent === "object") {
     trip(agent)
     // Tripping line only (transient fallbacks stay quiet — ⑤).
-    logEvent("web:deepseek", { tool, status: r.status, tripped: true, ms: Date.now() - started })
+    logEvent("web:deepseek", { tool, status: r.status, tripped: true, ttlMs: BREAKER_TTL_MS, ms: Date.now() - started })
   }
   const reason = r.kind === "http" ? `http ${r.status}`
     : r.kind === "net" ? (r.timeout ? "timeout" : "network")