thincoder 0.12.52 → 0.12.53

package/CHANGELOG.md

@@ -1,4 +1,23 @@
 ## [0.12.52] — 2026-08-31
+## [0.12.53] — 2026-08-31
+
+### Added
+
+- **TUI 展开块内滚动**（2026-08-31 用户需求）：折叠区块 60% 高度封顶保留，正文改为滚动视口——`state._foldScroll` 记每块窗口起点；**滚轮命中块内容行 → 块内 ±3 行**（未命中走会话滚动），▲/▼ 控制行点击翻窗（step=winH 快速跳转）；**穿出语义**：块顶滚上/块底滚下 → 交还会话滚动（会话顶懒加载可达）；锚定补偿：暂停流式跟随期间内容增长按 convLen 增量补偿 scroll（读的位置不漂移）。**滚动读全文、永不截断**
+- **流式跟随尾部**：`state._followTail` 默认 true——输出活动期间渲染前钉底；用户上滚（PgUp/滚轮）暂停跟随，PgDn/滚回底部/新提交消息恢复
+- **工具顺手度**（2026-08-31）：① insert_after 精确判定（本 session 写入记录受影响区，未受影响区直接插入不逼重 read、受影响区拒绝保护栏）；② edit 数组形态 `edits: [{path, old_string, new_string}, ...]` 一次多文件原子替换；③ dispatch 拦截工具执行期间 console.log/console.error 回显给模型（异常路径同样回显）；④ 写入工具返回带上下文窗口（edit/insert_after/hashline_edit 返回写入点 ±3 行带行号——模型自检行号语义，防"行号漂移死循环"）
+
+### Changed
+
+- **懒加载滚动到头自动加载**（2026-08-31 用户约定修复）：恢复会话向上滚动到会话顶部自动加载更早一页（原只挂 PgUp 键=违约）；`HISTORY_PAGE_MESSAGES` 50→20（单页更平顺，vscode parity）
+- **三层渲染缓存**（懒加载卡顿根治）：行级 wrapRowsCached + 段级 _lineSegCache（覆盖普通行/工具块/frozenSubTask/frozenAdvisor）——loadOlder 后 rebuild 111ms→5-8ms 平坦（不随已加载历史增长）
+- **折叠 key 身份化**（会诊三家共识）：`long-${i}`/`fold-${foldCounter++}`/`advisor-done-${i}` 位置键全部改 `_lineId` 派生（loadOlder unshift 后展开态/块内滚动 offset 不串位）
+- **视口数学单源** `convViewport`（渲染+鼠标命中共用）：短会话顶部补 pad 后命中整体偏移的存量 bug 修复（点击折叠头/滚轮落空或错行）
+
+### Fixed
+
+- **块内滚动穿出缺陷**：滚到块顶/块尾后滚轮永远命中该块、穿不出 → 会话顶/懒加载不可达（"经过展开块滚不到顶"）——显式边界判定穿出
+- **懒加载只挂 PgUp 键**（小键盘无 PgUp 用户等于无入口）——滚轮滚到会话顶同样触发
 
 ### Fixed
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thincoder",
-  "version": "0.12.52",
+  "version": "0.12.53",
   "description": "Thin coding agent - zero dependencies, no build step, Node.js native. Sharp code, zero bloat.",
   "keywords": [
     "ai",

package/src/advisor/run.mjs

@@ -7,6 +7,7 @@ import { findProvider, specForModel } from "../config.mjs"
 import { toOpenAISchema } from "../tools/index.mjs"
 import { prepareAdvisorMessages } from "../advisor.mjs"
 import { appendCitationReport } from "./citations.mjs"
+import { describeToolArgs } from "../tui/tool-args.mjs"
 
 const MAX_ADVISOR_TURNS = 100
 // Mechanical convergence cap: the protocol assumes up to 5 rounds suffice
@@ -97,16 +98,12 @@ function advisorToolsFor(agent) {
 // Test seam: the tool set is pure (agent.memory → code_search inclusion).
 export { advisorToolsFor as _advisorToolsFor }
 
-/** Compact one-line summary of tool args for panel progress lines.
- *  Picks the most identifying field; falls back to truncated JSON. */
-function summarizeToolArgs(args) {
-  // e.g. "read src/x.mjs", "grep foo src/", "ls docs" — action first when present
-  const parts = [args.action, args.path ?? args.pattern ?? args.command].filter((v) => v != null)
-  let s = parts.length > 0 ? parts.map(String).join(" ") : JSON.stringify(args)
-  s = s.replace(/\s+/g, " ").trim()
-  return s.length > 80 ? s.slice(0, 79) + "…" : s
-}
-
+/**
+ * Tool-call progress line summary delegates to the single source describeToolArgs
+ * (../tui/tool-args.mjs) — the same function main-agent tool blocks and subagent
+ * blocks use. 2026-08-31: replaced the local picker (action/path/pattern/command-only)
+ * so advisor progress lines show the quoted-path forms everywhere else.
+ */
 /**
  * Render the ordered review timeline — thinking / tool progress / final text
  * interleaved EXACTLY as emitted, so the persisted record shows the review
@@ -246,7 +243,8 @@ async function runAdvisorToolLoop(provider, messages, onOutput, signal, agent, c
         continue
       }
       
-      onTool(`\n→ ${tc.name} ${summarizeToolArgs(args)}\n`)
+      const argsLine = describeToolArgs(tc.name, args)
+      onTool(`\n→ ${tc.name}${argsLine ? " " + argsLine : ""}\n`)
       let result
       if (!tool) {
         result = `Error: unknown tool "${tc.name}". Available: ${[...toolByName.keys()].join(", ")}`

package/src/agent/dispatch.mjs

@@ -156,6 +156,13 @@ export async function executeToolCalls(agent, toolByName, toolCalls, callbacks,
             : "Error: no permission handler configured — this tool requires user approval but the current context doesn't support interaction (e.g. subagent or non-TUI mode)"
       return { ...item, result: reason, ok: false }
     }
+    // 2026-08-31 工具顺手度（用户批准"做吧"）：dispatch 拦截工具执行期间的
+    // console.log/console.error——工具的探查/调试输出（原本只到终端、模型看不到）
+    // 收集后附在工具结果后回显给模型。bash 工具的输出走子进程回显（onOutput），
+    // 不走 dispatch console——拦截安全。嵌套 dispatch（subagent）各自拦截/恢复，
+    // 捕获分离（父恢复原始后子的拦截期间父捕获停止、子恢复后父继续）——正确。
+    // 声明在 try 之外：catch 块（异常路径）也要访问（报错前的探查输出回显）。
+    const capturedConsole = []
     try {
       // Snapshot for undo before side-effect tools (setupOutputPanel already fired in Phase 1)
       if (!item.tool?.readonly && item.args) {
@@ -170,26 +177,40 @@ export async function executeToolCalls(agent, toolByName, toolCalls, callbacks,
           return { ...item, result: routed.result, ok: true }
         }
       }
-      const rawResult = await item.tool.execute(item.args, {
-        cwd: agent.cwd,
-        agent,
-        depth,
-        signal,
-        callbacks,
-        onOutput: (chunk) => callbacks.onToolOutput?.(item.toolCall.name, chunk, item.toolCall.id),
-        onQuestion: callbacks.onQuestion,
-        onPermissionRequest: callbacks.onPermissionRequest,
-      })
+      const origConsoleLog = console.log
+      const origConsoleErr = console.error
+      console.log = (...a) => capturedConsole.push(a.map(String).join(" "))
+      console.error = (...a) => capturedConsole.push("[err] " + a.map(String).join(" "))
+      let rawResult
+      try {
+        rawResult = await item.tool.execute(item.args, {
+          cwd: agent.cwd,
+          agent,
+          depth,
+          signal,
+          callbacks,
+          onOutput: (chunk) => callbacks.onToolOutput?.(item.toolCall.name, chunk, item.toolCall.id),
+          onQuestion: callbacks.onQuestion,
+          onPermissionRequest: callbacks.onPermissionRequest,
+        })
+      } finally {
+        console.log = origConsoleLog
+        console.error = origConsoleErr
+      }
       if (rawResult === undefined) throw new Error(`Tool "${item.toolCall.name}" returned undefined — all tools must return a string value`)
       const raw = String(rawResult)
       // Multimodal tools keep the raw result (base64 images ride the multimodal
     // channel); everything else offloads oversized text to disk. Flag-driven, not
     // name-driven (consult P3, 2026-08-30).
     const result = item.tool?.multimodal ? raw : await offloadToolResult(raw, item.toolCall.id)
-      callbacks.onToolResult?.(item.toolCall.name, result, item.toolCall.id)
+      // 2026-08-31：工具执行期间捕获的 console 输出附在结果后回显（模型视野）
+      const resultWithConsole = capturedConsole.length > 0
+        ? `${result}\n[console during ${item.toolCall.name}]\n${capturedConsole.join("\n")}`
+        : result
+      callbacks.onToolResult?.(item.toolCall.name, resultWithConsole, item.toolCall.id)
       // PostToolUse hooks: fire-and-forget (result not awaited on hook failure)
       runHooks("PostToolUse", { agent, toolName: item.toolCall.name, toolArgs: item.args, result: raw }).catch(() => {})
-      return { ...item, result, ok: true }
+      return { ...item, result: resultWithConsole, ok: true }
     } catch (error) {
       // Persist to ~/.thincoder/tool-errors/ for post-mortem; only pass message to the model (stack traces confuse LLMs and may leak paths)
       logToolError(item.toolCall.name, item.args, error)
@@ -205,7 +226,11 @@ export async function executeToolCalls(agent, toolByName, toolCalls, callbacks,
       if (item.args.pattern) ctxParts.push(`pattern=${item.args.pattern}`)
       if (item.args.command) ctxParts.push(`cmd=${item.args.command.slice(0, 80)}`)
       const ctx = ctxParts.length > 0 ? ` [${ctxParts.join(", ")}]` : ""
-      return { ...item, result: `Error: ${error.message}${ctx}`, ok: false }
+      // 2026-08-31：异常路径同样回显捕获的 console（工具报错前的探查输出最有价值）
+      const consolePart = capturedConsole.length > 0
+        ? `\n[console during ${item.toolCall.name}]\n${capturedConsole.join("\n")}`
+        : ""
+      return { ...item, result: `Error: ${error.message}${ctx}${consolePart}`, ok: false }
     }
   }
 

package/src/agent.mjs

@@ -10,6 +10,7 @@ import { join, dirname } from "node:path"
 import { fileURLToPath } from "node:url"
 import { executeToolCalls } from "./agent/dispatch.mjs"
 import { recordToolResults } from "./agent/record-results.mjs"
+import { FILE_MUTATORS } from "./agent/helpers.mjs"
 import { prepareRun } from "./agent/setup.mjs"
 import { injectPostTurn } from "./agent/post-turn.mjs"
 import { handleCompletion } from "./agent/completion.mjs"
@@ -256,6 +257,20 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
       throw e
     }
 
+    // 内置工具（Responses web_search）结果本地化：服务端已执行——入历史为 tool 消息，
+    // 模型下一轮可见；全量回传时 transport 依 tool_call_id 前缀还原 web_search_call item。
+    // 注意：服务端 item id 是 msg_xxx 非 web_search_call_ 前缀——必须合成前缀（toItems 识别锚点），
+    // 原始 id 存入 content（真机冒烟 2026-08-31：直接用 msg_xxx 会被转成 function_call_output
+    // 与服务端不配对，属蒙对）。
+    for (const btr of response.builtinToolResults ?? []) {
+      if (!btr?.id) continue
+      pushReal(agent, {
+        role: "tool",
+        tool_call_id: `web_search_call_${btr.id}`,
+        content: JSON.stringify({ id: btr.id, query: btr.query ?? "", sources: btr.sources ?? [], status: btr.status ?? "completed" }),
+      })
+    }
+
     // Stream rule triggered mid-generation (action: "abort"): halt current output,
     // inject rule's message as a reminder, and retry from the same context.
     if (response.ruleTriggered) {
@@ -357,6 +372,25 @@ export async function runAgent(agent, input, callbacks = {}, { depth = 0, signal
     // Ctrl+I interrupt during tool execution: skip committing partial results —
     // the tool failure messages would mislead the model. Inject the interrupt and retry.
     if (signal?.reason?.interrupt) {
+      // 中断变更记账（2026-08-31 评审 #4）：此分支的工具已全部执行完成（磁盘已变，execute 已完成），
+      // 真实结果按语义不进历史（placeholder 替代）——但变更必须记账：否则 guard 看到
+      // "本轮未改代码" 放行，评审/verify 门禁被绕过（文件改了却没评审）。
+      for (const { toolCall, ok } of results) {
+        const tool = toolByName.get(toolCall.name)
+        if (!ok || !tool || !FILE_MUTATORS.has(toolCall.name)) continue
+        agent._mutatedThisRun = true
+        agent._calledAdvisorThisRun = false
+        agent._verifiedThisRun = false
+        agent._verifyPassed = undefined
+        try {
+          const args = JSON.parse(toolCall.arguments)
+          const paths = tool.touchedPaths ? tool.touchedPaths(args) : [args.path]
+          for (const p of paths) {
+            const abs = join(agent.cwd, p)
+            if (!agent._touchedFiles.includes(abs)) agent._touchedFiles.push(abs)
+          }
+        } catch { /* 畸形 args 不影响记账（touchedFiles 尽力而为） */ }
+      }
       // The assistant tool_calls were already committed above (L347) — a strict
       // provider 400s on dangling tool_calls, so synthesize placeholder tool
       // results BEFORE the interrupt message (tool result must immediately

package/src/cli/make-agent.mjs

@@ -60,11 +60,17 @@ export async function assembleAgent() {
     if (existsSync(mcpJsonPath)) {
       const mcpJson = JSON.parse(readFileSync(mcpJsonPath, "utf8"))
       if (mcpJson.mcpServers && typeof mcpJson.mcpServers === "object") {
-        const configNames = new Set(mcpServers.map((s) => s.name))
-        for (const [name, server] of Object.entries(mcpJson.mcpServers)) {
-          if (configNames.has(name)) continue // config.json takes priority
-          if (!server || typeof server !== "object") continue
-          mcpServers.push({ name, ...server })
+        // 2026-08-31 MCP 会诊 #10：数组型 mcpServers 不是规范形态——Object.entries 会产出
+        // "0"/"1" 数字名（变成工具前缀 "0_tool"），必须跳过；server 条目嵌套数组同理。
+        if (Array.isArray(mcpJson.mcpServers)) {
+          console.error("[mcp] .mcp.json: mcpServers must be a plain object, got array — skipped")
+        } else {
+          const configNames = new Set(mcpServers.map((s) => s.name))
+          for (const [name, server] of Object.entries(mcpJson.mcpServers)) {
+            if (configNames.has(name)) continue // config.json takes priority
+            if (!server || typeof server !== "object" || Array.isArray(server)) continue
+            mcpServers.push({ name, ...server })
+          }
         }
       }
     }

package/src/mcp/helpers.mjs

@@ -27,13 +27,22 @@ export function quoteArg(s) {
   return /[\s"]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s
 }
 
-/** Append a Bearer token as a query parameter to a WebSocket URL */
+/** Convert an Authorization Bearer token into a WebSocket subprotocol.
+ *  2026-08-31 MCP 会诊 #10：原实现把 token 塞进 URL query——代理/网关日志会泄露凭证，
+ *  且无标准依据。Node 内置 WebSocket（undici）无法自定义请求头，MCP 生态的标准替代
+ *  通道是 subprotocol（`bearer.<token>`）。用户 URL 自带的 query token 不动（兼容）。
+ *  @returns {{ url: string, protocols: string[] }} — protocols 为空数组表示无认证。 */
 export function withAuthToken(wsUrl, authorization) {
-  if (!authorization) return wsUrl
+  if (!authorization) return { url: wsUrl, protocols: [] }
   const token = authorization.replace(/^Bearer\s+/i, "")
-  const u = new URL(wsUrl)
-  u.searchParams.set("token", token)
-  return u.href
+  let u
+  try {
+    u = new URL(wsUrl)
+  } catch {
+    throw new Error(`Invalid WebSocket URL: ${String(wsUrl).slice(0, 120)}`)
+  }
+  // subprotocol 不进入 URL/日志，token 不再注入 query
+  return { url: u.href, protocols: [`bearer.${token}`] }
 }
 
 /** Sanitize a tool name: replace non-alphanumeric chars with underscores, cap at 64 chars */

package/src/mcp/transport-http.mjs

@@ -12,6 +12,16 @@ export function httpTransport(baseURL, extraHeaders = {}) {
   let abortController = null
   let postUrl = url
   let legacySSE = false
+  let deadFired = false
+  let deadListeners = new Set()
+
+  /** 2026-08-31 MCP 会诊 P5：意外死亡通知（SSE 流断/error，非主动 close）。 */
+  const fireDead = (msg) => {
+    if (deadFired) return
+    deadFired = true
+    for (const cb of deadListeners) { try { cb(msg) } catch { /* listener error */ } }
+  }
+  const onDead = (cb) => { deadListeners.add(cb); return () => deadListeners.delete(cb) }
 
   const headers = () => {
     const h = { "Content-Type": "application/json", Accept: "text/event-stream, application/json", ...extraHeaders }
@@ -86,10 +96,14 @@ export function httpTransport(baseURL, extraHeaders = {}) {
             }
           } catch { /* not JSON, ignore */ }
         }
+        // 正常走完 = server 关闭了流（网络/对端退出）→ 非主动关闭视为死亡
+        if (!closed) fireDead("SSE stream ended")
       } catch (error) {
-        if (!closed) {
+        const wasClosed = closed
+        if (!wasClosed) {
           for (const [, resolve] of pending) resolve({ id: null, error: { code: -32000, message: `SSE error: ${error.message}` } })
           pending.clear()
+          fireDead(`SSE error: ${error.message}`)
         }
       }
     })()
@@ -106,14 +120,26 @@ export function httpTransport(baseURL, extraHeaders = {}) {
     const body = JSON.stringify({ jsonrpc: "2.0", id, method, params })
 
     if (legacySSE) {
+      // 2026-08-31 MCP 会诊 #10：legacy 模式下 POST 若直接带回 JSON-RPC body（违规 server，
+      // 规范是响应经 GET SSE 流回）——原实现对 resp.ok 什么都不做 → pending 挂满 120s。
+      // 空 body = 规范行为（等待 SSE 流）；非空 JSON = 违规 server，直接解析 resolve。
       return new Promise((resolve) => {
         pending.set(id, resolve)
         fetch(postUrl, { method: "POST", headers: headers(), body, signal: AbortSignal.timeout(CALL_TIMEOUT_MS) })
-          .then((resp) => {
+          .then(async (resp) => {
             if (!resp.ok) {
               pending.delete(id)
               resolve({ id, error: { code: -32000, message: `POST failed: HTTP ${resp.status}` } })
+              return
+            }
+            const raw = await resp.text().catch(() => "")
+            if (raw.trim()) {
+              try {
+                const msg = JSON.parse(raw)
+                if (msg.id === id) { pending.delete(id); resolve(msg); return }
+              } catch { /* ignore — pending 交给 SSE 流 */ }
             }
+            // 空体或非本次 id 的 JSON：保持 pending 等 GET SSE 流回包
           })
           .catch((e) => {
             pending.delete(id)
@@ -122,30 +148,56 @@ export function httpTransport(baseURL, extraHeaders = {}) {
       }).finally(() => pending.delete(id))
     }
 
-    const resp = await fetch(postUrl, {
-      method: "POST",
-      headers: headers(),
-      body,
-      signal: AbortSignal.timeout(CALL_TIMEOUT_MS),
-    })
-    if (!resp.ok) throw new Error(`HTTP ${resp.status}`)
-
-    const ct = resp.headers.get("content-type") ?? ""
-    const newSessionId = resp.headers.get("Mcp-Session-Id")
-    if (newSessionId) sessionId = newSessionId
-
-    if (ct.includes("text/event-stream")) {
-      const sse = parseSSE(resp)
-      for await (const { data } of sse) {
-        try {
-          const msg = JSON.parse(data)
-          if (msg.id === id) return msg
-        } catch { /* skip */ }
-      }
-      return { id, error: { code: -32000, message: "No JSON-RPC response in SSE stream" } }
-    }
-
-    return resp.json()
+    // 2026-08-31 MCP 会诊 P4：Streamable HTTP 规范路径（POST→202→GET SSE 回包）。
+    // 原实现非 legacy 分支从不注册 pending：202 空 body → resp.json() 抛 SyntaxError，
+    // 而 SSE 流里 pending.get(id) 永远 miss——每次调用挂满 120s。
+    // 现在两类通道统一：先注册 pending，POST 得到的结果（直接 body / SSE / 202 等待）
+    // 都经 pending resolve；SSE 流由 openSSE() 转发。200+JSON 直接 body 解析。
+    return new Promise((resolve) => {
+      pending.set(id, resolve)
+      fetch(postUrl, { method: "POST", headers: headers(), body, signal: AbortSignal.timeout(CALL_TIMEOUT_MS) })
+        .then(async (resp) => {
+          const ct = resp.headers.get("content-type") ?? ""
+          const newSessionId = resp.headers.get("Mcp-Session-Id")
+          if (newSessionId) sessionId = newSessionId
+          // 202: 已接受，响应将经 GET SSE 流回——pending 保持，由 openSSE 转发 resolve
+          if (resp.status === 202) return
+          if (!resp.ok) {
+            pending.delete(id)
+            resolve({ id, error: { code: -32000, message: `HTTP ${resp.status}` } })
+            return
+          }
+          if (ct.includes("text/event-stream")) {
+            // 响应体本身就是一条 SSE（一次性流）：解析匹配该 id
+            try {
+              for await (const { data } of parseSSE(resp)) {
+                try {
+                  const msg = JSON.parse(data)
+                  if (msg.id === id) { pending.delete(id); resolve(msg); return }
+                } catch { /* skip */ }
+              }
+              pending.delete(id)
+              resolve({ id, error: { code: -32000, message: "No JSON-RPC response in SSE stream" } })
+            } catch (e) {
+              pending.delete(id)
+              resolve({ id, error: { code: -32000, message: `SSE response failed: ${e.message}` } })
+            }
+            return
+          }
+          // 直接 JSON body：拿掉 pending 立即解析
+          pending.delete(id)
+          try {
+            resolve(await resp.json())
+          } catch (e) {
+            resolve({ id, error: { code: -32000, message: `invalid JSON body: ${e.message}` } })
+          }
+        })
+        .catch((e) => {
+          if (pending.delete(id)) {
+            resolve({ id, error: { code: -32000, message: `POST failed: ${e.message}` } })
+          }
+        })
+    }).finally(() => pending.delete(id))
   }
 
   const send = async (method, params) => withTimeout(postRequest(method, params), CALL_TIMEOUT_MS)
@@ -180,5 +232,5 @@ export function httpTransport(baseURL, extraHeaders = {}) {
     pending.clear()
   }
 
-  return { send, notify, close, openSSE, url, headers: extraHeaders }
+  return { send, notify, close, openSSE, url, headers: extraHeaders, isAlive: () => !closed && eventSource != null, onDead }
 }

package/src/mcp/transport-stdio.mjs

@@ -4,6 +4,23 @@
 import { spawn } from "node:child_process"
 import { rpcId, CALL_TIMEOUT_MS, withTimeout, quoteArg } from "./helpers.mjs"
 
+/** Kill the child AND its whole process tree.
+ *  win32: cmd.exe 包装 spawn 的孙进程（npx/node）必须 taskkill /T /F 才能杀净
+ *  （2026-08-31 MCP 会诊 P2：此前只 child.kill() 杀 cmd.exe 壳，真 server 成僵尸
+ *  并在 Windows 团队每人每次断开/重连泄漏一批）；
+ *  POSIX: SIGTERM 后 2s 未退 SIGKILL 兜底。 */
+function killTree(child) {
+  if (!child.pid) return
+  if (process.platform === "win32") {
+    try { spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true }) } catch { /* best effort */ }
+    return
+  }
+  try {
+    child.kill("SIGTERM")
+    setTimeout(() => { try { child.kill("SIGKILL") } catch { /* already gone */ } }, 2000).unref?.()
+  } catch { /* best effort */ }
+}
+
 /** Create an MCP stdio transport over a spawned child process.
  *  @param {Object} [env] — extra environment variables merged on top of process.env */
 export function stdioTransport(command, args, env) {
@@ -22,6 +39,17 @@ export function stdioTransport(command, args, env) {
   let stderrTail = ""
   let spawnError = null
   let closed = false
+  let deadFired = false
+  let deadListeners = new Set()
+
+  /** 2026-08-31 MCP 会诊 P5：意外死亡通知（进程自杀/崩溃，非主动 close）。
+   *  主动 close() 先置 closed → 后续 close 事件不触发。 */
+  const fireDead = (msg) => {
+    if (deadFired) return
+    deadFired = true
+    for (const cb of deadListeners) { try { cb(msg) } catch { /* listener error */ } }
+  }
+  const onDead = (cb) => { deadListeners.add(cb); return () => deadListeners.delete(cb) }
 
   const failAll = (message) => {
     for (const [, resolve] of pending) resolve({ id: null, error: { code: -32000, message } })
@@ -56,16 +84,31 @@ export function stdioTransport(command, args, env) {
     failAll(`spawn failed: ${error.message}`)
   })
   child.on("close", () => {
+    const wasClosed = closed // 主动 close() 先置 closed → 意外事件不重复
     closed = true
     const lastLine = stderrTail.trim().split("\n").pop()
     failAll(`Connection closed${lastLine ? ` | stderr: ${lastLine}` : ""}`)
+    if (!wasClosed) fireDead(`MCP server process exited${lastLine ? ` | stderr: ${lastLine}` : ""}`)
   })
 
-  const send = (method, params) => {
+  const send = (method, params, signal) => {
     if (spawnError) return Promise.resolve({ id: null, error: { code: -32000, message: `spawn failed: ${spawnError.message}` } })
     if (closed) return Promise.reject(new Error("MCP connection closed"))
     const id = rpcId()
-    const promise = new Promise((resolve) => pending.set(id, resolve))
+    let resolveFn
+    const promise = new Promise((resolve) => { resolveFn = resolve; pending.set(id, resolve) })
+    // 2026-08-31 MCP 会诊 P7：上层 signal 中断时即刻作废 pending（原实现等满
+    // CALL_TIMEOUT_MS 才清）并向 server 发 cancelled 通知。
+    const onAbort = () => {
+      pending.delete(id)
+      try { notify("notifications/cancelled", { requestId: id }) } catch { /* ignore */ }
+      resolveFn({ id, error: { code: -32000, message: "Request cancelled by user" } })
+    }
+    if (signal) {
+      if (signal.aborted) return Promise.reject((signal.reason instanceof Error) ? signal.reason : new DOMException("Aborted", "AbortError"))
+      signal.addEventListener("abort", onAbort, { once: true })
+      promise.finally(() => signal.removeEventListener("abort", onAbort)).catch?.(() => {})
+    }
     try {
       child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n")
     } catch (error) {
@@ -82,5 +125,16 @@ export function stdioTransport(command, args, env) {
     } catch { /* ignore */ }
   }
 
-  return { send, notify, close: () => { if (!closed) child.kill() } }
+  return {
+    send, notify,
+    close: () => {
+      // 2026-08-31 MCP 会诊 P2：close ≠ 只杀进程——先置 closed + failAll（在途请求
+      // 立即得到 "Connection closed" 而非挂满 120s），再杀整个进程树。
+      closed = true
+      failAll("Connection closed")
+      if (child.exitCode === null) killTree(child)
+    },
+    isAlive: () => !closed && !spawnError && child.exitCode === null,
+    onDead,
+  }
 }

package/src/mcp/transport-ws.mjs

@@ -8,6 +8,16 @@ export function wsTransport(wsUrl, extraHeaders = {}) {
   const pending = new Map()
   let closed = false
   let ws = null
+  let deadFired = false
+  let deadListeners = new Set()
+
+  /** 2026-08-31 MCP 会诊 P5：意外死亡通知（非主动 close 的连接断开）。 */
+  const fireDead = (msg) => {
+    if (deadFired) return
+    deadFired = true
+    for (const cb of deadListeners) { try { cb(msg) } catch { /* listener error */ } }
+  }
+  const onDead = (cb) => { deadListeners.add(cb); return () => deadListeners.delete(cb) }
 
   const failAll = (message) => {
     for (const [, resolve] of pending) resolve({ id: null, error: { code: -32000, message } })
@@ -16,15 +26,22 @@ export function wsTransport(wsUrl, extraHeaders = {}) {
 
   const connect = () => {
     if (closed) throw new Error("MCP WebSocket connection closed")
-    ws = new WebSocket(withAuthToken(wsUrl, extraHeaders.Authorization))
+    // 2026-08-31 MCP 会诊 #10：Authorization 经 subprotocol（bearer.<token>）传递，
+    // 不注入 URL query（防代理/网关日志泄露）；无认证时 protocols 为空数组。
+    const { url: wsUrlResolved, protocols } = withAuthToken(wsUrl, extraHeaders.Authorization)
+    ws = new WebSocket(wsUrlResolved, protocols.length ? protocols : undefined)
 
     return new Promise((resolve, reject) => {
+      let settled = false
+      const settleErr = (err) => { if (!settled) { settled = true; reject(err) } }
       const timeout = setTimeout(() => {
-        ws.close()
-        reject(new Error(`WebSocket connect timeout: ${wsUrl}`))
+        settleErr(new Error(`WebSocket connect timeout: ${wsUrl}`))
+        try { ws.close() } catch { /* ignore */ }
       }, INIT_TIMEOUT_MS)
 
       ws.addEventListener("open", () => {
+        if (settled) return
+        settled = true
         clearTimeout(timeout)
         resolve()
       })
@@ -41,28 +58,45 @@ export function wsTransport(wsUrl, extraHeaders = {}) {
       })
 
       ws.addEventListener("error", (event) => {
+        const wasClosed = closed
         clearTimeout(timeout)
         closed = true
-        const errMsg = event.message || "WebSocket error"
-        if (pending.size > 0) {
-          failAll(errMsg)
-        } else {
-          reject(new Error(errMsg))
-        }
+        const errMsg = event.message || event.error?.message || "WebSocket error"
+        settleErr(new Error(errMsg))
+        failAll(errMsg)
+        if (!wasClosed) fireDead(errMsg)
       })
 
       ws.addEventListener("close", () => {
+        const wasClosed = closed
         clearTimeout(timeout)
         closed = true
+        // 2026-08-31 MCP 会诊 P1：握手期间 disconnect（close 先于 open 且无 error）——
+        // 原实现 close 只 clearTimeout + failAll，connect promise 永不 settle（启动挂死）。
+        // settled 标志保证 close 未开成必 reject。
+        settleErr(new Error("WebSocket closed before connection established"))
         failAll("WebSocket closed")
+        if (!wasClosed) fireDead("WebSocket closed")
       })
     })
   }
 
-  const send = (method, params) => {
+  const send = (method, params, signal) => {
     if (closed) return Promise.reject(new Error("MCP WebSocket connection closed"))
     const id = rpcId()
-    const promise = new Promise((resolve) => pending.set(id, resolve))
+    let resolveFn
+    const promise = new Promise((resolve) => { resolveFn = resolve; pending.set(id, resolve) })
+    // 2026-08-31 MCP 会诊 P7：abort 即刻作废 pending + 发 cancelled（原等满 120s）
+    if (signal) {
+      if (signal.aborted) return Promise.reject(new DOMException("Aborted", "AbortError"))
+      const onAbort = () => {
+        pending.delete(id)
+        try { notify("notifications/cancelled", { requestId: id }) } catch { /* ignore */ }
+        resolveFn({ id, error: { code: -32000, message: "Request cancelled by user" } })
+      }
+      signal.addEventListener("abort", onAbort, { once: true })
+      promise.finally(() => signal.removeEventListener("abort", onAbort)).catch?.(() => {})
+    }
     try {
       ws.send(JSON.stringify({ jsonrpc: "2.0", id, method, params }))
     } catch (error) {
@@ -84,5 +118,5 @@ export function wsTransport(wsUrl, extraHeaders = {}) {
     try { ws?.close() } catch { /* ignore */ }
   }
 
-  return { send, notify, close, connect }
+  return { send, notify, close, connect, isAlive: () => !closed && ws?.readyState === WebSocket.OPEN, onDead }
 }