@thincoder/core 0.9.1

package/provider/sse.mjs

@@ -0,0 +1,264 @@
+/**
+ * provider/sse.mjs — SSE stream reader
+ * Extracted from core.mjs. Parses Server-Sent Events for LLM chat responses.
+ */
+import { abortError, timeoutError } from "../abort-provenance.mjs"
+
+/**
+ * Normalize provider cache fields into DeepSeek-style prompt_cache_hit/miss_tokens.
+ * DeepSeek already returns these; OpenAI/Kimi report the cache hit as
+ * prompt_tokens_details.cached_tokens; a few providers put cached_tokens at the
+ * usage top level. Miss is derived as prompt_tokens - hit when not reported.
+ */
+export function normalizeUsageCache(u) {
+  if (!u || u.prompt_cache_hit_tokens !== undefined) return u
+  const cached = u.prompt_tokens_details?.cached_tokens ?? u.cached_tokens
+  if (cached === undefined) return u
+  u.prompt_cache_hit_tokens = cached
+  if (u.prompt_cache_miss_tokens === undefined && typeof u.prompt_tokens === "number") {
+    u.prompt_cache_miss_tokens = Math.max(0, u.prompt_tokens - cached)
+  }
+  return u
+}
+/** 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) {
+  for (const tc of delta.tool_calls ?? []) {
+    if (!tc || typeof tc !== "object") { result.droppedToolCalls++; continue }
+    let slot
+    if (Number.isInteger(tc.index) && tc.index >= 0) {
+      slot = (result.toolCalls[tc.index] ??= { id: "", name: "", arguments: "" })
+    } else if (tc.id) {
+      slot = result.toolCalls.find((s) => s && s.id === tc.id)
+      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]
+      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)
+  }
+}
+
+/** Finalize tool calls (PROVIDER.md §10): drop nameless slots, synthesize missing ids,
+ *  count drops, and surface a machine-line warning via the existing `_warnings` channel. */
+function finalizeToolCalls(result) {
+  const entries = result.toolCalls.filter((tc) => tc) // drop sparse holes (rule-1 index jumps)
+  const kept = entries.filter((tc) => tc.name) // drop nameless slots
+  result.droppedToolCalls = (result.droppedToolCalls ?? 0) + (entries.length - kept.length)
+  result.toolCalls = kept
+  const used = new Set(kept.map((tc) => tc.id).filter(Boolean))
+  let seq = 0
+  for (const tc of kept) {
+    if (!tc.id) {
+      let id
+      do { id = `call_${seq++}` } while (used.has(id))
+      tc.id = id
+      used.add(id)
+    }
+  }
+  if (result.droppedToolCalls > 0) {
+    const existing = (result._warnings ??= [])
+    if (!existing.some((w) => w.name === "malformed-tool-calls")) {
+      existing.push({ name: "malformed-tool-calls", message: `${result.droppedToolCalls} malformed tool_calls dropped from provider response` })
+    }
+  }
+}
+
+export async function readSSE(response, { onToken, onReasoning, rules, signal, firedPatterns: sharedFired }) {
+  // 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") || ""
+  if (!contentType.includes("event-stream")) {
+    const body = await response.text().catch(() => "")
+    if (response.status >= 400) {
+      let errorMsg = ""
+      try {
+        const parsed = JSON.parse(body)
+        errorMsg = parsed?.error?.message
+          || parsed?.base_resp?.status_msg
+          || parsed?.detail
+          || parsed?.message
+          || parsed?.msg
+          || (typeof parsed.error === "string" ? parsed.error : "")
+      } catch { /* not JSON */ }
+      if (!errorMsg) errorMsg = body.slice(0, 500)
+      throw new Error(`API error: HTTP ${response.status} — ${errorMsg}`)
+    }
+    // HTTP < 400 non-SSE: might be a valid single-chunk JSON response (e.g. proxy
+    // stripped SSE framing). Parse `choice.message` (full chat.completion) OR
+    // `choice.delta` (chunk shape) — 2026-08-31: gateways downgrading stream:true
+    // to a complete completion used to return EMPTY content silently (message-only shape).
+    try {
+      const parsed = JSON.parse(body)
+      const choice = parsed.choices?.[0]
+      if (choice) {
+        const result = { content: "", reasoning: "", toolCalls: [], droppedToolCalls: 0, usage: normalizeUsageCache(parsed.usage ?? null), finishReason: null }
+        const delta = choice.delta ?? choice.message ?? {}
+        result.content = delta.content ?? ""
+        result.reasoning = delta.reasoning_content ?? delta.reasoning ?? ""
+        result.finishReason = choice.finish_reason ?? null
+        mergeToolCalls(result, delta)
+        if (result.content) onToken?.(result.content)
+        if (result.reasoning) onReasoning?.(result.reasoning)
+        finalizeToolCalls(result)
+        return result
+      }
+    } catch { /* not parseable JSON */ }
+    // Not an error response but not a valid chunk either — unexpected
+    throw new Error(`API error: HTTP ${response.status} — unexpected non-SSE response: ${body.slice(0, 200)}`)
+  }
+
+  const result = { content: "", reasoning: "", toolCalls: [], droppedToolCalls: 0, usage: null, finishReason: null }
+  const decoder = new TextDecoder()
+  let buffer = ""
+  let hasChoices = false
+  const firedPatterns = sharedFired ?? new Set()
+
+  /** Process one complete SSE event (data lines joined with \n per the SSE spec).
+   *  2026-08-31: rows are buffered per event (multi-line data: support that the
+   *  per-line JSON.parse used to crash on — single-line events behave identically). */
+  const handleEvent = (data) => {
+    if (!data || data === "[DONE]") return
+    let json
+    try { json = JSON.parse(data) } catch { return }
+
+    if (json.usage) result.usage = normalizeUsageCache(json.usage)
+    const choice = json.choices?.[0]
+    if (!choice) return
+    hasChoices = true
+    if (choice.finish_reason) result.finishReason = choice.finish_reason
+
+    const delta = choice.delta ?? choice.message ?? {}
+    // 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)
+    }
+    if (delta.content) {
+      result.content += delta.content
+      onToken?.(delta.content)
+    }
+    mergeToolCalls(result, delta)
+  }
+
+  const processLines = (lines) => {
+    let currentData = ""
+    for (const line of lines) {
+      if (line.startsWith("data:")) {
+        const v = line.slice(5).trim()
+        if (v === "[DONE]") { currentData = ""; continue }
+        // multi-line data: joins with \n (SSE spec); single-line is the common case
+        currentData = currentData ? currentData + "\n" + v : v
+        continue
+      }
+      if (line === "" && currentData) { handleEvent(currentData); currentData = "" }
+    }
+    if (currentData) handleEvent(currentData)
+  }
+
+  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 才判死。
+  // 直连 fetch 与 proxyFetch 统一走这里（proxy 的 _bodyIdleMs 语义与之等价，双保险）。
+  const READ_IDLE_MS = 120_000
+  let idleTimer = 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 */ }
+    }, READ_IDLE_MS)
+    idleTimer.unref?.()
+  }
+  armIdle()
+  try {
+    for await (const chunk of response.body) {
+      armIdle()
+      if (signal?.aborted) {
+        throw abortError(signal, "provider", "stream-read")
+      }
+      buffer += decoder.decode(chunk, { stream: true })
+      // UTF-8 BOM 剥除（2026-08-31 会诊 #12）：某些网关/负载均衡在流首注入 \uFEFF，
+      // 首行 "data:" 前缀匹配失败会被静默丢弃（首个事件整体消失）。
+      if (buffer.charCodeAt(0) === 0xfeff) buffer = buffer.slice(1)
+      const lines = buffer.split("\n")
+      buffer = lines.pop()
+      processLines(lines)
+
+      if (rules?.length && result.content && !result.toolCalls.length) {
+        for (const rule of rules) {
+          if (rule.repeat === "once" && firedPatterns.has(rule.pattern)) continue
+          if (rule._regex.test(result.content)) {
+            if (rule.repeat === "once") firedPatterns.add(rule.pattern)
+            if (rule.action === "abort") {
+              result.ruleTriggered = true
+              result.ruleMessage = rule.message
+              result.ruleName = rule.name
+              if (idleTimer) clearTimeout(idleTimer)
+              return result
+            }
+            const existing = result._warnings ??= []
+            if (!existing.some(w => w.pattern === rule.pattern)) {
+              existing.push({ name: rule.name, pattern: rule.pattern, message: rule.message })
+            }
+          }
+        }
+      }
+    }
+    buffer += decoder.decode()
+    processLines(buffer.split("\n"))
+  } catch (e) {
+    if (idleTimer) clearTimeout(idleTimer)
+    if (e.name === "AbortError" && signal?.reason?.interrupt) {
+      result.interrupted = true
+      result.interruptMessage = signal.reason.message
+      if (idleTimer) clearTimeout(idleTimer)
+      return result
+    }
+    // 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)
+      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
+  }
+
+  if (idleTimer) clearTimeout(idleTimer)
+
+  if (!hasChoices) {
+    // Stream started as SSE but no choices were parsed — unusual. Include status for debugging.
+    const raw = buffer.trim()
+    let errorMsg = ""
+    try {
+      const parsed = raw ? JSON.parse(raw) : null
+      errorMsg = parsed?.error?.message
+        || parsed?.base_resp?.status_msg
+        || parsed?.detail
+        || parsed?.message
+        || parsed?.msg
+        || (typeof parsed.error === "string" ? parsed.error : "")
+    } catch { /* not JSON */ }
+    if (!errorMsg) errorMsg = `SSE stream contained no choices (HTTP ${response.status})`
+    throw new Error(`API error: ${errorMsg}`)
+  }
+
+  finalizeToolCalls(result)
+  return result
+}

package/provider/wait-status.mjs

@@ -0,0 +1,59 @@
+/**
+ * wait-status.mjs — `onWait` 相位 → 状态文案（核内单源映射 · 批 1 CORE-DEFECT-FIXES B3）。
+ *
+ * 背景（`docs/core/design/PROVIDER.md` §6.20）：`onWait` 载荷的相位值域只在**发射侧**
+ * 收敛（五相：`gate` / `retry` / `overloaded` 带 `seconds` · `warn` / `quota` 带
+ * `message`），三个消费点（CLI TUI 状态行 / headless stderr / ACP 日志）各自枚举相位 ⇒
+ * 未列相位落 `else` 兜底，读 `seconds` 渲染出字面 `undefined`
+ * （`Rate-limited 429, retry in undefineds`），`warn` / `quota` 还被误标 429。
+ *
+ * 本档 = 相位值域 + 文案的**单源**：消费面只调 `waitStatusText(ev)`，禁各自相位枚举 /
+ * 兜底分支（结构机检 = `thincoder-cli/test/wait-status-callsites.test.mjs`）。
+ *
+ * 判据（PROVIDER.md §6.20 映射表·逐相）：
+ *   gate       带 seconds → `status.rateWait`    显示
+ *   retry      带 seconds → `status.rateLimited` 显示
+ *   overloaded 带 seconds → `status.overloaded`  显示（不得落 429 文案）
+ *   quota      带 message → `status.quota`       显示（剥发射回显前缀——防双前缀）
+ *   warn       前置告警   → `null`（不显示——与 VSC 面 `statusTextPayload` 同判据）
+ *   未知相位 / 秒缺失 / 无可渲染载荷 → `null`（不虚构数值、不落兜底误标）
+ */
+import { t } from "../i18n.mjs"
+
+/** 发射面回显前缀（`provider/retry.mjs:60` 的 `quota exhausted: `）——由 i18n 模板去占位符
+ *  派生（核内零第二套文案字面）；发射侧恒为 en 字面，故剥前缀不随 locale 变。 */
+const QUOTA_ECHO_PREFIX = t("status.quota", { msg: "" })
+
+/** 秒值有效性：有限数才可渲染（缺字段 / null / 非数 ⇒ 不虚构数值）。 */
+function hasSeconds(ev) {
+  return typeof ev?.seconds === "number" && Number.isFinite(ev.seconds)
+}
+
+/**
+ * 相位 → `{ kind, seconds | message }`（纯映射）；`null` = 不显示。
+ * `kind` 词表与 VSC 面 `statusTextPayload` 的 kind 同名（两端同一词表）。
+ */
+export function waitStatusOf(ev) {
+  const phase = ev?.phase
+  if (phase === "quota") {
+    const raw = typeof ev?.message === "string" ? ev.message : ""
+    if (!raw.trim()) return null // 无可渲染载荷 ⇒ 不显示（不渲染空/undefined）
+    const stripped = raw.startsWith(QUOTA_ECHO_PREFIX) ? raw.slice(QUOTA_ECHO_PREFIX.length) : raw
+    return { kind: "quota", message: stripped }
+  }
+  if (phase === "gate" || phase === "retry" || phase === "overloaded") {
+    if (!hasSeconds(ev)) return null
+    const kind = phase === "gate" ? "rateWait" : phase === "retry" ? "rateLimited" : "overloaded"
+    return { kind, seconds: ev.seconds }
+  }
+  return null // warn（前置告警）/ 未知相位 ⇒ 不显示
+}
+
+/** 相位 → 文案（文案取自核 i18n `status.*` 单源）；`null` = 消费点不显示、不打印。 */
+export function waitStatusText(ev, locale = "en") {
+  const m = waitStatusOf(ev)
+  if (!m) return null
+  return m.kind === "quota"
+    ? t("status.quota", { msg: m.message }, locale)
+    : t("status." + m.kind, { s: m.seconds }, locale)
+}

package/proxy.mjs

@@ -0,0 +1,274 @@
+/**
+ * proxy.mjs — Shared proxy tunnel for websearch, fetch, and provider calls.
+ * Zero dependencies: Node built-ins only (net, tls, http, url).
+ */
+import { connect } from "node:net";
+import { connect as tlsConnect } from "node:tls";
+import { PassThrough } from "node:stream";
+import { URL } from "node:url";
+import { abortError, timeoutError } from "./abort-provenance.mjs";
+
+const FETCH_TIMEOUT = 15_000
+
+/**
+ * Resolve proxy URI.
+ * New format: { proxy: { uri: "http://host:port", web: true, model: false } }
+ * Old format: { proxy: "http://host:port" } — backwards compatible, web=true model=false
+ * Env vars: HTTPS_PROXY, HTTP_PROXY, ALL_PROXY
+ *
+ * @returns {{ uri: string|null, web: boolean, model: boolean }}
+ */
+export function resolveProxyConfig(ctx) {
+  const cfgProxy = ctx?.agent?.config?.proxy
+  if (!cfgProxy) {
+    const uri = process.env.HTTPS_PROXY || process.env.HTTP_PROXY || process.env.ALL_PROXY || null
+    return { uri, web: !!uri, model: false }
+  }
+  if (typeof cfgProxy === "string") {
+    // Backward compat: bare string → web only
+    return { uri: cfgProxy, web: true, model: false }
+  }
+  return {
+    uri: cfgProxy.uri || cfgProxy.url || null,
+    web: cfgProxy.web !== false,
+    model: cfgProxy.model === true,
+  }
+}
+
+/** Convenience: resolve proxy URI for web tools (websearch/fetch) */
+export function resolveWebProxy(ctx) {
+  const cfg = resolveProxyConfig(ctx)
+  return (cfg.uri && cfg.web) ? cfg.uri : null
+}
+
+/**
+ * Inject the resolved proxy URI into each provider as provider.proxyUri
+ * (consumed by chat() in provider/core.mjs).
+ * Model 请求走代理需要双重开启：per-provider `proxy: true` 且全局 `config.proxy.model === true`（默认关）。
+ */
+export function injectProxy(providers, config) {
+  const { uri, model } = resolveProxyConfig({ agent: { config } })
+  for (const p of providers ?? []) {
+    p.proxyUri = p.proxy && model ? (uri ?? undefined) : undefined
+  }
+}
+
+/**
+ * 在已建立的 socket 上发 HTTP 请求，响应头到齐即 resolve（流式）。
+ * 返回 Response-like: { ok, status, headers: Headers, body: PassThrough(异步迭代), text(): Promise<string> }
+ * body 边收边吐（SSE 流式消费方可逐 chunk 读取）；text() 消费流到底（非流式调用方用）。
+ * opts.signal 全程有效：abort 即 destroy socket 并 reject/终止流。
+ * absoluteForm: 请求行发绝对 URI（http:// 目标的经典代理转发用），默认发 origin-form。
+ * 2026-08-31 会诊 #4：timeout 只覆盖"响应头阶段"；settle 后 body 空闲 > bodyIdleMs 即
+ * 断流（原实现头部 timer 到齐即清，流式中途停摆会无限挂起直到用户 Ctrl+C）。
+ * bodyIdleMs 默认 120s（provider 长生成用 0 即禁用，由调用方决定）。
+ * 导出供测试（裸 socket，无需 TLS/CONNECT）；生产路径走 tunnelHttps / proxyFetch。
+ */
+export function streamHttpResponse(sock, urlStr, opts = {}, timeout = FETCH_TIMEOUT, absoluteForm = false, bodyIdleMs = 120_000) {
+  return new Promise((resolve, reject) => {
+    const target = new URL(urlStr)
+    const method = opts.method ?? "GET"
+    const headers = opts.headers ?? {}
+    const signal = opts.signal
+
+    if (signal?.aborted) { sock.destroy(); return reject(abortError(signal, "provider", "proxy")) }
+
+    const body = new PassThrough()
+    let settled = false
+    let headerBuf = ""
+    let idleTimer = null
+
+    const timer = setTimeout(() => fail(timeoutError("Response timeout", "provider", "proxy-header")), timeout)
+    const onAbort = () => { sock.destroy(); fail(abortError(signal, "provider", "proxy")) }
+    signal?.addEventListener("abort", onAbort, { once: true })
+
+    function cleanup() {
+      clearTimeout(timer)
+      clearTimeout(idleTimer)
+      signal?.removeEventListener("abort", onAbort)
+    }
+    /** 头部阶段失败 reject；resolve 后失败则终止 body 流（for-await 抛出，不挂起） */
+    function fail(err) {
+      cleanup()
+      if (!settled) { settled = true; reject(err) }
+      else body.destroy(err)
+    }
+    /** body 阶段空闲看门狗：每次数据到达重置；无数据超时 → 断流（流式消费方抛错） */
+    function armIdle() {
+      clearTimeout(idleTimer)
+      if (bodyIdleMs > 0) idleTimer = setTimeout(() => body.destroy(timeoutError("Response body timeout (idle)", "provider", "proxy-body-idle")), bodyIdleMs)
+    }
+
+    sock.on("data", (d) => {
+      if (settled) return // 理论上不会发生（settle 后摘掉本监听器），防御
+      headerBuf += d.toString("utf8")
+      const idx = headerBuf.indexOf("\r\n\r\n")
+      if (idx < 0) return
+
+      const headerText = headerBuf.slice(0, idx)
+      const statusMatch = headerText.match(/^HTTP\/\d\.\d (\d+)/)
+      const status = statusMatch ? Number(statusMatch[1]) : 502
+      const respHeaders = {}
+      for (const line of headerText.split("\r\n").slice(1)) {
+        const ci = line.indexOf(":")
+        if (ci > 0) respHeaders[line.slice(0, ci).trim().toLowerCase()] = line.slice(ci + 1).trim()
+      }
+
+      // 头到齐：摘掉头阶段监听，剩余字节推入 body，后续数据直接 pipe
+      sock.removeAllListeners("data")
+      settled = true
+      cleanup()
+      armIdle()
+      const remaining = headerBuf.slice(idx + 4)
+      if (remaining) body.write(Buffer.from(remaining, "utf8"))
+      sock.pipe(body)
+      // 空闲看门狗随数据到达重置。注意必须用 'readable' 而非 'data'：
+      // 'data' 监听把流切成 flowing 模式，会抢走 readSSE/for-await 未来得及认领的
+      // 已写缓冲（2026-08-31 实测：分包响应头的 remaining 首段被吞，readSSE 等不到 ack）。
+      // 'readable' 不改变流模式，数据仍由消费方按需拉取。
+      body.on("readable", armIdle)
+      // body 结束后才移除 abort 监听（流式中途 abort 要能终止流）；空闲看门狗一并清
+      body.on("close", () => {
+        clearTimeout(idleTimer)
+        signal?.removeEventListener("abort", onAbort)
+      })
+      signal?.addEventListener("abort", onAbort, { once: true })
+
+      resolve({
+        ok: status >= 200 && status < 400,
+        status,
+        headers: new Headers(respHeaders),
+        body,
+        text: async () => {
+          const chunks = []
+          for await (const c of body) chunks.push(c)
+          return Buffer.concat(chunks).toString("utf8")
+        },
+      })
+    })
+    sock.on("close", () => {
+      if (!settled) fail(new Error("Connection closed before response"))
+      else body.end()
+    })
+    // 头部阶段的传输错误统一包装为稳定契约（对端 RST 会抛原生 ECONNRESET，调用方难判别）；
+    // resolve 后的 body 阶段保留原始错误终止流
+    sock.on("error", (e) => {
+      if (!settled) fail(new Error(`Connection closed before response (${e.code ?? e.message})`))
+      else fail(e)
+    })
+
+    // 写请求（absoluteForm：代理转发时请求行为绝对 URI）
+    const requestTarget = absoluteForm ? urlStr : `${target.pathname}${target.search}`
+    const lines = [`${method} ${requestTarget} HTTP/1.1`]
+    for (const [k, v] of Object.entries({ ...headers, Host: target.hostname })) lines.push(`${k}: ${v}`)
+    lines.push("Connection: close", "", "")
+    sock.write(lines.join("\r\n"))
+    if (opts.body) sock.write(opts.body)
+  })
+}
+
+/**
+ * HTTPS request through HTTP CONNECT proxy tunnel.
+ * CONNECT + TLS 建立后交给 streamHttpResponse — 响应头到齐即 resolve，body 为流式。
+ * 2026-08-31 会诊 #1/#4：
+ *  - TLS 默认全量证书校验（rejectUnauthorized: true）——走代理的流量（含 API key）
+ *    不得在未验证链路上传输；确需自签/内网代理时 opts.insecureTls=true 显式放行。
+ *  - CONNECT/TLS 阶段用 timeout（默认 15s，建隧道快）；**响应头超时**用
+ *    opts._headerTimeoutMs（默认 60s）——原实现共用 15s，DeepSeek 排队 TTFB>15s
+ *    即误报 "Response timeout"，与直连 600s 语义割裂。
+ */
+export function tunnelHttps(urlStr, opts, proxyUri, timeout = FETCH_TIMEOUT) {
+  return new Promise((resolve, reject) => {
+    let target, proxy
+    try {
+      target = new URL(urlStr)
+      proxy = new URL(proxyUri)
+    } catch {
+      // 融合（§2.5 #74——取双侧并集）：VSC 侧的**坏代理串友好报错**并入核内——
+      // 原生 `Invalid URL` 不解释期望形态，调用方拿到的可观测文案退化。
+      return reject(new Error(`Invalid proxy URI: "${proxyUri}" — expected http://host:port`))
+    }
+    const signal = opts?.signal
+    const headerTimeoutMs = Number.isFinite(opts?._headerTimeoutMs) ? opts._headerTimeoutMs : 60_000
+    const bodyIdleMs = opts?._bodyIdleMs ?? 120_000
+
+    if (signal?.aborted) return reject(abortError(signal, "provider", "proxy"))
+
+    const sock = connect({ host: proxy.hostname, port: Number(proxy.port) || 3128 })
+    const timer = setTimeout(() => { sock.destroy(); reject(new Error("Proxy CONNECT timeout")) }, timeout)
+    const onAbort = () => { sock.destroy(); reject(abortError(signal, "provider", "proxy")) }
+    signal?.addEventListener("abort", onAbort, { once: true })
+    sock.on("connect", () => sock.write(`CONNECT ${target.hostname}:${target.port || 443} HTTP/1.1\r\nHost: ${target.hostname}\r\n\r\n`))
+
+    let buf = ""
+    sock.on("data", d => {
+      buf += d.toString()
+      const end = buf.indexOf("\r\n\r\n")
+      if (end < 0) return
+      const statusLine = buf.slice(0, end).split("\r\n")[0]
+      buf = buf.slice(end + 4)
+      if (!statusLine.includes("200")) { sock.destroy(); clearTimeout(timer); return reject(new Error(`Proxy CONNECT: ${statusLine}`)) }
+      sock.removeAllListeners("data"); clearTimeout(timer)
+
+      // 安全默认：TLS 全量校验。企业中间人代理场景显式 opts.insecureTls=true 才放行。
+      const tlsSock = tlsConnect({ socket: sock, servername: target.hostname, rejectUnauthorized: opts?.insecureTls !== true })
+      if (buf) tlsSock.unshift(Buffer.from(buf))
+      tlsSock.on("secureConnect", () => {
+        // TLS 之后的请求/响应阶段：abort 交由 streamHttpResponse 接管
+        signal?.removeEventListener("abort", onAbort)
+        streamHttpResponse(tlsSock, urlStr, opts, headerTimeoutMs, false, bodyIdleMs).then(resolve, reject)
+      })
+      tlsSock.on("error", e => { sock.destroy(); reject(e) })
+    })
+    sock.on("error", e => { clearTimeout(timer); reject(new Error(`Proxy CONNECT failed (${e.code ?? e.message})`)) })
+    // 代理干净 FIN 关闭（无 error）时也要 reject，不能卡满超时
+    sock.on("close", () => { clearTimeout(timer); reject(new Error("Proxy connection closed before tunnel established")) })
+  })
+}
+
+/** TCP 直连代理（http:// 目标的经典转发用）：超时/abort/对端关闭都有稳定 reject */
+function tcpConnectProxy(proxyUri, signal, timeout) {
+  return new Promise((resolve, reject) => {
+    let proxy
+    try {
+      proxy = new URL(proxyUri)
+    } catch {
+      // 融合（§2.5 #74）：同 tunnelHttps——坏代理串友好报错。
+      return reject(new Error(`Invalid proxy URI: "${proxyUri}" — expected http://host:port`))
+    }
+    const sock = connect({ host: proxy.hostname, port: Number(proxy.port) || 3128 })
+    if (signal?.aborted) { sock.destroy(); return reject(abortError(signal, "provider", "proxy")) }
+    const onAbort = () => sock.destroy()
+    signal?.addEventListener("abort", onAbort, { once: true })
+    const timer = setTimeout(() => { sock.destroy(); reject(new Error("Proxy CONNECT timeout")) }, timeout)
+    const onError = (e) => { clearTimeout(timer); reject(new Error(`Proxy CONNECT failed (${e.code ?? e.message})`)) }
+    const onClose = () => {
+      clearTimeout(timer)
+      reject(signal?.aborted ? abortError(signal, "provider", "proxy") : new Error("Proxy connection closed before tunnel established"))
+    }
+    sock.once("connect", () => {
+      clearTimeout(timer)
+      signal?.removeEventListener("abort", onAbort)
+      sock.removeListener("error", onError)
+      sock.removeListener("close", onClose)
+      resolve(sock)
+    })
+    sock.once("error", onError)
+    sock.once("close", onClose)
+  })
+}
+
+/**
+ * Generic fetch with proxy support.
+ * No proxy → native fetch. Proxy + HTTPS → CONNECT tunnel. Proxy + HTTP → 经典代理转发（绝对 URI 请求行）。
+ */
+export async function proxyFetch(urlStr, opts, proxyUri) {
+  if (!proxyUri) return globalThis.fetch(urlStr, opts)
+  const target = new URL(urlStr)
+  if (target.protocol === "https:") return tunnelHttps(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
+  return streamHttpResponse(sock, urlStr, opts, headerTimeoutMs, true, bodyIdleMs)
+}

package/rules.mjs

@@ -0,0 +1,53 @@
+/**
+ * rules.mjs — stream rule discovery from .thincoder/rules/*.md
+ *
+ * Rule file format (markdown + YAML frontmatter):
+ *   ---
+ *   pattern: "console\\.log"
+ *   action: abort        # "abort"|"warn" (default: "warn")
+ *   repeat: once         # "once"|"always" (default: "always")
+ *   ---
+ *   Use the project logger instead of console.log.
+ *
+ * The body becomes the rule message; if empty, falls back to `message` frontmatter.
+ */
+import { existsSync, readFileSync, readdirSync } from "node:fs"
+import { join } from "node:path"
+import { parseFrontmatter } from "./markdown.mjs"
+
+/**
+ * Scan `.thincoder/rules/` in the project root for `.md` rule files.
+ * Returns an array of rule objects compatible with config.streamRules format.
+ */
+export function discoverRules(projectRoot) {
+  const rulesDir = join(projectRoot, ".thincoder", "rules")
+  if (!existsSync(rulesDir)) return []
+
+  const rules = []
+  let entries
+  try { entries = readdirSync(rulesDir) } catch { return rules }
+
+  for (const f of entries) {
+    if (!f.endsWith(".md")) continue
+    try {
+      const text = readFileSync(join(rulesDir, f), "utf8")
+      const fm = text.match(/^---\r?\n([\s\S]*?)\r?\n---/)
+      if (!fm) continue
+      const meta = parseFrontmatter(fm[1])
+      const body = text.slice(fm[0].length).trim()
+      if (!meta.pattern) continue
+      // Strip surrounding quotes from frontmatter values (parseFrontmatter returns raw)
+      const pattern = meta.pattern.replace(/^"(.*)"$/s, "$1").replace(/^'(.*)'$/s, "$1")
+      const message = (meta.message || "").replace(/^"(.*)"$/s, "$1").replace(/^'(.*)'$/s, "$1")
+
+      rules.push({
+        pattern,
+        message: body || message || "",
+        action: meta.action || "warn",
+        repeat: meta.repeat || "always",
+        name: f.replace(/\.md$/, ""),
+      })
+    } catch { /* skip malformed rule files silently */ }
+  }
+  return rules
+}