@thincoder/core 0.10.1 → 0.10.3

package/prompts/persona-engineering.md

@@ -76,6 +76,7 @@ Batch record, dispatch task books, verification conclusions, review firing, requ
 - **Parent does not ghost-write**: you do NOT write the design doc — anything needing change goes **via a fix round** to eng-designer; three exception categories: ① your own write domain (batch record §1/§4/§6 · ledger · requirement docs) ② purely mechanical form corrections (line folding / pointer form / counts) ③ **small edits** (single-line / table-level · no new semantics · verifiable one by one).
   **All three must be marked** ("parent direct execution" + revertable). **Judgment lines**: you content-writing on a dispatched surface without a fix round ⇒ violation; mechanical form correction unmarked ⇒ violation.
 - **Close three states (no "promises")**: each round's close allows **only three states** — ① **Do** (the action **was fired THIS round**: tool call / edit landed — the report only describes **what happened this round**); ② **Wait** (real dependency: waiting for the user's nod / a subagent's return — **must state what you're waiting for**); ③ **Stop** (anomaly / pending judgment — **state the stop point**). **The fourth state "promise" is forbidden**: writing "right away / next stroke / immediately / I will / up next" + an action WITHOUT firing that action in the same round ⇒ **treated as "not done"** — that wording must not be used: either do it in the same round, or rewrite it as "Wait".
+- **Every claim carries its basis**: at close, each judgment / conclusion / reading must carry its basis — one of: a judgment source (what it stands on), a `file:line` coordinate, or an explicit `unverified`; a claim with none of the three must not be output as a conclusion; a basis present must be checkable, one absent must be marked — no format mandated, existing documents not retrofitted.
 - **Debts go on the list**: undispatched / unfinished items of your own ⇒ **immediately written into batch record §6 unresolved (or a ledger row)** — debts **must be visible**, never living only in report prose, a code comment, or an inline note waiting for the user to chase.
 - **Fix in place first**: one-off small-form items (wording / coordinates / indexes / cleanup) from reviews or sweeps get fixed on the spot — never booked. **Only real debts enter the pool** (needs its own round / conditional / needs design). Triage aged pool entries before disposals: landed ⇒ retro-close; premise gone / duplicate ⇒ withdraw.
 - **Drain first (auto mode)**: while subagents are in flight, **clear your own queue in parallel** (verification / closure / settlement / mechanical corrections) — "waiting" **only holds for real dependencies**; parking doable work on "waiting" ⇒ violation.
@@ -105,13 +106,14 @@ Batch record, dispatch task books, verification conclusions, review firing, requ
   No "pre-existing" cop-out: "it was already broken" is never a reason to skip a fix — you own the whole design/code, and when a defect appeared does not decide whether it should be fixed.
   Findings beyond the approved design's scope: surface them or propose a design update — never silently ignore.
   A 🔴 you neither fix nor surface blocks convergence.
-  `Deferred` fits 🟡/🔵 improvements or a 🔴 needing the user's decision first — never a way to silently drop a real defect; unresolved 🔴 must be surfaced to the user.
+  `Deferred` fits 🟡/🔵 improvements, a 🔴 needing the user's decision first, or a reasoned acknowledged-not-fixed 🔴 (the dispute window closes it from round 3 on; a zero-reason refusal is never accepted) — never a way to silently drop a real defect; unresolved 🔴 must be surfaced to the user.
 - **Fix round ⇄ user approval timing** (post-review): after review passes you adjudicate one by one (adjudication table) — fixes your adjudication demands (design-doc revisions / implementation repairs)
   **land via a fix round and pass your verification BEFORE you may request user approval**; while a fix round is in flight you must NOT request approval — in-flight status is reported only, and the report carries no approval request.
   **Fix-round boundary**: only fixes directly derived from review findings and your adjudication — **no smuggled new semantics/scope**; smuggling = new content,
   to be explicitly laid before the user for a separate decision, never default-approved along with the approval request.
   In the approval request, the adjudication table's `Dispatched` rows must have converged to `Fixed` one by one (with landing evidence: file:line or design-doc section).
 - Round decay: round 2 verifies the prior table + flags obvious new issues; round 3+ strictly verifies only the prior table (no new-issue hunting). No round cap — repeated mechanical failure (same criterion) ⇒ stop and report.
+Every non-fix must carry a reason (a technical rebuttal with evidence, or an explicit acknowledged-not-fixed record); the reviewer may push back on insufficient reasons through round 2, and from round 3 accepts reasoned non-fixes — a zero-reason refusal is never accepted and stays unresolved.
   When the advisor reports all clear (no 🔴 remaining), run `verify`.
 - Async: **advisor calls are async by default at the top level.** On approval the design token is issued to the session automatically and the digest echoes the designId for the eng-coder spawn.
 

package/provider/core.mjs

@@ -126,6 +126,8 @@ async function chatImpl(provider, { messages, tools, onToken, onReasoning, onWai
   // window/clamping logic below reads the overridden value where it matters.
   const spec = providerSpec(provider)
   messages = stripImagesForTextModel(messages, spec)
+  // #853 D-PR32：历史图片累计字节预算——发送前对消息副本累计驱逐（最老先弃；history 本体零触）。
+  messages = capHistoryImages(messages)
   // SESSION.md §6.9 T-S3: local-only message fields (ts/transient) never reach the wire.
   // Stripped BEFORE format dispatch — anthropic/responses transports pass whole message
   // objects through verbatim (only the OpenAI path ran escapeMessages). Copy-on-write:
@@ -330,7 +332,7 @@ export function buildContinuationMessages(messages, result, spec) {
 // Pre-send payload normalization lives in normalize.mjs (2026-08-31 extract,
 // TODO #2); re-exported so provider/index.mjs and tool-pairing.test.mjs keep
 // their import paths.
-import { stripImagesForTextModel, normalizeToolPairing } from "./normalize.mjs"
+import { stripImagesForTextModel, normalizeToolPairing, capHistoryImages } from "./normalize.mjs"
 export { stripImagesForTextModel, normalizeToolPairing }
 /** Merge tool calls from a retry/continuation into the accumulated result.
  *  2026-08-31 会诊 #7/#17：readSSE 输出的 tc 已 finalize（无 index 字段），
@@ -392,9 +394,9 @@ async function requestWithRetry(provider, body, signal, onWait) {
         _headerTimeoutMs: effectiveFetchTimeoutMs(provider),
         _bodyIdleMs: FETCH_BODY_IDLE_MS,
       }
-      response = provider.proxyUri
-        ? await proxyFetch(url, opts, provider.proxyUri)
-        : await fetch(url, opts)
+      // #878 D-PX8：请求调用点收口——恒走 `proxyFetch`（无 proxyUri 即直连分支，内部 abort 通道单点建设；
+      // 原 call-site 分叉删除）。
+      response = await proxyFetch(url, opts, provider.proxyUri)
     } catch (error) {
       // AGENT-LOOP-SUBAGENT.md §6.12 站点 #2（第 24 批）：fetch 拒否面补标来源（undici 拒否的 AbortError 现场无 reason）
       if (error.name === "AbortError") throw annotateAbort(error, signal, "provider", "request")
@@ -406,6 +408,10 @@ async function requestWithRetry(provider, body, signal, onWait) {
 
     const text = await response.text().catch(() => "")
     let message = `LLM API error ${response.status}: ${text}`
+    // #853 D-PR32：413 可操作化——长会话图片累积的高频形态，从裸 HTTP 码变为可执行指引。
+    if (response.status === 413) {
+      message += " — request body too large (HTTP 413): run /compact to compress the conversation history, or remove historical images."
+    }
     // 401 双平台提示 + 诊断回显（2026-08-31 会诊 #15）：
     // Kimi 双平台 key 不互通的提示保留；通用加 baseURL host + key 前 6 位掩码，
     // 帮用户快速分辨"配错平台还是配错账号"。

package/provider/google.mjs

@@ -8,6 +8,7 @@ import { proxyFetch } from "../proxy.mjs"
 import { requestWithRetry } from "./retry.mjs"
 import { effectiveFetchTimeoutMs } from "./core.mjs"
 import { abortError, timeoutError } from "../abort-provenance.mjs"
+import { terminateBody } from "../stream-destroy.mjs"
 
 /** OpenAI 语义 tool_choice → Gemini FunctionCallingConfig（2026-08-31 能力层）。 */
 function mapFunctionCallingConfig(choice) {
@@ -197,10 +198,14 @@ async function parseGeminiStream(response, { onToken, onReasoning, signal }) {
   // 2026-09-01 读侧 idle 超时（同 sse.mjs）：body 有数据流动即不超时；连续 120s 无新 chunk 判死
   const READ_IDLE_MS = 120_000
   let idleTimer = null
+  let idleError = null
   const armIdle = () => {
     if (idleTimer) clearTimeout(idleTimer)
     idleTimer = setTimeout(() => {
-      try { response.body?.destroy(timeoutError(`SSE idle timeout: no data for ${READ_IDLE_MS / 1000}s`, "provider", "google-sse-idle")) } catch { /* already gone */ }
+      // #878：断流单点分流——直连 fetch（web 流）走 `IDLE_ABORT` 内部 abort 通道；
+      // proxy 形回落 destroyBody（原契约）。相位串 = 本腿专属 google-sse-idle。
+      idleError = timeoutError(`SSE idle timeout: no data for ${READ_IDLE_MS / 1000}s`, "provider", "google-sse-idle")
+      try { terminateBody(response, idleError) } catch { /* already gone */ }
     }, READ_IDLE_MS)
     idleTimer.unref?.()
   }
@@ -238,6 +243,16 @@ async function parseGeminiStream(response, { onToken, onReasoning, signal }) {
       result.interruptMessage = signal.reason.message
       return result
     }
+    // #878：看门狗终结两径归一（idleFired）——无内容 ⇒ idle 超时错误；有内容 ⇒ partial
+    //（已流出内容保留，不整轮报废）。非 idle 错误照旧走下方 hasPartial 径（原语义零变）。
+    if (idleError) {
+      if (result.content || result.reasoning || result.toolCalls.length) {
+        result.partial = true
+        result.networkError = idleError.message ?? String(idleError)
+        return result
+      }
+      throw idleError
+    }
     if (hasPartial(e)) {
       result.partial = true
       result.networkError = e.message ?? String(e)
@@ -251,7 +266,8 @@ async function parseGeminiStream(response, { onToken, onReasoning, signal }) {
   return result
 }
 
-/** google.mjs 无 hasChoices 追踪——只有流中途死且已有内容才标 partial（同 sse.mjs 语义的简化版） */
+/** google.mjs 无 hasChoices 追踪——非 idle 网络错误按文案判 partial（同 sse.mjs 语义的简化版）；
+ *  idle 径两分（有内容 ⇒ partial ∥ 无内容 ⇒ 超时错误）归 catch（#878）。 */
 function hasPartial(e) {
   return /ECONNRESET|terminated|idle timeout|network/i.test(e?.message ?? "")
 }

package/provider/normalize.mjs

@@ -10,6 +10,63 @@
 
 const RASTER_IMAGE_URL = /^data:image\/(png|jpe?g|gif|webp);base64,/
 
+/** 历史图片累计字节预算（D-PR32——40MB 级请求体的保守下界，留两张大图余量；可调）。 */
+export const IMAGE_HISTORY_BYTES_BUDGET = 32 * 1024 * 1024
+
+/** 图片驱逐占位文本（D-PR32 逐字）。 */
+const IMAGE_BUDGET_PLACEHOLDER = "[image omitted — dropped to keep the request under the history image budget]"
+
+/** 单 part 的 base64 载荷长度（仅 data URL；非 data 引用不过请求体、零计账）。 */
+function imagePartBytes(p) {
+  if (p?.type !== "image_url") return 0
+  const url = p.image_url?.url
+  if (typeof url !== "string" || !url.startsWith("data:")) return 0
+  const comma = url.indexOf(",")
+  return comma >= 0 ? url.length - comma - 1 : 0
+}
+
+/**
+ * 历史图片累计字节预算（D-PR32）：全部 image part 的 base64 载荷和超 budgetBytes 时，
+ * 从**最老**图起替换为占位文本，直到剩余 ≤ 预算。纯函数 + 拷贝语义（未改动时返回原引用；
+ * 改动时仅重建涉及的消息对象）——发送前对消息副本用；注入面对 `history` 本体回写（同函数同预算）。
+ * @param {Array} messages
+ * @param {number} [budgetBytes]
+ */
+export function capHistoryImages(messages, budgetBytes = IMAGE_HISTORY_BYTES_BUDGET) {
+  if (!Array.isArray(messages)) return messages
+  const hits = []
+  let total = 0
+  for (let mi = 0; mi < messages.length; mi++) {
+    const parts = messages[mi]?.content
+    if (!Array.isArray(parts)) continue
+    for (let pi = 0; pi < parts.length; pi++) {
+      const bytes = imagePartBytes(parts[pi])
+      if (bytes <= 0) continue
+      total += bytes
+      hits.push({ mi, pi, bytes })
+    }
+  }
+  if (total <= budgetBytes || hits.length === 0) return messages
+  const drop = new Set()
+  let remaining = total
+  for (const hit of hits) {
+    if (remaining <= budgetBytes) break
+    drop.add(`${hit.mi}:${hit.pi}`)
+    remaining -= hit.bytes
+  }
+  return messages.map((m, mi) => {
+    const parts = m?.content
+    if (!Array.isArray(parts)) return m
+    let changed = false
+    const next = parts.map((p, pi) => {
+      if (!drop.has(`${mi}:${pi}`)) return p
+      changed = true
+      return { type: "text", text: IMAGE_BUDGET_PLACEHOLDER }
+    })
+    return changed ? { ...m, content: next } : m
+  })
+}
+
 export function stripImagesForTextModel(messages, spec) {
   let changed = false
   const out = messages.map((m) => {

package/provider/sse.mjs

@@ -3,6 +3,7 @@
  * Extracted from core.mjs. Parses Server-Sent Events for LLM chat responses.
  */
 import { abortError, timeoutError } from "../abort-provenance.mjs"
+import { terminateBody } from "../stream-destroy.mjs"
 
 /**
  * Normalize provider cache fields into DeepSeek-style prompt_cache_hit/miss_tokens.
@@ -20,29 +21,43 @@ export function normalizeUsageCache(u) {
   }
   return u
 }
+/** 帧形状分派用前缀补差（D-PR31）：全同 ⇒ ""（零再增）；已收为前缀 ⇒ 只补差量；
+ *  无前缀关系 ⇒ 整段按增量追加（不吞真实内容——无法判定时不丢文本）。 */
+function snapshotSuffix(accumulated, text) {
+  if (text === accumulated) return ""
+  if (text.startsWith(accumulated)) return text.slice(accumulated.length)
+  return text
+}
+
 /** Defensive tool-call merge (PROVIDER.md §10): skip null/malformed elements and count them;
- *  merge slots by index / id / name / tail, accumulate arguments. */
-function mergeToolCalls(result, delta) {
+ *  merge slots by index / id / name / tail, accumulate arguments.
+ *  `snapshot: true`（D-PR31——`choice.message` 完整快照帧）：已有 slot（index / id 命中）的
+ *  arguments **覆盖**（非 +=）——修快照帧二次拼接；新 slot 照常建、其余路径零变。 */
+function mergeToolCalls(result, delta, { snapshot = false } = {}) {
   for (const tc of delta.tool_calls ?? []) {
     if (!tc || typeof tc !== "object") { result.droppedToolCalls++; continue }
     let slot
+    let existed = false
     if (Number.isInteger(tc.index) && tc.index >= 0) {
+      existed = result.toolCalls[tc.index] != null
       slot = (result.toolCalls[tc.index] ??= { id: "", name: "", arguments: "" })
     } else if (tc.id) {
       slot = result.toolCalls.find((s) => s && s.id === tc.id)
+      existed = !!slot
       if (!slot) { slot = { id: tc.id, name: "", arguments: "" }; result.toolCalls.push(slot) }
     } else if (tc.function?.name) {
       slot = { id: "", name: "", arguments: "" }
       result.toolCalls.push(slot)
     } else {
       slot = result.toolCalls[result.toolCalls.length - 1]
+      existed = !!slot
       if (!slot) { result.droppedToolCalls++; continue }
     }
     if (tc.id && !slot.id) slot.id = tc.id
     if (tc.function?.name && !slot.name) slot.name = tc.function.name
     const arg = tc.function?.arguments
-    if (typeof arg === "string") slot.arguments += arg
-    else if (arg != null) slot.arguments += JSON.stringify(arg)
+    if (typeof arg === "string") slot.arguments = snapshot && existed ? arg : slot.arguments + arg
+    else if (arg != null) slot.arguments = snapshot && existed ? JSON.stringify(arg) : slot.arguments + JSON.stringify(arg)
   }
 }
 
@@ -135,19 +150,29 @@ export async function readSSE(response, { onToken, onReasoning, rules, signal, f
     hasChoices = true
     if (choice.finish_reason) result.finishReason = choice.finish_reason
 
-    const delta = choice.delta ?? choice.message ?? {}
+    // 帧形状分派（D-PR31）：`delta == null && message != null` = 完整快照帧（MiniMax v2 类端点）——
+    // content / reasoning 前缀补差、tool_calls 覆盖；`delta` 在场 = 纯增量语义照旧
+    //（真增量文本天然可重复——不做去重）。
+    const snapshot = choice.delta == null && choice.message != null
+    const delta = snapshot ? choice.message : (choice.delta ?? {})
     // reasoning 方言：DeepSeek/Kimi/GLM 用 reasoning_content，OpenAI o 系和部分
     // 路由器用 reasoning —— 两个都认（2026-08-31 会诊 #9）
     const rDelta = delta.reasoning_content ?? delta.reasoning
     if (rDelta) {
-      result.reasoning += rDelta
-      onReasoning?.(rDelta)
+      const add = snapshot ? snapshotSuffix(result.reasoning, rDelta) : rDelta
+      if (add) {
+        result.reasoning += add
+        onReasoning?.(add)
+      }
     }
     if (delta.content) {
-      result.content += delta.content
-      onToken?.(delta.content)
+      const add = snapshot ? snapshotSuffix(result.content, delta.content) : delta.content
+      if (add) {
+        result.content += add
+        onToken?.(add)
+      }
     }
-    mergeToolCalls(result, delta)
+    mergeToolCalls(result, delta, { snapshot })
   }
 
   const processLines = (lines) => {
@@ -172,10 +197,14 @@ export async function readSSE(response, { onToken, onReasoning, rules, signal, f
   // 直连 fetch 与 proxyFetch 统一走这里（proxy 的 _bodyIdleMs 语义与之等价，双保险）。
   const READ_IDLE_MS = 120_000
   let idleTimer = null
+  let idleError = null
   const armIdle = () => {
     if (idleTimer) clearTimeout(idleTimer)
     idleTimer = setTimeout(() => {
-      try { response.body?.destroy(timeoutError(`SSE idle timeout: no data for ${READ_IDLE_MS / 1000}s`, "provider", "sse-idle")) } catch { /* already gone */ }
+      // #878：断流单点分流——直连 fetch（web 流）走 `IDLE_ABORT` 内部 abort 通道，
+      // proxy 形回落 destroyBody（原契约）。
+      idleError = timeoutError(`SSE idle timeout: no data for ${READ_IDLE_MS / 1000}s`, "provider", "sse-idle")
+      try { terminateBody(response, idleError) } catch { /* already gone */ }
     }, READ_IDLE_MS)
     idleTimer.unref?.()
   }
@@ -224,20 +253,23 @@ export async function readSSE(response, { onToken, onReasoning, rules, signal, f
       if (idleTimer) clearTimeout(idleTimer)
       return result
     }
+    // #878：看门狗终结归类归一（abort 通道下底层错误形不定）——无内容 ⇒ idle 超时错误；
+    // 有部分内容 ⇒ partial + networkError（原径语义保持）。
+    const err = idleError ?? e
     // 2026-08-31 会诊 #2（流中断丢全部已收内容）：网络级失败（ECONNRESET / 半截 EOF /
     // proxy 断连）时若已解析出内容，把 partial 交回上层而不是整轮报废重试。
     // 标记 partial:true + networkError（上层可决定续写/重试/展示部分结果）。
     if (hasChoices && (result.content || result.toolCalls.length)) {
       finalizeToolCalls(result)
       result.partial = true
-      result.networkError = e.message ?? String(e)
+      result.networkError = err.message ?? String(err)
       const existing = result._warnings ??= []
       if (!existing.some((w) => w.name === "network-partial")) {
         existing.push({ name: "network-partial", message: `stream interrupted by network error after partial output: ${result.networkError}` })
       }
       return result
     }
-    throw e
+    throw err
   }
 
   if (idleTimer) clearTimeout(idleTimer)

package/proxy.mjs

@@ -7,6 +7,7 @@ import { connect as tlsConnect } from "node:tls";
 import { PassThrough } from "node:stream";
 import { URL } from "node:url";
 import { abortError, timeoutError } from "./abort-provenance.mjs";
+import { IDLE_ABORT, destroyBody } from "./stream-destroy.mjs";
 
 const FETCH_TIMEOUT = 15_000
 
@@ -91,12 +92,12 @@ export function streamHttpResponse(sock, urlStr, opts = {}, timeout = FETCH_TIME
     function fail(err) {
       cleanup()
       if (!settled) { settled = true; reject(err) }
-      else body.destroy(err)
+      else destroyBody(body, err)
     }
     /** body 阶段空闲看门狗：每次数据到达重置；无数据超时 → 断流（流式消费方抛错） */
     function armIdle() {
       clearTimeout(idleTimer)
-      if (bodyIdleMs > 0) idleTimer = setTimeout(() => body.destroy(timeoutError("Response body timeout (idle)", "provider", "proxy-body-idle")), bodyIdleMs)
+      if (bodyIdleMs > 0) idleTimer = setTimeout(() => destroyBody(body, timeoutError("Response body timeout (idle)", "provider", "proxy-body-idle")), bodyIdleMs)
     }
 
     sock.on("data", (d) => {
@@ -261,9 +262,18 @@ function tcpConnectProxy(proxyUri, signal, timeout) {
 /**
  * Generic fetch with proxy support.
  * No proxy → native fetch. Proxy + HTTPS → CONNECT tunnel. Proxy + HTTP → 经典代理转发（绝对 URI 请求行）。
+ * 直连分支 = 内部 abort 通道建设点（#878 D-PX8）：建 `AbortController` + signal 合成（`AbortSignal.any`，
+ * 无 user signal 时单独用）后经 `IDLE_ABORT` 挂 response——web `ReadableStream` 的读侧看门狗
+ * （`readSSE` ∥ `parseGeminiStream`）经 `terminateBody` 恢复有效；proxy 两分支不挂（自有 `_bodyIdleMs`）。
  */
 export async function proxyFetch(urlStr, opts, proxyUri) {
-  if (!proxyUri) return globalThis.fetch(urlStr, opts)
+  if (!proxyUri) {
+    const idleAbort = new AbortController()
+    const signal = opts?.signal ? AbortSignal.any([opts.signal, idleAbort.signal]) : idleAbort.signal
+    const response = await globalThis.fetch(urlStr, { ...opts, signal })
+    response[IDLE_ABORT] = idleAbort
+    return response
+  }
   const target = new URL(urlStr)
   if (target.protocol === "https:") return tunnelHttps(urlStr, opts, proxyUri)
   // http:// 目标：TCP 直连代理，请求行发绝对 URI（GET http://host/path HTTP/1.1）

package/session-lifecycle.mjs

@@ -19,6 +19,8 @@
 
 import { existsSync } from "node:fs"
 import { resolveCompactThreshold } from "./config.mjs"
+// 槽面判据单源（#841 KD-841-2：槽渠道 key 门 + 模型面序——PROVIDER.md §6.22）。
+import { resolveProviderPlan } from "./model-ref.mjs"
 import {
   slotPath, loadManifest, saveManifest, slotDigest, writeSessionFile, getSessionId,
   writeEndMarker, sessionEnd, ownerPid, ownerPids,
@@ -158,18 +160,25 @@ export function applySession(agent, data, opts = {}) {
   } else {
     unbindRecordStore(agent)
   }
-  // ── MODEL-MERGE-SESSION 恢复（F-4——两支）──
-  const slotProvider = data.activeProvider ? agent.providers?.find((pr) => pr.name === data.activeProvider) : null
-  if (slotProvider) {
-    // ① 槽 provider 存在 → 按槽值设（不看 config）：双字段恒非空——legacy 槽 activeModel
-    //    null/空串 = 无 override——回该渠道默认模型（`providers[].model` 单值——M3）。
-    //    F-2d（MODEL-400-FIX）：`||` 非 `??`——空串也兜（activeModel="" 的槽会让 `??` 不落链 →
-    //    空槽 model 恒有值，provider.model 键不缺失）
+  // ── MODEL-MERGE-SESSION 恢复（F-4——两支；#841：槽面判据单源 = 统一解析第 1 步）──
+  // 槽渠道（`activeProvider` 在册 ∧ 持 key）⇒ 槽值设；槽无 key ∥ 不在册 ⇒ 跳过（落 config 链——
+  // 不把不可运行渠道钉进运行态；**跳过不写槽**——原槽值保留（D-S3 / KD-841-2））。判定 + 模型面
+  // 同源 = `resolveProviderPlan`（PROVIDER.md §6.22——零第二判据）。
+  const slotPlan = resolveProviderPlan({
+    providers: agent.providers,
+    defaultModel: agent.config?.defaultModel,
+    slot: { provider: data.activeProvider ?? null, model: data.activeModel ?? null },
+  })
+  if (slotPlan.source === "slot") {
+    const slotProvider = agent.providers?.find((pr) => pr.name === slotPlan.channel)
+    // ① 槽 provider 存在 → 按槽值设（不看 config）：双字段恒非空。
+    //    模型面序（#841）：槽模型 → `defaultModel` 属本渠道 ⇒ 其模型段 → 渠道默认单值
+    //    （`providers[].model`）；三档皆无 ⇒ `null`（不落 model 键——下游沿既有「model 缺失」处置）。
+    //    F-2d（MODEL-400-FIX）径保留：空串 / 非串槽模型同样兜（#638 非串 = 未登记）——slotPlan.model
+    //    已按同归一出值（单源，无第二判据）。
     const prevName = agent.activeProvider
     const prevModel = agent.activeModel ?? null
-    // #638（adoption 边界归一）：非串 `data.activeModel`（外端脏载 / 手工档）= 未登记 ⇒ 回退渠道
-    // 模型——类型脏值不入两状态字段（镜下方阈值重算门 ∕ 档位块 ∕ VSC `panel-turn-stages.mjs:53` 同形门）。
-    const slotModel = (typeof data.activeModel === "string" && data.activeModel) ? data.activeModel : slotProvider.model
+    const slotModel = slotPlan.model
     const switched = prevName !== slotProvider.name || prevModel !== slotModel
     agent.activeProvider = slotProvider.name
     agent.activeModel = slotModel
@@ -200,8 +209,8 @@ export function applySession(agent, data, opts = {}) {
     }
     return switched
   }
-  // ② 槽 provider 没了 → D-S3 保留——静默保持现状（不报错不纠正——config 有效则静默用
-  //    config/defaultModel 运行时；两方都无效由调用侧复验 validateProvider 弹重选）
+  // ② 槽无 key ∥ 不在册 → D-S3 保留——静默保持现状（落 config 链：config 统一解析产物已是
+  //    `agent.provider`；不报错不纠正——两方都无效由调用侧复验 validateProvider 弹重选）
   return false
 }
 

package/session.mjs

@@ -106,8 +106,11 @@ function digestFromStore(fields, counters, mtimeMs) {
  *  Restore now always rebuilds from history (lazy, see startup.mjs).
  *  2026-08-31 会诊 F1：slot 粘性——首次认领后缓存 agent._slot，永不重跑 ensureActive
  *  （原实现每次保存重推，manifest active 被并发方翻动时会话静默迁移）。
- *  返回轮转的 .bak 路径或 null。 */
-export function saveSession(agent) {
+ *  返回轮转的 .bak 路径或 null。
+ *  **`opts.prefsSeedOnly`（加性 · 2026-10-04 解锁批 · R2——唯一传者 = 桌面两落盘点）**：回合关联落盘
+ *  **不携会话级三键**（`provider` / `model` / `effort`）——写前读槽：复合在场（`activeProvider` 非空串 ∧
+ *  `activeModel` 真值）⇒ 槽值赢 ∥ 缺 ⇒ 记忆值播种；`effort` 单键在场（值可 `null`）⇒ 槽值保留。 */
+export function saveSession(agent, opts = {}) {
   // _fullHistory is written at the source via pushReal — no flush needed here.
   // history        = FULL, never-compacted (human-readable; VS Code panel & CLI resume read this)
   // contextHistory = machine context (possibly compacted) so CLI resume keeps the token savings
@@ -168,6 +171,14 @@ export function saveSession(agent) {
   // 原值——`"off"` 记号原样写盘，不回填为具体档）；缺之 ⇒ 下一次回合保存把槽写面结果整对象抹除。
   // `undefined` = 本会话未携带（老槽无该键 / 未经 `applySession`）⇒ 键不落盘（禁回填）。
   if (agent._slotEffort !== undefined) fields.effort = agent._slotEffort
+  // R2（2026-10-04 解锁批 · 加性 `prefsSeedOnly`）：回合关联落盘**不携三键**——写前读槽（守卫后：轮转现场不参与判据），
+  // 复合在场（`activeProvider` 非空串 ∧ `activeModel` 真值）⇒ 槽值赢（防起跑快照覆写忙期新选定）∥ 缺 ⇒ 记忆值播种。
+  if (opts.prefsSeedOnly === true) {
+    const onDisk = loadSlotFile(agent.cwd, slot) ?? {}
+    const compositeOn = typeof onDisk.activeProvider === "string" && onDisk.activeProvider !== "" && Boolean(onDisk.activeModel)
+    if (compositeOn) Object.assign(fields, { activeProvider: onDisk.activeProvider, activeModel: onDisk.activeModel })
+    if (Object.hasOwn(onDisk, "effort")) fields.effort = onDisk.effort ?? null
+  }
   // 绑定态 → 流式投影（段原文拼接——VSC 兼容面逐字同形）；未绑定 → 既有全量物化写
   if (agent._recordStore) saveProjectedSlot(agent, p, fields, contextHistory)
   else writeSessionFile(p, { ...fields, history: legacyHistory(agent), contextHistory })

package/stream-destroy.mjs

@@ -0,0 +1,62 @@
+/**
+ * stream-destroy.mjs — response body 终止守卫（单一权威源——PROXY.md §2 ∥ §7 D-PX7）
+ *
+ * 无监听者瞬间的 `destroy(err)` 会 emit 未处理 'error' ⇒ uncaughtException ⇒ 整个进程被杀
+ * （2026-09-22/23 三份 crash-report 签名 = `Response body timeout (idle)`，栈 = proxy.mjs
+ * 看门狗；GitHub #16）。`destroyBody(body, err)` 在终止前先挂**永久** no-op `'error'`
+ * 监听者——pipe 内部监听者触发即自摘后的重发同样被兜住；消费面语义零变（在场 ∥ 迟到
+ * `for-await` 消费者仍收原错误；`stream.errored` 保留原错误对象）。
+ *
+ * 契约四则（PROXY.md §2）：
+ * ① body 空 ∥ 非 destroy 形态（web `ReadableStream`）∥ 已 `destroyed` ⇒ 显式返回（no-op）；
+ * ② 首次调用挂永久 no-op 'error' 监听者（一次性标记防重复挂）；
+ * ③ 再 `destroy(err)`——原错误对象直传；
+ * ④ 禁 `listenerCount('error') === 0` 预检（pipe 监听者使计数失真——触发即自摘后重发）。
+ *
+ * 内部 abort 通道（2026-10-04 · #878 D-PX8）：直连 fetch 的 body = web `ReadableStream`（无
+ * `destroy`——本档形态①的 no-op 面）。断流改经 `IDLE_ABORT` 符号挂载的 `AbortController`：
+ * `terminateBody(response, err)` 对挂通道者 `controller.abort(err)`（body 随之中止）；无通道回落
+ * `destroyBody`（原契约零变）。建设点 = `proxy.mjs` `proxyFetch` 直连分支单点。
+ *
+ * 零 import——proxy ∥ provider 消费点共用（无环）。
+ */
+
+/** 一次性标记（模块私有 Symbol——不占 body 公开面）。 */
+const GUARDED = Symbol("thincoder.destroyBody.guarded")
+
+/**
+ * 终止 body，且未处理 'error' 不逃逸到进程（契约四则见档头）。
+ * @param {import("node:stream").Stream} body — response body（PassThrough）；
+ *   web `ReadableStream`（无 destroy）⇒ 显式 no-op
+ * @param {Error} err — 原错误对象（直传 destroy）
+ */
+export function destroyBody(body, err) {
+  if (!body || typeof body.destroy !== "function" || body.destroyed) return
+  if (!body[GUARDED]) {
+    body[GUARDED] = true
+    body.on("error", () => {})
+  }
+  body.destroy(err)
+}
+
+/** 内部 abort 通道符号（#878 D-PX8——直连 fetch 响应的断流通道；module-private 语义面）。 */
+export const IDLE_ABORT = Symbol("thincoder.idleAbort")
+
+/**
+ * body 终止分流单点（#878）：
+ * - response 挂有 `IDLE_ABORT`（直连 fetch——web `ReadableStream`）⇒ `controller.abort(err)`
+ *   （读循环随之终结；原错误对象即 abort reason——undici 以该对象拒读）；
+ * - 否则回落 `destroyBody(response.body, err)`（proxy PassThrough ∥ 无通道 web 流——原契约零变）。
+ * response 缺位 / 无 body ⇒ no-op 不抛（幂等——二次调用对 AbortController 原生安全）。
+ * @param {Response|{body?: import("node:stream").Stream}} response
+ * @param {Error} err — 原错误对象（abort reason ∥ destroy 直传）
+ */
+export function terminateBody(response, err) {
+  if (!response) return
+  const controller = response[IDLE_ABORT]
+  if (controller) {
+    controller.abort(err)
+    return
+  }
+  destroyBody(response.body, err)
+}

package/tool-docs/verify.md

@@ -1 +1 @@
-Generic pre-completion verification gate — language/framework/project agnostic. verify does NOT run any test/verification command for you and does NOT require a test per change. You DECLARE your verification status via the verification argument ({ status: 'passed' | 'failed' | 'skipped', command?, summary? } — effects per parameter): the declaration is self-reported evidence — verify only mechanically gates on it ('passed' → allowed; 'failed' → blocked; 'skipped' → allowed but needs a reason). Whether/how to verify is described in natural language in the project's AGENTS.md and is decided + executed by you. The report also carries the changed files (git diff), an advisory node --check hint on changed .js/.mjs (not gating), the task list, and a self-review checklist. Call this BEFORE declaring a coding task complete — do not say 'done' until verify passes.
+Generic pre-completion verification gate — language/framework/project agnostic. verify does NOT run any test/verification command for you and does NOT require a test per change. You DECLARE your verification status via the verification argument ({ status: 'passed' | 'failed' | 'skipped', command?, summary?, basis? } — effects per parameter): the declaration is self-reported evidence — verify only mechanically gates on it ('passed' → allowed; 'failed' → blocked; 'skipped' → allowed but needs a reason). 'basis' (optional) is the 'what it stands on' dimension of the declaration — a judgment source, a read file:line coordinate, or an explicit 'unverified' (declaration-only: no format is enforced or machine-checked); a passed / skipped declaration with no basis gets one advisory hint line in the report — never blocking and never changing the gate — while the failed face gets no basis hint (already blocked). Whether/how to verify is described in natural language in the project's AGENTS.md and is decided + executed by you. The report also carries the changed files (git diff), an advisory node --check hint on changed .js/.mjs (not gating), the task list, and a self-review checklist. Call this BEFORE declaring a coding task complete — do not say 'done' until verify passes.

package/tools/edit-batch.mjs

@@ -23,7 +23,8 @@ import { assertEditArgsExclusive, assertEditsContainer, assertEditEntries, valid
 
 /**
  * Apply the `edits` array form: multi-file atomic replacement. Throws on any
- * failure (atomic — nothing written). Returns the per-entry result text (joined).
+ * failure (atomic — nothing written). Returns the per-entry result text (joined)
+ * + the constant batch summary line at the end (#796 — EDIT.md §5).
  */
 export async function applyEditBatch(args, ctx) {
   assertEditsContainer(args.edits)
@@ -105,7 +106,11 @@ export async function applyEditBatch(args, ctx) {
       note: p.note,
     }))
   }
-  return results.join("\n")
+  // #796（核面小修批——EDIT.md §5 批量回执汇总行 ∥ §8 D-9）：末行**恒为**汇总行——大回执
+  // （>64K）落盘后双端 preview 保尾（TOOL-OUTPUT-LIMITS.md §2）⇒ 汇总结论恒可见；N = 条目数
+  // （全判后原子写 ⇒ 成功恒 N/N）；路径 = 条目原样形、去重保序首现序（groups 插入序即首现序）。
+  const summary = `edit batch: ${args.edits.length}/${args.edits.length} entries — ${[...groups.values()].map((g) => g.path).join(", ")}`
+  return [...results, summary].join("\n")
 }
 
 // ---------------------------------------------------------------------------

package/undo-stack.mjs

@@ -6,13 +6,23 @@
  * 属核内面，函数本体零 TUI 依赖 ⇒ 按核内结构归位到核；`/undo` 命令面 `handleUndoCommand`
  * 留 CLI 壳——S2 由壳 import 本档）。
  *
+ * 双上界（#863 · TUI-COMMANDS.md §5.3）：单条备份超 `MAX_UNDO_BYTES` ⇒ **oversize 占位**条目
+ * （`oversize: true` · `backup: null`——列表可见 · 不可回退；与「文件创建」态靠 `oversize` 字段分判，
+ * 消费面 = `cmd-undo.mjs` 先判该字段再判 `backup === null`）；总量超 `MAX_UNDO_TOTAL_BYTES`
+ * ⇒ 逐最旧驱逐（条数上限 `MAX_UNDO` 保留）。
+ *
  * Tracks write/edit/delete/hashline_edit/apply_patch operations in agent._undoStack.
  */
 
-import { existsSync, readFileSync } from "node:fs"
+import { existsSync, readFileSync, statSync } from "node:fs"
 import { isAbsolute, join } from "node:path"
 
 const MAX_UNDO = 50
+const MAX_UNDO_BYTES = 10_000_000             // 10 MB — 单条备份上界（= tools/file.mjs 大档 read 守卫同值）
+const MAX_UNDO_TOTAL_BYTES = 64_000_000       // 64 MB — 备份总预算（超限逐最旧驱逐）
+
+/** 条目预算字节数（oversize 占位 ∥ 文件创建态（backup = null）不占预算）。 */
+const backupBytes = (e) => (typeof e?.backup === "string" ? Buffer.byteLength(e.backup, "utf8") : 0)
 
 /**
  * Snapshot a file before a side-effect tool modifies it.
@@ -26,22 +36,26 @@ export function snapshotForUndo(agent, toolName, args, cwd) {
   // 绝对路径直接用（path.join 对绝对段不重置——Windows 反斜杠路径也不按 "/" 切分）；相对路径整段 join(cwd)。
   const abs = isAbsolute(path) ? path : join(cwd, path)
   let backup = null
+  let oversize = false
   try {
     if (existsSync(abs)) {
-      backup = readFileSync(abs, "utf8")
+      if (statSync(abs).size > MAX_UNDO_BYTES) oversize = true // 大档不入内存——占位条目（与「文件创建」态分判）
+      else backup = readFileSync(abs, "utf8")
     }
   } catch {
     // can't read — maybe binary, skip
     return
   }
 
-  agent._undoStack.push({
-    tool: toolName,
-    path,
-    backup,
-    timestamp: Date.now(),
-  })
+  agent._undoStack.push(oversize
+    ? { tool: toolName, path, backup: null, oversize: true, timestamp: Date.now() }
+    : { tool: toolName, path, backup, timestamp: Date.now() })
   if (agent._undoStack.length > MAX_UNDO) agent._undoStack.shift()
+  // 总量上界：超限逐最旧驱逐（按字节预算计——条数上界保留）。
+  let total = agent._undoStack.reduce((n, e) => n + backupBytes(e), 0)
+  while (total > MAX_UNDO_TOTAL_BYTES && agent._undoStack.length > 0) {
+    total -= backupBytes(agent._undoStack.shift())
+  }
 }
 
-export { MAX_UNDO }
+export { MAX_UNDO, MAX_UNDO_BYTES, MAX_UNDO_TOTAL_BYTES }