@thincoder/core 0.10.9 → 0.10.11

package/prompts/persona-explore.md

@@ -6,7 +6,7 @@ Your role is to search, read, and analyze. You do NOT have file editing tools.
 
 ## Reporting duty
 - If the expected pattern doesn't exist, report that explicitly: what you searched for, which tools you used, and that nothing matched.
-- Report findings in a structured format; the delivery table follows the unified format in the shared layer.
+- Report findings as a table: one row per item, a status column on every row (✅ done / ⚠️ simplified / ❌ not done), and no "deferred/later" column — pushing to later means "not done now".
 
 ## Thoroughness levels — pick the depth the task actually needs (the parent agent may state one in the task description):
 - quick — a single targeted search answering one specific question

package/prompts/persona-normal.md

@@ -8,34 +8,42 @@ You own the code — the entire project is your code.
 
 ## Role and collaboration stance
 Programming is collaborative labor between you and the human.
-The human decides direction and makes the final call. You own the code — the entire project is your code.
+The human decides direction and makes the final call.
 What you confirm is your contract.
 You are the lead engineer: you see the full picture, you coordinate complex work, and you are ultimately responsible for the result.
 When you delegate to subagents, hold them to the same bar: a subagent that takes shortcuts is your failure, not theirs.
 **Subagent ids carry their accounts in reports**: report subagent statuses as a table with a dedicated ledger column — form: `coder #3 | #938 · <topic> | <task detail> | <status>`; a bare serial number ⇒ violation (the user traces it without asking).
 
 ## Confirmation and approval gate (confirm before writing files)
-- **Before writing files, restate your understanding of the task + the plan points, and wait for explicit user confirmation ("OK / sure / continue" type) before executing.**
-**The restatement carries the checked-evidence line** — **a restatement without an evidence line is a guess, not a plan**.
+- **Before writing files**: restate your understanding of the task + the plan points, and wait for explicit user confirmation ("OK / sure / continue" type) before executing.
+  **Checked-evidence line**: the restatement carries it — a restatement without an evidence line is a guess, not a plan.
   No confirmation, silence, or the user replying with a new question/requirement means no approval — touching the file anyway lands work the user has not approved, however small or obvious.
-- **Stated requirements are a contract**: every requirement the user states (in conversation/docs/plans) binds the moment it is stated — shrinking at delivery means the user approved the design and received a discount. Discovering mid-way that an element is costly → implement it anyway and note the cost, or stop and lay out the trade-off BEFORE shrinking; disclosing only after delivery is the same discount, paid later.
+- **Stated requirements are a contract**: every requirement the user states (in conversation/docs/plans) binds the moment it is stated.
+  Why: shrinking at delivery means the user approved the design and received a discount.
+- **Discovering mid-way that an element is costly** → implement it anyway and note the cost, or stop and lay out the trade-off BEFORE shrinking.
+  Why: disclosing only after delivery is the same discount, paid later.
 - **The only exemption (doc/code consistency)**: updating a doc whose topic you already own, recording a decision the user just made, closing a doc-code gap the advisor pointed out — these complete the same already-confirmed task, so they are done in the same turn and spend no new confirmation.
-- **Re-confirm when the requirement changes.**
+- **When the requirement changes**: re-confirm.
 - Confirmations are delivered in your plain reply text: a routine confirm gate stays plain text — the `question` tool blocks, turning "shall I continue" into a hard stop.
 
 ## In-flight ask — non-blocking steer during long runs
-**During a long task (a long chain / subagents in flight) the ordinary reply text beats both bad choices**: blocking on the user stalls the run, and pushing through blind spends the decision without them — so raise the question there, state a **workable default**, and keep going.
+**Long task, live question**: during a long chain or with subagents in flight, the ordinary reply text beats both bad choices — blocking stalls the run, pushing through blind spends the decision without them — so raise the question there, state a **workable default**, and keep going.
 - **Trigger (both must hold)**: ① you are mid-run and stopping to wait clearly costs; ② the question has a **workable default** — carrying it forward means a silent user does not leave you stalled.
 - **One-sentence form**: "I'm continuing with <default> (basis: <basis>); if you'd rather have <alternative>, say so and I'll switch." **`<basis>` = the checked-evidence line ∥ "checked, nothing relevant"**.
 **Example**: "I'm continuing with plan A (basis: `<path>:<line>` — the ruling written there); if you'd rather have B, say so and I'll switch."
-- **A steer corrects you at once**: the user's reply reaches you as an ordinary user message (a message queued while you were busy takes effect once the current step lands) — apply it to the work that follows; interrupting a tool already in flight throws away its result and re-runs the work, and re-running finished parts pays for the same work twice.
+- **A steer corrects you at once**: the user's reply reaches you as an ordinary user message — apply it to the work that follows.
+  - A message queued while you were busy takes effect once the current step lands.
+  - **In-flight interruption**: the tool's result is thrown away and the work runs again.
+    Why: re-running finished parts pays for the same work twice.
 - **Defaults stay in bounds**: a default is drawn only from the scope already confirmed — anything past the confirm gate has no approval behind it, and an in-flight ask that widened scope would carry a decision nobody made.
 - **Channel boundary**: hard gate (new scope / a ruling on a criterion / no default can carry it) ⇒ the `question` tool (blocking) or stop and ask the user; soft steer ⇒ in-flight ask (non-blocking); routine confirm gates stay plain text.
   **All three routes follow one rule: check the docs first, and carry the checked-evidence line ∥ "checked, nothing relevant" when you ask** — asking without checking makes someone re-answer what is already written down; the user can check this on the spot.
 - **Discipline**: one question at a time (the `question` tool's ONE-question rule) · re-asking an authorized scope spends the user's attention · the default leads, because idling produces nothing.
 
 ## Main-agent role — only the top-level agent has these capabilities. Subagents do not.
-**The management face is yours**: normal mode has no designer role — requirements integration ∥ design text ∥ closeout documentation normalization are your own work (the same standard as the engineering-mode designer), then an independent review; the batch record ∥ ledger ∥ closeout are all yours to write.
+**The management face is yours**: normal mode has no designer role.
+**Requirements integration ∥ design text ∥ closeout documentation normalization** are your own work — the same standard as the engineering-mode designer; an independent review follows.
+**The batch record ∥ ledger ∥ closeout** are all yours to write.
 Plan before building — for complex multi-step tasks, enter plan mode first.
 Explore the codebase read-only, design the architecture, present the plan. When approved, exit plan mode and implement.
 For tasks that match the Coding discipline's "complex" tier, plan mode is your design step; for "medium" tasks it's optional but recommended.

package/provider/anthropic.mjs

@@ -7,7 +7,7 @@
 import { specForModel, requestBudget } from "../config.mjs"
 import { proxyFetch } from "../proxy.mjs"
 import { requestWithRetry } from "./retry.mjs"
-import { effectiveFetchTimeoutMs } from "./core.mjs"
+import { effectiveFetchTimeoutMs, effectiveBodyIdleMs } from "./core.mjs"
 import { abortError } from "../abort-provenance.mjs"
 
 const ANTHROPIC_VERSION = "2023-06-01"
@@ -32,6 +32,123 @@ export function normalizeTools(tools) {
   }))
 }
 
+// PROVIDER.md §6.27 常量：告警码唯一发射点 = R7 分支；占位文案由批内单测逐字锁定。
+const TOOL_ARGS_MALFORMED = "anthropic-tool-args-malformed"
+const CONTINUED_HISTORY_TEXT = "[conversation continued from the history below]"
+const EMPTY_TOOL_RESULT = "(no output)"
+const RAW_ARGS_EXCERPT = 80
+
+/** R6 ∥ R7：OpenAI 形 `arguments` → Anthropic `input`。
+ *  缺 ∥ 空串 ∥ null ⇒ `{}`（R6，无告警）；非法 JSON ∥ 解析结果非普通对象 ⇒ `{}` + 告警（R7）。
+ *  不抛：历史是持久的，抛错会让该会话此后每轮必死；真实结果仍在 tool_result 里（D-PR42）。 */
+function toolInputOf(raw, toolName, warnings) {
+  if (raw == null || raw === "") return {}
+  let parsed
+  try {
+    parsed = JSON.parse(raw)
+  } catch {
+    parsed = undefined
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    warnings.push({
+      name: TOOL_ARGS_MALFORMED,
+      message: `tool "${toolName}" arguments are not a JSON object — input sent as {} (raw: ${String(raw).slice(0, RAW_ARGS_EXCERPT)})`,
+    })
+    return {}
+  }
+  return parsed
+}
+
+/** R12：`image_url` part → Anthropic image 块（data URL ⇒ base64 source；其余 ⇒ url source）。 */
+function imageBlockOf(part) {
+  const url = part.image_url?.url || ""
+  const data = url.match(/^data:([^;,]+);base64,(.*)$/s)
+  if (data) return { type: "image", source: { type: "base64", media_type: data[1], data: data[2] } }
+  return { type: "image", source: { type: "url", url } }
+}
+
+/** R2–R5 ∥ R12 ∥ 表外默认：单个 OpenAI part → Anthropic 块。 */
+function blockOfPart(part) {
+  if (!part || typeof part !== "object") return null
+  if (part.type === "text") return { type: "text", text: part.text }
+  if (part.type === "image_url") return imageBlockOf(part)
+  // 表外默认：未列出的 part 类型原样直通（上游按类型拒收 = 显式失败），本层不静默丢弃
+  return { ...part }
+}
+
+/** R8：tool 消息的 `content` → tool_result 内容；空 ∥ 缺失 ⇒ 占位（`record-results.mjs:85` 原样推，无 stdout 的成功调用 = ""）。 */
+function toolResultText(content) {
+  if (typeof content === "string") return content === "" ? EMPTY_TOOL_RESULT : content
+  if (content == null) return EMPTY_TOOL_RESULT
+  return content // 表外（本仓只产出字符串）：原样透传，由上游显式判收
+}
+
+/** R8 ∥ R9 ∥ R10：user 消息内 `tool_result` 恒在其它块之前（官方约束，§6.27 R8）。 */
+function toolResultsFirst(blocks) {
+  if (!blocks.some((b) => b.type === "tool_result")) return blocks
+  return [...blocks.filter((b) => b.type === "tool_result"), ...blocks.filter((b) => b.type !== "tool_result")]
+}
+
+/**
+ * PROVIDER.md §6.27：OpenAI 形态会话历史 → Anthropic Messages API 形态（纯函数）。
+ * 返回 `{ messages, warnings }`（I5 ∥ I6）；入参零写——历史是四条通道共用的持久表示。
+ * system 已由 `chat()` 抽到顶层（R1），本函数只处理其余消息。
+ */
+export function convertMessages(messages) {
+  const out = []
+  const warnings = []
+  const push = (role, blocks) => {
+    if (blocks.length === 0) return // R13：空块消息丢弃（上游拒收空 content 数组——I3）
+    const ordered = role === "user" ? toolResultsFirst(blocks) : blocks
+    const last = out[out.length - 1]
+    if (last && last.role === role) {
+      // R10：转换后相邻同 role 合并，块按原序拼接（user 侧 tool_result 仍恒在前）
+      last.content = role === "user" ? toolResultsFirst([...last.content, ...ordered]) : [...last.content, ...ordered]
+      return
+    }
+    out.push({ role, content: ordered })
+  }
+
+  for (const m of messages) {
+    if (!m || typeof m !== "object") continue
+    if (m.role === "system") continue // R1：system 由 chat() 抽到顶层，永不进 messages
+    if (m.role === "tool") {
+      // R8 ∥ R9：tool 消息 ⇒ 含 tool_result 块的 user 消息（连续多条经 push 的合并自然并入同一条）
+      push("user", [{ type: "tool_result", tool_use_id: m.tool_call_id, content: toolResultText(m.content) }])
+      continue
+    }
+    const blocks = []
+    if (typeof m.content === "string") {
+      if (m.content !== "") blocks.push({ type: "text", text: m.content }) // R13：空串 ⇒ 零块
+    } else if (Array.isArray(m.content)) {
+      for (const part of m.content) {
+        const block = blockOfPart(part)
+        if (block) blocks.push(block)
+      }
+    }
+    if (m.role === "assistant") {
+      // R5：tool_calls 追加 tool_use 块；文本块在前、tool_use 块在后
+      for (const tc of m.tool_calls ?? []) {
+        if (!tc || typeof tc !== "object") continue
+        blocks.push({
+          type: "tool_use",
+          id: tc.id,
+          name: tc.function?.name,
+          input: toolInputOf(tc.function?.arguments, tc.function?.name, warnings),
+        })
+      }
+    }
+    // user ∥ 未列出的 role：按 user 收口（出口 role 只允许 user/assistant——I1）
+    push(m.role === "assistant" ? "assistant" : "user", blocks)
+  }
+
+  // R11：首条须 user（精简历史可 assistant 开头）；全空输入不造占位消息（I1）
+  if (out.length > 0 && out[0].role !== "user") {
+    out.unshift({ role: "user", content: [{ type: "text", text: CONTINUED_HISTORY_TEXT }] })
+  }
+  return { messages: out, warnings }
+}
+
 /** Build and send an Anthropic chat request. Returns the same shape as core.mjs chat.
  *  2026-08-31 会诊 #6：接入 rateGate/recordRate + 429 Retry-After 单次重试
  *  （原实现完全绕过 TPM/RPM 闸门与记账——用户配了 tpm 以为受控实际不受控）。
@@ -48,10 +165,13 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, on
     }
   }
 
+  // PROVIDER.md §6.27：OpenAI 形态历史 → Messages API 形态（system 抽离之后、请求体组装之前）
+  const { messages: adaptedMessages, warnings } = convertMessages(chatMessages)
+
   const spec = specForModel(provider.model)
   const body = {
     model: provider.model,
-    messages: chatMessages,
+    messages: adaptedMessages,
     stream: true,
     // §6.17 发送面同源：anthropic 恒发 max_tokens（显式 ?? 规格 maxOutput——原第三级兜底不可达已随本批删净，
     // §6.17「装配面不留第二算式」）
@@ -102,14 +222,17 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, on
       // 响应头阶段仍用 fetchTimeoutMs（600s 默认），body 阶段由 parseAnthropicStream 读侧 idle 管
       signal,
       _headerTimeoutMs: effectiveFetchTimeoutMs(provider),
-      _bodyIdleMs: 120_000,
+      _bodyIdleMs: effectiveBodyIdleMs(provider),
     }, provider.proxyUri),
     { signal, onWait, buildMessage: (status, text) => `Anthropic API error ${status}: ${text}` },
   )
 
   const result = await parseAnthropicStream(response, { onToken, onReasoning, signal })
   recordRate(provider, estimated, result.usage)
-  return finishAnthropic(result)
+  const finished = finishAnthropic(result)
+  // §6.27 告警投递：R7 的畸形参数告警并入既有 `_warnings` 机读线（消费面 agent/run-stages.mjs:44-45）
+  finished._warnings = [...(finished._warnings ?? []), ...warnings]
+  return finished
 }
 
 /** Anthropic `stop_reason` ⇒ 核统一 `finishReason`（§6.31.7 F-DA5——归一只喂既有分类；

package/provider/core.mjs

@@ -5,6 +5,7 @@
  */
 
 import { providerSpec, requestBudget, resolveEnableThinking } from "../config.mjs"
+import { DEFAULT_BODY_IDLE_MS } from "../config-defaults.mjs"
 import { resolveProviderSecrets } from "../env-ref.mjs"
 import { proxyFetch } from "../proxy.mjs"
 import { escapeMessages, stripLocalMessageFields } from "../escape.mjs"
@@ -63,8 +64,7 @@ export function createProvider(config) {
 
 /** Send a streaming chat completion request with automatic continuation on truncation */
 // 2026-09-01 根因修复：600s 绝对墙钟曾腰斩长上下文子代理（eng-coder TTFB>10min 即死）——TTFB 阶段改用
-// fetchTimeoutMs（默认 600s，agent.fetchTimeoutMs 可配），body 阶段 idle 超时（FETCH_BODY_IDLE_MS，无新数据才断）。
-const FETCH_BODY_IDLE_MS = 120_000
+// fetchTimeoutMs（默认 600s，agent.fetchTimeoutMs 可配），body 阶段 idle 超时（agent.bodyIdleTimeoutMs 可配，无新数据才断）。
 /** §6.14 设计值：prefix 续写只保留最近 8 条非工具文本（截断点语境足够，N 以测试锁定） */
 const PREFIX_CONTINUATION_KEEP = 8
 
@@ -73,6 +73,14 @@ export function effectiveFetchTimeoutMs(provider) {
   return Number.isFinite(provider?.fetchTimeoutMs) && provider.fetchTimeoutMs > 0 ? provider.fetchTimeoutMs : 600_000
 }
 
+/** body 阶段读侧空闲超时（TIMEOUT-DIGEST.md §2.1 —— 唯一解析点，各消费点同读本函数）：
+ *  键 `agent.bodyIdleTimeoutMs` 经 loadConfig 提升为 `provider.bodyIdleTimeoutMs`；
+ *  非法 ∥ 缺省 ⇒ 回退 DEFAULT_BODY_IDLE_MS（不抛错、不解释成「禁用」）。 */
+export function effectiveBodyIdleMs(provider) {
+  return Number.isFinite(provider?.bodyIdleTimeoutMs) && provider.bodyIdleTimeoutMs > 0
+    ? provider.bodyIdleTimeoutMs : DEFAULT_BODY_IDLE_MS
+}
+
 export async function chat(provider, opts = {}) {
   // LOGGING（docs/design/LOGGING.md）：llm:* 事件统一在此落点——所有 chat 调用
   // （主回合/消化轮/compress/distill/advisor/子代理/auto-think/consult）都经本函数，
@@ -143,6 +151,8 @@ async function chatImpl(provider, { messages, tools, onToken, onReasoning, onWai
   if (provider.format === "anthropic") {
     const { chat: anthropicChat } = await import("./anthropic.mjs")
     const { normalizeTools } = await import("./anthropic.mjs")
+    // §6.27：配对归一见转换前（缺回执的 tool_call 会变成孤儿 tool_use，上游同样拒收）——复用 OpenAI 径同一函数
+    messages = normalizeToolPairing(messages)
     const result = await anthropicChat(provider, {
       messages,
       tools: tools?.length ? normalizeTools(tools) : null,
@@ -243,7 +253,7 @@ async function chatImpl(provider, { messages, tools, onToken, onReasoning, onWai
   await rateGate(provider, estimated, onWait, signal)
 
   const response = await requestWithRetry(provider, body, signal, onWait)
-  const result = await readSSE(response, { onToken, onReasoning, rules, signal, firedPatterns })
+  const result = await readSSE(response, { onToken, onReasoning, rules, signal, firedPatterns, idleMs: effectiveBodyIdleMs(provider) })
   recordRate(provider, estimated, result.usage)
 
   // Stream rule triggered, user interrupted, or network partial — return immediately.
@@ -261,7 +271,7 @@ async function chatImpl(provider, { messages, tools, onToken, onReasoning, onWai
       await sleepInterruptible(3000, signal)
     }
     const retryResponse = await requestWithRetry(provider, body, signal, onWait)
-    const retryResult = await readSSE(retryResponse, { onToken, onReasoning })
+    const retryResult = await readSSE(retryResponse, { onToken, onReasoning, idleMs: effectiveBodyIdleMs(provider) })
     recordRate(provider, estimated, retryResult.usage)
     if (retryResult.finishReason !== "insufficient_system_resource") {
       // Merge any partial content from the failed attempt (streaming already showed it)
@@ -395,12 +405,12 @@ async function requestWithRetry(provider, body, signal, onWait) {
         body: JSON.stringify(body),
         // 2026-09-01 根因修复：原 600s 绝对墙钟会腰斩长上下文子代理（TTFB/首 token >10min 即死）。
         // 拆分语义：响应头阶段仍用 fetchTimeoutMs（600s，覆盖网关排队）；body 阶段由读侧 idle 超时管
-        // （sse.mjs readIdleMs——无新数据才断）。signal 只保留用户取消链，不再叠加绝对墙钟。
+        // （sse.mjs idleMs——effectiveBodyIdleMs 传入，无新数据才断）。signal 只保留用户取消链，不再叠加绝对墙钟。
         signal,
         // 2026-08-31 会诊 #4：代理路径响应头超时对齐直连语义（原 15s 与直连 600s 割裂，
         // DeepSeek 排队 TTFB>15s 即误报）— 仅 _ 前缀内部字段，proxyFetch 消费
         _headerTimeoutMs: effectiveFetchTimeoutMs(provider),
-        _bodyIdleMs: FETCH_BODY_IDLE_MS,
+        _bodyIdleMs: effectiveBodyIdleMs(provider),
       }
       // #878 D-PX8：请求调用点收口——恒走 `proxyFetch`（无 proxyUri 即直连分支，内部 abort 通道单点建设；
       // 原 call-site 分叉删除）。

package/provider/google.mjs

@@ -6,10 +6,11 @@
 
 import { proxyFetch } from "../proxy.mjs"
 import { requestWithRetry } from "./retry.mjs"
-import { effectiveFetchTimeoutMs } from "./core.mjs"
+import { effectiveFetchTimeoutMs, effectiveBodyIdleMs } from "./core.mjs"
 import { abortError, timeoutError } from "../abort-provenance.mjs"
 import { terminateBody } from "../stream-destroy.mjs"
 import { requestBudget } from "../config.mjs"
+import { DEFAULT_BODY_IDLE_MS } from "../config-defaults.mjs"
 
 /** OpenAI 语义 tool_choice → Gemini FunctionCallingConfig（2026-08-31 能力层）。 */
 function mapFunctionCallingConfig(choice) {
@@ -130,12 +131,12 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, on
       // 2026-09-01：同 core.mjs——绝对墙钟废除；响应头阶段 fetchTimeoutMs（600s 默认），body 阶段读侧 idle 管
       signal,
       _headerTimeoutMs: effectiveFetchTimeoutMs(provider),
-      _bodyIdleMs: 120_000,
+      _bodyIdleMs: effectiveBodyIdleMs(provider),
     }, provider.proxyUri),
     { signal, onWait, buildMessage: (status, text) => `Gemini API error ${status}: ${text}` },
   )
 
-  const result = await parseGeminiStream(response, { onToken, onReasoning, signal })
+  const result = await parseGeminiStream(response, { onToken, onReasoning, signal, idleMs: effectiveBodyIdleMs(provider) })
   recordRate(provider, estimated, result.usage)
 
   const usage = result.usage
@@ -168,7 +169,7 @@ function mapGeminiFinishReason(reason) {
  * Parse Gemini SSE stream.
  * Format: data: {...}\n\n (each line is a complete JSON object)
  */
-async function parseGeminiStream(response, { onToken, onReasoning, signal }) {
+async function parseGeminiStream(response, { onToken, onReasoning, signal, idleMs = DEFAULT_BODY_IDLE_MS }) {
   const result = { content: "", reasoning: "", toolCalls: [], usage: null, finishReason: null }
   const decoder = new TextDecoder()
   let buffer = ""
@@ -214,8 +215,7 @@ async function parseGeminiStream(response, { onToken, onReasoning, signal }) {
   }
 
   if (!response.body) throw new Error("No stream response body")
-  // 2026-09-01 读侧 idle 超时（同 sse.mjs）：body 有数据流动即不超时；连续 120s 无新 chunk 判死
-  const READ_IDLE_MS = 120_000
+  // 2026-09-01 读侧 idle 超时（同 sse.mjs）：body 有数据流动即不超时；连续 `idleMs` 无新 chunk 判死
   let idleTimer = null
   let idleError = null
   const armIdle = () => {
@@ -223,9 +223,9 @@ async function parseGeminiStream(response, { onToken, onReasoning, signal }) {
     idleTimer = setTimeout(() => {
       // #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")
+      idleError = timeoutError(`SSE idle timeout: no data for ${idleMs / 1000}s`, "provider", "google-sse-idle")
       try { terminateBody(response, idleError) } catch { /* already gone */ }
-    }, READ_IDLE_MS)
+    }, idleMs)
     idleTimer.unref?.()
   }
   armIdle()

package/provider/list-models.mjs

@@ -15,6 +15,7 @@
  */
 import { proxyFetch } from "../proxy.mjs"
 import { resolveProviderSecrets } from "../env-ref.mjs"
+import { positiveInt, recordListedContext } from "../model-context.mjs"
 
 const LIST_TIMEOUT_MS = 15_000
 /** 翻页上限（cursor loop 防死循环——任一分页失败即整体抛出，不部分返回）。 */
@@ -57,10 +58,37 @@ function collect(rows, pick) {
   return out
 }
 
+/** 列表窗口三字段名（取用序 = `context_window` > `context_length` > `max_model_len`）。
+ *  只从 openai 形态（`data[]`）取：anthropic / google 两分支不取（零实测——需求 §4.8 边界）。 */
+const LISTED_CONTEXT_FIELDS = ["context_window", "context_length", "max_model_len"]
+
+/** 三字段按序取第一个合法值（不是「取首字段」）：字段缺失 ∥ 值非法 ⇒ 跳下一个；
+ *  都不可得 ⇒ `null`（L3 缺席——R26 与字段缺席逐字同判）。 */
+function listedWindowOf(row) {
+  for (const field of LISTED_CONTEXT_FIELDS) {
+    const value = positiveInt(row?.[field])
+    if (value !== null) return value
+  }
+  return null
+}
+
 async function listOpenai(provider, signal) {
   const url = `${provider.baseURL}/models`
   const data = await fetchJson(provider, url, { ...(provider.headers ?? {}), Authorization: `Bearer ${provider.apiKey ?? ""}` }, signal)
-  return collect(data?.data, (m) => m?.id)
+  // L3 写面的收集段（PROVIDER.md §6.15）：解析 `data[]` 时顺带收 `id → 窗口`——三字段按序取
+  // 第一个**合法**值（R25 ∥ R26），非法相当于该字段缺席；三字段都不可得 = 该模型列表未报（不进表）。
+  const ids = []
+  // 形状门：载荷读得出来（data 是数组）才建表；非数组 = 读不出，返回 null 让调用侧不写缓存
+  // （「不报」与「读不出」分开——后者不清空上次成功值，同「拉取失败不清空」口径）。
+  const windows = Array.isArray(data?.data) ? new Map() : null
+  for (const m of Array.isArray(data?.data) ? data.data : []) {
+    const id = m?.id
+    if (typeof id !== "string" || !id) continue
+    ids.push(id)
+    const tokens = listedWindowOf(m)
+    if (tokens !== null) windows.set(id, tokens)
+  }
+  return { ids, windows }
 }
 
 async function listAnthropic(provider, signal) {
@@ -94,18 +122,22 @@ async function listGoogle(provider, signal) {
   return out
 }
 
-/** List available model IDs from the provider's /models endpoint (format 分派——M1)。 */
+/** List available model IDs from the provider's /models endpoint (format 分派——M1)。
+ *  返回形态仍是 `string[]`（六个消费面只吃 id——零改）；`openai` 分支在返回前把
+ *  `id → 自报窗口` 写进核缓存（L3 写面——零新增请求）。 */
 export async function listModels(provider, { signal } = {}) {
   // #57（provider-config-family 批）：清单拉取入口凭据值位解析（CONFIG.md §6.3）——三 format 分支共享。
   provider = resolveProviderSecrets(provider)
   const base = String(provider?.baseURL ?? "").replace(/\/+$/, "")
   if (!base) throw new Error("GET /models failed: baseURL is missing") // §2.5 #115 并入（VSC 明确报错）
   const format = provider?.format
-  const ids = format === "anthropic" ? await listAnthropic(provider, signal)
-    : format === "google" ? await listGoogle(provider, signal)
+  const collected = format === "anthropic" ? { ids: await listAnthropic(provider, signal) }
+    : format === "google" ? { ids: await listGoogle(provider, signal) }
       : await listOpenai(provider, signal)
+  // L3 写面：成功拉取后才写（失败照旧抛出、不清空上次成功值——上次自报比静态表更接近事实）。
+  if (collected.windows) recordListedContext(base, collected.windows)
   // §2.5 #115 并入（VSC 排序）：返回前本端排序——UI 确定性。
-  return ids.filter((id) => typeof id === "string" && id).sort()
+  return collected.ids.filter((id) => typeof id === "string" && id).sort()
 }
 
 /** 渠道准入失败消息（§2.5 #115 / VSC M8 并入——逐字长句 = 消息本体；状态标签由 UI 层组合）。

package/provider/normalize.mjs

@@ -4,8 +4,7 @@
  * Split from core.mjs (TODO #2: 420 lines, past the 300 advisory). These two
  * pure functions sanitize the message array right before it hits the wire;
  * no dependency on chat()/retry logic. core.mjs re-exports them so
- * provider/index.mjs and tool-pairing.test.mjs keep their import paths.
- * The caller passes the spec (providerSpec from core.mjs — provider-aware).
+ * provider/index.mjs keeps its import paths.
  */
 
 const RASTER_IMAGE_URL = /^data:image\/(png|jpe?g|gif|webp);base64,/
@@ -148,6 +147,7 @@ export function normalizeToolPairing(messages) {
     out.push(m)
     if (m.role !== "assistant" || !m.tool_calls?.length) continue
     for (const tc of m.tool_calls) {
+      if (!tc || typeof tc !== "object") continue // 空元素不携带 id：跳过，不让整个回合崩（#31）
       const t = toolById.get(tc.id)
       if (t) {
         toolById.delete(tc.id)

package/provider/responses.mjs

@@ -11,7 +11,7 @@
  * 事件流规范：流以 response.completed / response.incomplete / response.failed 结束，
  * 没有 "data: [DONE]"。
  */
-import { effectiveFetchTimeoutMs } from "./core.mjs"
+import { effectiveFetchTimeoutMs, effectiveBodyIdleMs } from "./core.mjs"
 import { proxyFetch } from "../proxy.mjs"
 import { requestWithRetry } from "./retry.mjs"
 import { rateGate, recordRate, estimateRequestTokens } from "./rate.mjs"
@@ -244,8 +244,8 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, on
         headers,
         body: JSON.stringify(body),
         signal,
-          _headerTimeoutMs: effectiveFetchTimeoutMs(provider),
-        _bodyIdleMs: 120_000,
+        _headerTimeoutMs: effectiveFetchTimeoutMs(provider),
+        _bodyIdleMs: effectiveBodyIdleMs(provider),
       }, provider.proxyUri),
       { signal, onWait, buildMessage: (status, text) => `Responses API error ${status}: ${text}` },
     )
@@ -263,8 +263,8 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, on
         headers,
         body: JSON.stringify(fullBody),
         signal,
-          _headerTimeoutMs: effectiveFetchTimeoutMs(provider),
-        _bodyIdleMs: 120_000,
+        _headerTimeoutMs: effectiveFetchTimeoutMs(provider),
+        _bodyIdleMs: effectiveBodyIdleMs(provider),
       }, provider.proxyUri),
       { signal, onWait, buildMessage: (status, text) => `Responses API error ${status}: ${text}` },
     )
@@ -281,8 +281,8 @@ export async function chat(provider, { messages, tools, onToken, onReasoning, on
         headers,
         body: JSON.stringify(fresh2.body),
         signal,
-          _headerTimeoutMs: effectiveFetchTimeoutMs(provider),
-        _bodyIdleMs: 120_000,
+        _headerTimeoutMs: effectiveFetchTimeoutMs(provider),
+        _bodyIdleMs: effectiveBodyIdleMs(provider),
       }, provider.proxyUri),
       { signal, onWait, buildMessage: (status, text) => `Responses API error ${status}: ${text}` },
     )

package/provider/sse.mjs

@@ -4,6 +4,7 @@
  */
 import { abortError, timeoutError } from "../abort-provenance.mjs"
 import { terminateBody } from "../stream-destroy.mjs"
+import { DEFAULT_BODY_IDLE_MS } from "../config-defaults.mjs"
 
 /**
  * Normalize provider cache fields into DeepSeek-style prompt_cache_hit/miss_tokens.
@@ -89,7 +90,7 @@ function finalizeToolCalls(result) {
   }
 }
 
-export async function readSSE(response, { onToken, onReasoning, rules, signal, firedPatterns: sharedFired }) {
+export async function readSSE(response, { onToken, onReasoning, rules, signal, firedPatterns: sharedFired, idleMs = DEFAULT_BODY_IDLE_MS }) {
   // Early intercept: non-SSE responses — either error bodies (HTTP >= 400) or
   // valid single-chunk JSON completions (some APIs return JSON despite stream:true).
   const contentType = response.headers.get("content-type") || ""
@@ -196,9 +197,9 @@ export async function readSSE(response, { onToken, onReasoning, rules, signal, f
   if (!response.body) throw new Error("No stream response body")
   // 2026-09-01 读侧 idle 超时（根因修复）：原实现靠 fetch 层的 600s 绝对墙钟兜底——长上下文子代理
   // 单次生成（或上游排队）超 10 分钟即被腰斩（"The operation was aborted due to timeout" 直透）。
-  // 现改为：读侧空闲超时——body 只要有数据流动就永不超时，连续 READ_IDLE_MS 无新 chunk 才判死。
+  // 现改为：读侧空闲超时——body 只要有数据流动就永不超时，连续 `idleMs` 无新 chunk 才判死
+  // （`idleMs` 由 provider/core.mjs 的 effectiveBodyIdleMs 算好传入，缺省 DEFAULT_BODY_IDLE_MS）。
   // 直连 fetch 与 proxyFetch 统一走这里（proxy 的 _bodyIdleMs 语义与之等价，双保险）。
-  const READ_IDLE_MS = 120_000
   let idleTimer = null
   let idleError = null
   const armIdle = () => {
@@ -206,9 +207,9 @@ export async function readSSE(response, { onToken, onReasoning, rules, signal, f
     idleTimer = setTimeout(() => {
       // #878：断流单点分流——直连 fetch（web 流）走 `IDLE_ABORT` 内部 abort 通道，
       // proxy 形回落 destroyBody（原契约）。
-      idleError = timeoutError(`SSE idle timeout: no data for ${READ_IDLE_MS / 1000}s`, "provider", "sse-idle")
+      idleError = timeoutError(`SSE idle timeout: no data for ${idleMs / 1000}s`, "provider", "sse-idle")
       try { terminateBody(response, idleError) } catch { /* already gone */ }
-    }, READ_IDLE_MS)
+    }, idleMs)
     idleTimer.unref?.()
   }
   armIdle()

package/proxy-transport.mjs

@@ -15,6 +15,7 @@ import { createBrotliDecompress, createGunzip, createInflate } from "node:zlib"
 import { abortError, timeoutError } from "./abort-provenance.mjs"
 import { createChunkedDecoder } from "./proxy-chunked.mjs"
 import { destroyBody } from "./stream-destroy.mjs"
+import { DEFAULT_BODY_IDLE_MS } from "./config-defaults.mjs"
 
 export const FETCH_TIMEOUT = 15_000
 
@@ -35,10 +36,11 @@ const CE_DECODERS = { gzip: createGunzip, "x-gzip": createGunzip, deflate: creat
  * absoluteForm: 请求行发绝对 URI（http:// 目标的经典代理转发用），默认发 origin-form。
  * 2026-08-31 会诊 #4：timeout 只覆盖"响应头阶段"；settle 后 body 空闲 > bodyIdleMs 即
  * 断流（原实现头部 timer 到齐即清，流式中途停摆会无限挂起直到用户 Ctrl+C）。
- * bodyIdleMs 默认 120s（provider 长生成用 0 即禁用，由调用方决定）。
+ * bodyIdleMs 缺省 = DEFAULT_BODY_IDLE_MS（与 `agent.bodyIdleTimeoutMs` 同源）；传 0 不是「禁用」——
+ * 定时器立即触发（本批不提供禁用开关）。
  * 导出供测试（裸 socket，无需 TLS/CONNECT）；生产路径走 tunnelHttps / proxyFetch。
  */
-export function streamHttpResponse(sock, urlStr, opts = {}, timeout = FETCH_TIMEOUT, absoluteForm = false, bodyIdleMs = 120_000) {
+export function streamHttpResponse(sock, urlStr, opts = {}, timeout = FETCH_TIMEOUT, absoluteForm = false, bodyIdleMs = DEFAULT_BODY_IDLE_MS) {
   return new Promise((resolve, reject) => {
     const target = new URL(urlStr)
     const method = opts.method ?? "GET"
@@ -229,7 +231,7 @@ export function tunnelHttps(urlStr, opts, proxyUri, timeout = FETCH_TIMEOUT) {
     }
     const signal = opts?.signal
     const headerTimeoutMs = Number.isFinite(opts?._headerTimeoutMs) ? opts._headerTimeoutMs : 60_000
-    const bodyIdleMs = opts?._bodyIdleMs ?? 120_000
+    const bodyIdleMs = opts?._bodyIdleMs ?? DEFAULT_BODY_IDLE_MS
 
     if (signal?.aborted) return reject(abortError(signal, "provider", "proxy"))
 

package/proxy.mjs

@@ -5,6 +5,7 @@
  */
 import { URL } from "node:url"
 import { normalizeProxy } from "./config.mjs"
+import { DEFAULT_BODY_IDLE_MS } from "./config-defaults.mjs"
 import { IDLE_ABORT } from "./stream-destroy.mjs"
 import { isLoopbackTarget, resolveProxyConfig, resolveWebProxy } from "./proxy-target.mjs"
 import { FETCH_TIMEOUT, streamHttpResponse, tcpConnectProxy, tunnelHttps } from "./proxy-transport.mjs"
@@ -48,6 +49,6 @@ export async function proxyFetch(urlStr, opts, proxyUri) {
   // http:// 目标：TCP 直连代理，请求行发绝对 URI（GET http://host/path HTTP/1.1）
   const sock = await tcpConnectProxy(proxyUri, opts?.signal, FETCH_TIMEOUT)
   const headerTimeoutMs = Number.isFinite(opts?._headerTimeoutMs) ? opts._headerTimeoutMs : FETCH_TIMEOUT
-  const bodyIdleMs = opts?._bodyIdleMs ?? 120_000
+  const bodyIdleMs = opts?._bodyIdleMs ?? DEFAULT_BODY_IDLE_MS
   return streamHttpResponse(sock, urlStr, opts, headerTimeoutMs, true, bodyIdleMs)
 }

package/session-guard.mjs

@@ -22,6 +22,7 @@ import { RECORD_DIR_SUFFIX } from "./session-store.mjs"
 // 本进程端名（创建端取值链缺省值）——静态环：本档 ↔ session-slots.mjs（经 session.mjs，同
 // 两档头注：函数体内运行时使用、求值期零顶层调用 ⇒ 环安全）。
 import { sessionEnd } from "./session-slots.mjs"
+import { logEvent } from "./log.mjs" // 槽事件（docs/core/design/SESSION-OBSERVABILITY.md §3.1）：guard 侧轮转同报 `via=guard`。
 
 /** 轮转时随迁记录存储（.bak 路径联动）——本会话活动绑定面跳过（防拔掉活动存储）。 */
 function moveSidecar(src, dst, agent) {
@@ -55,10 +56,12 @@ export function guardForeignSlotFile(agent, p, slot) {
     const myStart = agent._sessionStart ?? null
     const diskForeign = typeof disk?.cwd === "string" && disk.cwd.toLowerCase() !== agent.cwd.toLowerCase()
     if (diskIsNewer || diskForeign || (diskStart && diskStart !== myStart)) {
+      const reason = diskIsNewer ? "newer-version" : diskForeign ? "foreign-cwd" : "other-session"
       const bak = `${p}.bak-${Date.now()}`
       renameSync(p, bak)
       moveSidecar(p, bak, agent)
       console.error(`[session] slot ${slot} holds ${diskIsNewer ? `a newer-version file (v${disk.version})` : diskForeign ? `a foreign-cwd file (${disk.cwd})` : `another session (start ${diskStart}, ours ${myStart})`} — preserved as ${basename(bak)}`)
+      logEvent("slot:rotate", { slot, reason, bak: true, via: "guard" })
       agent._slotMtime = { p, mtimeMs: st.mtimeMs }
       agent._slotCreatedBy = sessionEnd() // 轮转：现场已让位 ⇒ 本端将首物化新文件
       return bak
@@ -70,9 +73,12 @@ export function guardForeignSlotFile(agent, p, slot) {
     // 文件存在但不可读（损坏/半写）：改名 .corrupted 保留现场（2026-09-01 advisor 🔵——
     // 与自身 loadSlotFile 的 .corrupted 约定 + VS Code saveSessionToSlot 对齐；.bak 保留
     // 给 F2 轮转路径，损坏现场不再混入轮转后缀）。
+    // 设计档 §3.1 / D13：catch 补 `preserved` 跟踪——否则 `unreadable` / `rotate-failed` 两值不可判。
+    let preserved = false
     if (existsSync(p)) {
-      try { renameSync(p, `${p}.corrupted`) } catch {}
+      try { renameSync(p, `${p}.corrupted`); preserved = true } catch {}
     }
+    logEvent("slot:rotate", { slot, reason: preserved ? "unreadable" : "rotate-failed", bak: false, via: "guard" })
     agent._slotCreatedBy = sessionEnd() // 损坏改名：现场已让位 ⇒ 本端将首物化新文件
     return null
   }