cardbuddy 0.19.3 → 0.21.0

package/dist/preview-editor/index.html

@@ -8,8 +8,8 @@
     <link rel="icon" type="image/png" sizes="16x16" href="/assets/favicon-16-Cg6Nrosk.png" />
     <link rel="icon" type="image/png" sizes="32x32" href="/assets/favicon-32-B_1744sp.png" />
     <link rel="apple-touch-icon" sizes="180x180" href="/assets/apple-touch-icon-BQcES9QK.png" />
-    <script type="module" crossorigin src="/assets/index-DRzBK4qj.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-C_uqjKqI.css">
+    <script type="module" crossorigin src="/assets/index-CpDojF__.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-C8VLzU18.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/skills-upgrade.js

@@ -7,18 +7,22 @@
  * 就是为这个场景而生，且**只动 skills/**，绝不碰 .env.cb / package.json / README.md
  * （那是 `init --force` 的危险面，可能冲掉端口 / FinMall 配置 / AI 网关占位）。
  *
- * 四类 diff（内容比对，非 mtime）：
+ * 行为模型（upgrade = 显式要把新版带进来，「有差异 = 应当覆盖」，不做好坏判定）：
  *   ADDED    源有、目标无        → 复制（安全）
- *   SAME     两边内容一致        → 跳过
- *   MODIFIED 两边都有、内容不同  → 默认跳过 + 黄色警告（覆盖风险：消费者可能改过该 shipped skill）
- *   ORPHAN   目标有、源无        → 默认保留不删（可能是消费者私有 skill，或上游已下架该 skill）
+ *   SAME     两边一致            → 跳过
+ *   MODIFIED 两边都有、内容不同  → 默认覆盖（这正是升级的目的，会丢弃本地副本的改动）
+ *   ORPHAN   目标有、源无        → 默认保留（可能是私有 / 上游已下架）
  *
- * 标志：--force 覆盖 MODIFIED；--prune 额外删除 ORPHAN（危险，需显式）；--dry-run 只报告；
- *       --strict 存在 MODIFIED 且未 --force 时返回非 0（便于 CI 感知未决覆盖）。
+ * 确认门禁：当存在 MODIFIED（将覆盖并丢弃本地改动）时，默认进入交互确认——展示将覆盖的
+ *   文件清单，请用户 [y/N] 确认；确认即覆盖，否认即跳过这些 MODIFIED 并继续其余变更。
+ *   交互环境外（非 TTY）无法确认时，必须带 --force 才能升级，否则明确拒绝并提示（不再
+ *   静默跳过、假装升级成功）。
+ * 标志：--force/-y 跳过确认直接覆盖；--prune 额外删除 ORPHAN；--dry-run 只报告不落盘。
  * 同步后写 skills/.synced-from = 当前装包版本，供下次 drift 检测与启动提示。
  */
 import fs from 'node:fs'
 import path from 'node:path'
+import readline from 'node:readline/promises'
 import { fileURLToPath } from 'node:url'
 import chalk from 'chalk'
 import { loadConfig } from './config.js'
@@ -95,14 +99,36 @@ export function diffSkills(src, dest) {
   return res
 }
 
+/**
+ * 确认是否覆盖 MODIFIED 文件。
+ * - force/injected confirm：直接给结果（便于非交互 / 测试）
+ * - 交互 TTY：readline 逐条列出后请用户 [y/N]
+ * - 非 TTY 且无 --force：返回 null（调用方据此明确拒绝，而非静默跳过）
+ * @returns {Promise<boolean|null>}
+ */
+async function resolveOverwriteConsent({ modified, force, confirm, log, tag }) {
+  if (force) return true
+  if (typeof confirm === 'function') return Boolean(await confirm(modified))
+  if (!process.stdin.isTTY) return null
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr })
+  try {
+    log(tag + chalk.yellow(`将覆盖 ${modified.length} 个本地已修改的技能文件（你的本地改动将被丢弃）：`))
+    for (const rel of modified) log(chalk.yellow('    ' + rel))
+    const ans = await rl.question(chalk.bold('确认用包内版本覆盖以上文件？[y/N] '))
+    return /^(y|yes|是|确认|ok)$/i.test(ans.trim())
+  } finally {
+    rl.close()
+  }
+}
+
 /**
  * 执行 skills 升级。
  * @param {object} opts
  * @param {string} [opts.targetDir='.'] 目标工程根（skills 落在 <targetDir>/skills）
- * @param {boolean} [opts.force] 覆盖本地已修改的 shipped skill
+ * @param {boolean} [opts.force] 跳过确认直接覆盖本地已修改的 shipped skill（非交互必备）
  * @param {boolean} [opts.dryRun] 只报告不落盘
  * @param {boolean} [opts.prune] 额外删除包内已不存在的技能文件（默认保留）
- * @param {boolean} [opts.strict] 存在未覆盖 MODIFIED 时返回非 0
+ * @param {(modified:string[])=>boolean|Promise<boolean>} [opts.confirm] 注入式确认（测试用，默认交互）
  * @param {ReturnType<import('./config.js').loadConfig>} [opts.config]
  * @param {(msg: string) => void} [opts.log]
  * @returns {Promise<number>} 进程退出码
@@ -112,7 +138,7 @@ export async function runSkillsUpgrade({
   force = false,
   dryRun = false,
   prune = false,
-  strict = false,
+  confirm = null,
   config,
   log = (m) => console.log(m),
 } = {}) {
@@ -141,13 +167,36 @@ export async function runSkillsUpgrade({
   const version = ownVersion()
   const diff = diffSkills(src, destSkills)
 
+  if (!diff.added.length && !diff.modified.length && !diff.orphan.length && fs.existsSync(destSkills)) {
+    dim(`skills 已是最新（cardbuddy@${version}，无新增 / 修改 / 孤儿）`)
+    return 0
+  }
+
+  // 确认门禁：存在将被覆盖的 MODIFIED 时，先确认
+  let overwriteModified = false
+  if (diff.modified.length && !dryRun) {
+    const consent = await resolveOverwriteConsent({ modified: diff.modified, force, confirm, log, tag })
+    if (consent === null) {
+      warn(`⚠ 检测到 ${diff.modified.length} 个已修改的技能文件将被覆盖，但当前非交互环境无法确认。`)
+      dim('  加 --force 跳过确认直接覆盖，或在交互终端运行本命令确认。')
+      return 1
+    }
+    overwriteModified = consent
+    if (!overwriteModified) {
+      warn(`已跳过 ${diff.modified.length} 个 MODIFIED 文件（未确认覆盖，本地副本保留）；其余变更仍会进行。`)
+    }
+  } else if (diff.modified.length && dryRun) {
+    warn(`dry-run：${diff.modified.length} 个已修改的技能文件将被覆盖（确认后）。`)
+  }
+
   let copied = 0
   let bytes = 0
   let overwritten = 0
+  let added = 0
   let deleted = 0
 
-  // ADDED 总是复制；MODIFIED 仅 --force 时复制
-  const toCopy = [...diff.added, ...(force ? diff.modified : [])]
+  // ADDED 总是复制；MODIFIED 仅当用户确认（或 --force）时复制——这正是升级的目的
+  const toCopy = [...diff.added, ...(overwriteModified ? diff.modified : [])]
   for (const rel of toCopy) {
     const sp = path.join(src, rel)
     const dp = path.join(destSkills, rel)
@@ -159,15 +208,7 @@ export async function runSkillsUpgrade({
     bytes += fs.statSync(sp).size
     copied++
     if (isModified) overwritten++
-  }
-
-  // MODIFIED 未 --force：警告（不复制，防丢改动）
-  if (!force && diff.modified.length) {
-    warn(`⚠ 检测到 ${diff.modified.length} 个已修改的技能文件（本地副本与包内不一致），默认不覆盖，避免丢失你的改动：`)
-    for (const rel of diff.modified) say(chalk.yellow(`    ${rel}`))
-    dim('  如需用包内版本覆盖，加 --force；想先看差异，加 --dry-run 后人工对比。')
-  } else if (force && diff.modified.length) {
-    warn(`--force：已用包内版本覆盖 ${diff.modified.length} 个本地修改的技能文件（你的改动将被丢弃）`)
+    else added++
   }
 
   // ORPHAN：默认保留；--prune 才删除
@@ -207,14 +248,12 @@ export async function runSkillsUpgrade({
   say(chalk.dim(`  目标：${targetNote}`))
   say(
     chalk.dim(
-      `  新增 ${diff.added.length} · 相同 ${diff.same.length} · 覆盖 ${overwritten} · 保留私有 ${diff.orphan.length}` +
+      `  新增 ${added} · 相同 ${diff.same.length} · 覆盖 ${overwritten}` +
+        `${overwriteModified ? '' : ` · 跳过修改 ${diff.modified.length - overwritten}`}` +
+        ` · 保留私有 ${diff.orphan.length}` +
         `${prune ? ` · 删除孤儿 ${deleted}` : ''} · 体积 ${fmtBytes(bytes)}`
     )
   )
 
-  if (strict && diff.modified.length && !force) {
-    say(chalk.red('（--strict：存在未覆盖的 MODIFIED 文件，返回非 0）'))
-    return 2
-  }
   return 0
 }

package/dist/standalone.js

@@ -315,6 +315,49 @@ function createEventsEndpoint() {
   return { handler, notify }
 }
 
+/**
+ * 事件循环看门狗：周期性测量循环滞后，超阈值时打日志 + 活动资源清单。
+ *
+ * 背景：dev server 单进程承载 AI 回合 / 远端同步 / 卡片 CRUD / Vite SSR。任何一个操作堵住
+ * 事件循环（同步大计算、挂死的子进程、CPU 被同机 Chrome 抢占），症状都是「端口还在听、
+ * 但所有请求都不响应」。没有这个看门狗时这类故障完全无迹可查；有了它，日志里会留下
+ * 「滞后多久 + 当时挂着哪些资源（timer / socket / child process）」的直接证据。
+ *
+ * 只观测、不干预：不做任何自动恢复动作（误杀正在跑的长任务代价更大），把事实留给开发者判断。
+ * @param {{ intervalMs?: number, lagWarnMs?: number }} [opts]
+ */
+function installEventLoopWatchdog({ intervalMs = 2000, lagWarnMs = 5000 } = {}) {
+  let last = Date.now()
+  let warned = false
+  const timer = setInterval(() => {
+    const now = Date.now()
+    const lag = now - last - intervalMs
+    last = now
+    if (lag <= lagWarnMs) {
+      warned = false
+      return
+    }
+    // 连续超标只报警一次，恢复后重置，避免把日志刷爆
+    if (warned) return
+    warned = true
+    let resources = ''
+    try {
+      resources = process.getActiveResourcesInfo().join(', ')
+    } catch {
+      /* 老版本 Node 没有该 API */
+    }
+    console.warn(
+      srcTag +
+        chalk.yellow(
+          `⚠ 事件循环滞后 ${(lag / 1000).toFixed(1)}s（阈值 ${lagWarnMs / 1000}s）：服务可能暂时无响应。` +
+            ` 活动资源：${resources || '(unknown)'}`
+        )
+    )
+  }, intervalMs)
+  if (typeof timer.unref === 'function') timer.unref()
+  return timer
+}
+
 /**
  * 监听 src/cards 变更并（防抖）推送。
  *
@@ -474,6 +517,12 @@ export async function startServer(userConfig = {}) {
 
   watchCards(config.root, events.notify)
 
+  // 事件循环看门狗：dev server 是单进程服务一切（AI 回合 / 远端同步 / 卡片 CRUD / Vite SSR）。
+  // 任何一个操作把事件循环堵住（同步大计算、挂死的子进程等待、CPU 被同机 Chrome 抢占），
+  // 症状都是「端口还在、但所有请求都不响应」——而这种故障此前无任何线索可查。
+  // 这里周期性测循环滞后，超阈值就打日志 + 当时的活动资源清单，让下次「僵死」有据可查。
+  installEventLoopWatchdog({ intervalMs: 2000, lagWarnMs: 5000 })
+
   const server = tls
     ? https.createServer(tls, app)
     : http.createServer(app)

package/dist/vendored/card-editor/components/MultiColumn.vue

@@ -1,12 +1,13 @@
 <!--
   多列布局容器（官方组件 MultiColumn）。
 
-  预览运行时此前未注册该组件，导致画布显示「未知组件」占位（问题 #4）。
-  本组件对齐 Row/Column 的容器范式：用 StyleParser 解析样式（rect / flex / padding …），
-  渲染默认插槽内容；当 `column` 属性 > 1 时切换为 CSS Grid 多列布局（列数 = column）。
+  官方 component-meta 里 MultiColumn 没有 column 属性（properties: []），
+  真实运行时语义 = **直接子节点数即列数，单行均分**（N 个子节点 → N 等宽列）。
+  预览器此前自造 `column=2` 默认值，导致 4 子节点被排成 2×2（overseaTransfer
+  步骤条 row_hf 实测踩坑：内容高度翻倍后被 AbsoluteLayout 裁切，圆圈/标签错位）。
 
-  说明：当前测试卡的 MultiColumn 实例（comp_3）为「空容器」（无插槽子节点、无 column 属性），
-  此处仍提供完整的多列渲染能力，便于后续接入真实带子节点的多列布局卡片。
+  实现：显式传 column > 0 时按指定列数（保留扩展口子）；否则按默认插槽的
+  子 vnode 数自动取列数，>1 时切换 CSS Grid 单行均分（flex gap 兼作列间距）。
 -->
 <template>
   <div ref="mc" class="ce_multicolumn" :style="styleObj" @click="$emit('click', $event)">
@@ -15,6 +16,7 @@
 </template>
 
 <script>
+import { Comment, Text } from 'vue'
 import StyleParser from '../runtime/StyleParser.js'
 import base from './base.js'
 
@@ -24,16 +26,23 @@ export default {
   mixins: [base],
   props: {
     styleProps: { type: Object, default: () => ({}) },
-    column: { type: [Number, String], default: 2 },
+    /** 列数。0 = 自动（默认）：按子节点数单行均分，对齐官方「无 column 属性」语义 */
+    column: { type: [Number, String], default: 0 },
   },
   computed: {
+    cols() {
+      const explicit = parseInt(this.column, 10)
+      if (explicit > 0) return explicit
+      const vnodes = this.$slots.default ? this.$slots.default() : []
+      // 只统计真实子组件 vnode；注释 / 纯文本节点不计入
+      return vnodes.filter((v) => v && v.type !== Comment && v.type !== Text).length
+    },
     styleObj() {
       const s = new StyleParser(this, this.styleProps).parse()
-      const cols = parseInt(this.column, 10)
-      if (cols && cols > 1) {
-        // 多列：用 grid 把子节点按 column 列均分；flex gap 同时充当 grid 行列间距。
+      if (this.cols > 1) {
+        // 多列：用 grid 把子节点单行均分；flex gap 同时充当 grid 列间距。
         s.display = 'grid'
-        s.gridTemplateColumns = `repeat(${cols}, 1fr)`
+        s.gridTemplateColumns = `repeat(${this.cols}, 1fr)`
       }
       return s
     },

package/dist/vendored/card-editor/runtime/card-runtime.js

@@ -111,7 +111,7 @@ export function createCardRuntime(rootScopeRaw, adapter) {
     },
     /**
      * 切换卡片 / 绑定数据整体替换：**原地改写**现有响应式 rootScope，保持引用不变，
-     * 使 App.vue 的 `:scope="rt.rootScope"` 绑定、所有 `rt.rootScope` 读取方与画布
+     * 使 App.vue 的 `:scope="rt.state"` 绑定、所有 `rt.rootScope` 读取方与画布
      * 实时看到新数据。
      *
      * 早期实现把 rootScope 重赋成一个「新 reactive 对象」，导致 RenderTree 的 scope

package/dist/vendored/mcp/client.mjs

@@ -29,9 +29,28 @@ if (!process.env.DSL_CARD_PROJECT_ROOT) process.env.DSL_CARD_PROJECT_ROOT = ROOT
 // 仍可用 CARD_API_BASE 覆盖（如 dev server 跑在非默认端口）。
 const BASE = (process.env.CARD_API_BASE || devApiBase()).replace(/\/$/, '')
 
+/**
+ * dev server 请求超时。
+ *
+ * 为什么必须有：AI 回合的工具调度（card_read / render_status / validate / screenshot…）全部
+ * 经这里打到 dev server。裸 fetch 没有超时——dev server（Vite SSR / Python 校验子进程）一旦
+ * 卡住，工具调用就永久挂起；而回合墙钟只在**每轮开头**检查，挂在工具调用里时永远走不到那里，
+ * 结果是该卡的回合锁被无限期占用，之后每条消息都拿到 409「已有一个回合在跑」。
+ * 默认 120s 足够覆盖 SSR 渲染 + 8s Python 校验 + 截图，又不会让真挂死无限拖下去。
+ */
+const HTTP_TIMEOUT_MS = Number(process.env.CARDBUDDY_MCP_HTTP_TIMEOUT_MS || 120000)
+
+/** 带超时的 fetch：超时抛错（含明确文案），由调用方的降级逻辑处理 */
+function httpFetch(p, init = {}) {
+  const ctl = new AbortController()
+  const timer = setTimeout(() => ctl.abort(), HTTP_TIMEOUT_MS)
+  if (typeof timer.unref === 'function') timer.unref()
+  return fetch(BASE + p, { ...init, signal: ctl.signal }).finally(() => clearTimeout(timer))
+}
+
 /** 发起 GET，返回 { status, buf, text, json, contentType }；任何网络错误向上抛，由调用方决定降级 */
 async function httpGet(p) {
-  const res = await fetch(BASE + p, { headers: { Accept: 'application/json, image/png' } })
+  const res = await httpFetch(p, { headers: { Accept: 'application/json, image/png' } })
   const buf = Buffer.from(await res.arrayBuffer())
   let text = null
   let json = null
@@ -46,7 +65,7 @@ async function httpGet(p) {
 
 /** 发起 PATCH（JSON body）——目前只用于卡片重命名（PATCH /__card/<id>） */
 async function httpPatch(p, body) {
-  const res = await fetch(BASE + p, {
+  const res = await httpFetch(p, {
     method: 'PATCH',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify(body || {}),
@@ -65,7 +84,7 @@ async function httpPatch(p, body) {
 
 /** 发起 POST（JSON body） */
 async function httpPost(p, body) {
-  const res = await fetch(BASE + p, {
+  const res = await httpFetch(p, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify(body || {}),

package/dist/vendored/server/core/ai-chat.js

@@ -3524,22 +3524,36 @@ function listCcSwitchProviders() {
 function readBody(req, limitBytes = 8 * 1024 * 1024) {
   return new Promise((resolve, reject) => {
     let data = ''
+    let settled = false
+    const done = (fn, v) => {
+      if (settled) return
+      settled = true
+      fn(v)
+    }
     req.setEncoding('utf8')
     req.on('data', (chunk) => {
       data += chunk
       if (data.length > limitBytes) {
-        reject(new Error('body too large'))
+        done(reject, new Error('body too large'))
         req.destroy()
       }
     })
     req.on('end', () => {
       try {
-        resolve(data ? JSON.parse(data) : {})
+        done(resolve, data ? JSON.parse(data) : {})
       } catch (e) {
-        reject(e)
+        done(reject, e)
+      }
+    })
+    req.on('error', (e) => done(reject, e))
+    // 客户端中断（断网 / 主动取消 / 关标签页）时 req 只发 'aborted'+'close'、不发 'end'：
+    // 不收口会让这个 Promise 永远 pending，handler 挂着不返回、连接与回合锁一起泄漏。
+    req.on('aborted', () => done(reject, Object.assign(new Error('request aborted'), { code: 'aborted' })))
+    req.on('close', () => {
+      if (!req.complete) {
+        done(reject, Object.assign(new Error('request aborted'), { code: 'aborted' }))
       }
     })
-    req.on('error', reject)
   })
 }
 
@@ -4186,6 +4200,33 @@ function transientRetryDelays() {
 
 const nap = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
 
+/**
+ * 带硬超时的 fetch：模型网关「接受连接但不回数据」（响应卡死）时，原生 fetch 会一直挂到 OS 层
+ * 超时（分钟级），既拖住当前请求又泄漏 socket。这里统一套一个 AbortController 超时，让所有出向
+ * 模型请求（探测 / 连通性自测 / 流式）都有明确的失败边界，卡死立刻变「错误收敛」而非「服务假死」。
+ * @param {string} url
+ * @param {object} init fetch 选项（signal / method / headers / body 等）
+ * @param {number} [timeoutMs] 超时毫秒；可用 AI_HTTP_TIMEOUT_MS 覆盖（默认 20000）
+ */
+function fetchWithTimeout(url, init = {}, timeoutMs) {
+  const ms = Number(timeoutMs) > 0 ? Number(timeoutMs) : Number(process.env.AI_HTTP_TIMEOUT_MS) || 20000
+  // 已有上层 signal（流式 stall 看门狗 / 用户 stop）时合并，避免互相覆盖
+  const parent = init.signal
+  const ctl = new AbortController()
+  const timer = setTimeout(() => ctl.abort(), ms)
+  if (typeof timer.unref === 'function') timer.unref()
+  const onParentAbort = () => ctl.abort()
+  if (parent && typeof parent.addEventListener === 'function') {
+    if (parent.aborted) ctl.abort()
+    else parent.addEventListener('abort', onParentAbort, { once: true })
+  }
+  const cleanup = () => {
+    clearTimeout(timer)
+    if (parent && typeof parent.removeEventListener === 'function') parent.removeEventListener('abort', onParentAbort)
+  }
+  return fetch(url, { ...init, signal: ctl.signal }).finally(cleanup)
+}
+
 /** 网关静默后的重试间隔：AI_STALL_RETRY_MS 可覆盖（单测压成 0 提速）；次数多于间隔就沿用最后一个 */
 function stallRetryDelays() {
   const list = String(process.env.AI_STALL_RETRY_MS || '2000,5000,10000')
@@ -4268,7 +4309,7 @@ async function* callLLM({ baseUrl, apiKey, model, messages, tools, maxTokens = 4
         code: 'gateway-retry',
         text: `网关返回 HTTP ${resp.status}（瞬时错误）：${wait / 1000} 秒后自动重试本步（第 ${attempt + 1}/${delays.length} 次），任务不中断`,
         })
-        await nap(wait)
+        if (!(await napUnlessAborted(wait, signal))) throw new Error('请求已中止')
       } catch (e) {
         if (signal?.aborted) throw e
         lastErr = e
@@ -4279,7 +4320,7 @@ async function* callLLM({ baseUrl, apiKey, model, messages, tools, maxTokens = 4
         code: 'gateway-retry',
         text: `网关连接失败（${String(e?.message || e).slice(0, 80)}）：${wait / 1000} 秒后自动重试本步`,
         })
-        await nap(wait)
+        if (!(await napUnlessAborted(wait, signal))) throw new Error('请求已中止')
       }
     }
     const err = new Error(`LLM 网络错误：${String(lastErr?.message || lastErr).slice(0, 200)}`)
@@ -4508,7 +4549,13 @@ async function* callLLM({ baseUrl, apiKey, model, messages, tools, maxTokens = 4
     while (true) {
       if (signal?.aborted) return
       const { done, value } = await reader.read()
-      if (done) break
+      // 流 EOF（含网关把错误包成 HTTP 200 + 非 SSE body 返回、且不带 [DONE] 的场景）：
+      // 必须连外层 parse 循环一起退出。只 break 内层会让外层 while(true) 立刻重入，
+      // 而已结束流的 read() 立即 resolve {done:true} —— 整个循环退化成纯 microtask 空转，
+      // 事件循环被饿死，8787 对所有请求（含新连接）永久无响应（2026-10-20 实测：
+      // newapi 过期模型返回 200 HTML，服务 100% CPU 卡死，刷新页面也连不上）。
+      // break parse 后走下面的「流末尾残留」兜底解析，行为与 [DONE] 路径一致。
+      if (done) break parse
       // 收到字节就冒一个「连接还活着」事件：轮循环的静默看门狗据此区分「网关彻底不回应」与
       // 「模型正在长思考 / 正在拼超长工具参数，中转网关只在末尾批量 flush」。
       // 此前看门狗只认 reasoning / content / tool_calls 增量：网关缓冲工具参数时连接明明是活的，
@@ -4785,7 +4832,7 @@ async function probeVisionSupport({ baseUrl, apiKey, model }) {
       ],
     })
     const call = async (body) => {
-      const r = await fetch(url, { method: 'POST', headers, body: JSON.stringify(body) })
+      const r = await fetchWithTimeout(url, { method: 'POST', headers, body: JSON.stringify(body) })
       const text = await r.text().catch(() => '')
       let json = null
       try {
@@ -4874,7 +4921,7 @@ async function runMaxTokensProbe({ baseUrl, apiKey, model }, { binary = true } =
   let source = ''
   try {
     if (maxTokensMetaMiss.has(sig)) throw new Error('meta-miss')
-    const r = await fetch(`${base}/models`, { headers })
+    const r = await fetchWithTimeout(`${base}/models`, { headers })
     if (r.ok) {
       const j = await r.json().catch(() => null)
       const list = Array.isArray(j && j.data) ? j.data : []
@@ -4899,7 +4946,7 @@ async function runMaxTokensProbe({ baseUrl, apiKey, model }, { binary = true } =
   if (binary && !capCache.has(sig)) {
     for (const cand of MAXTOKENS_CANDIDATES) {
       try {
-        const r = await fetch(`${base}/chat/completions`, {
+        const r = await fetchWithTimeout(`${base}/chat/completions`, {
           method: 'POST',
           headers,
           body: JSON.stringify({ model, stream: false, max_tokens: cand, messages: [{ role: 'user', content: 'ping' }] }),
@@ -5435,8 +5482,15 @@ export function createAiChatMiddleware(opts = {}) {
     return true
   }
 
-  return async (req, res, next) => {
-    const rawUrl = req.url || ''
+  // 边界兜底：本中间件是 async 函数，而宿主（connect）不会 await / catch 异步中间件抛出的错误，
+  // 任意逃逸的 rejection 会变成 unhandledRejection，Node ≥15 默认直接终止进程 —— 一个卡死的模型
+  // 请求就可能让整个 8787 服务「不再响应」。这里把整段逻辑包进 run()，在边界统一 catch：
+  // 既结束响应、释放单飞锁，又不让异常逃逸到进程层。
+  return (req, res, next) => {
+    let _turnKey
+    let _turnLock
+    const run = async () => {
+      const rawUrl = req.url || ''
     const qIdx = rawUrl.indexOf('?')
     const pathname = qIdx >= 0 ? rawUrl.slice(0, qIdx) : rawUrl
     if (!pathname.startsWith('/__ai/')) return next()
@@ -6110,6 +6164,9 @@ export function createAiChatMiddleware(opts = {}) {
     }
     const turnLock = { since: Date.now(), turnTimeoutMs: finalConfig.turnTimeoutMs }
     activeTurns.set(turnKey, turnLock)
+    // 暴露给边界 catch：逃逸异常时仍能把这把单飞锁放掉，避免这张卡彻底卡死
+    _turnKey = turnKey
+    _turnLock = turnLock
     /** 释放本回合的单飞锁（幂等：只删自己那把，避免误删接管者的锁） */
     const releaseTurnLock = () => {
       if (activeTurns.get(turnKey) === turnLock) activeTurns.delete(turnKey)
@@ -7224,6 +7281,29 @@ export function createAiChatMiddleware(opts = {}) {
       releaseTurnLock()
       if (!res.writableEnded) res.end()
     }
+    }
+    run()
+      .catch((err) => {
+        try {
+          log.error?.('[ai-chat] 回合未捕获错误（已在中间件边界兜底，不影响 8787 其余请求）：', err)
+        } catch {}
+        // 释放单飞锁（与 finally 同款幂等判定），避免这张卡因一次异常永久卡死
+        try {
+          if (_turnKey != null && _turnLock && activeTurns.get(_turnKey) === _turnLock) {
+            activeTurns.delete(_turnKey)
+          }
+        } catch {}
+        // 兜底结束响应：SSE 已开始则直接收尾；尚未发头则回 500，绝不留一个永不结束的连接
+        try {
+          if (!res.headersSent && !res.writableEnded) {
+            res.statusCode = 500
+            res.setHeader('Content-Type', 'application/json')
+            res.end(JSON.stringify({ error: 'internal-error', message: String((err && err.message) || err) }))
+          } else if (!res.writableEnded) {
+            res.end()
+          }
+        } catch {}
+      })
   }
 }