mingdao-harness 0.6.12 → 0.6.13

package/README.md

@@ -275,7 +275,7 @@ mingdao cost --by pack          # 垂域费用分账
 
 ## 配置与扩展
 
-配置字段、权限规则、Hooks、MCP、云同步、自定义 Provider 的完整说明见 [docs/CONFIG.md](docs/CONFIG.md)；架构见 [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md)；Provider 扩展见 [docs/PROVIDERS.md](docs/PROVIDERS.md)。
+配置字段、权限规则、Hooks、MCP、云同步、自定义 Provider 的完整说明见 [docs/CONFIG.md](docs/CONFIG.md)；架构见 [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md)；Provider 扩展见 [docs/PROVIDERS.md](docs/PROVIDERS.md)；桌面版自动更新（检查 / 下载 / 来源签名 / feed 与发版链路）见 [docs/DESKTOP-AUTO-UPDATE.md](docs/DESKTOP-AUTO-UPDATE.md)。
 
 ## 常见问题
 

package/docs/CONFIG.md

@@ -419,26 +419,79 @@ completion 计费，防止推理吃满上限时空轮白烧）、`compactTrigger
 ```
 
 - **判据**：连续 N 分钟**既没有"成功且不重复的工具结果"、也没有新的正文/推理增量** → 主动中止整个
-  回合，并如实报告「连续 N 分钟没有任何工具调用、也没有新内容，已中止」+ 已发生的模型轮次/工具调用数。
+  回合，并如实报告「连续 N 分钟没有任何工具调用、也没有新内容，已中止」+ 已发生的模型轮次/工具调用数，
+  外加**中止时正在等待哪个工具、等了多久**，以及与 `capped`/`aborted` 的区别
+  （capped = 跑满步数上限、可续跑；aborted = 你点的停止；stalled = 再等下去也不会产出新东西）。
   重复调用（name+args 完全相同）与失败调用**不算进展**——真机现场正是它们把时间烧光的。
 - **默认 60 分钟**的依据：现有单请求总量上限是本地 1800s；回合级阈值取它的 **2 倍**，
   保证"一次慢 prefill"永远由更具体的请求级超时（首帧/空闲/总量各有文案）先说话，看门狗不抢答；
   而真干活的回合每隔几秒就有工具结果或正文增量，60 分钟零增量在任何正常回合都不可能。
-- 该值**不能**用 0/负数/Infinity 关掉（一律回落默认，fail-safe）；子代理会**继承父回合的截止时刻**
-  （24 个并行子代理不会各跑各的几小时）。
+- 该值**不能**用 0/负数/Infinity 关掉（一律回落默认，fail-safe）；子代理会**继承父回合的阈值**
+  （24 个并行子代理不会各跑各的几小时），且继承的**截止时刻是活的**——它随父回合的进展前移。
+- **子代理的进展算父回合的进展**（v0.6.13 真机修复）：父回合在 `await task` 期间拿不到任何中间信号，
+  所以子代理每有一次真实进展（成功且不重复的工具结果 / 新正文增量）就回调父回合，父回合据此续期，
+  并把快照挂在 `io.turnProgress.subagent` 上——`web-server.log` 的进度行与界面状态条因此能写出
+  「正在等待工具 task（已 620s）· 子代理「审计 agent.js」已跑 12 轮 / 17 次工具调用，最后进展 3s 前」，
+  "在等子代理"与"卡死"才分得开（真机现场日志里只有前者，看不出子代理是在干活还是死了）。
+- **子代理卡住由它自己的看门狗先响**：父回合在等待子代理时只多等 15s
+  （`SUBAGENT_WAIT_GRACE_MS`，相对默认 60 分钟是 0.4%——**不是**放宽阈值），
+  这样子代理的收口结论（"自己无进展"还是"父回合整轮无进展"）能原样回传父回合，
+  而不是被父回合抢先掐断、只剩一句"父回合中止"。
+- **stalled 在界面上必须有说明**：内核发一条告警 banner（内容与 `done.note` 同源），
+  前端在消息下方再留一条，并把结局（含两种 stalled 原因）写进控制台
+  ——桌面壳日志取的就是渲染进程 console，此前那里只有「回合收尾：generating=false」，
+  与内核的 `status=stalled` 对不上。
 
 #### 端点预检（v0.6.13，本地端点自动执行）
 
 对**本地端点**（baseUrl 是回环/内网，或 `customModels.<名>.local: true`）在开工前做一次轻量预检
 （结果缓存 10 分钟，只读不写你的配置）：
 
-1. 取 `/v1/models`，把**引擎实际加载的模型名**与配置项名对照（不一致会写出来，避免"配的是 A、跑的是 B"）；
+1. 读**引擎自述上下文**（`GET /props`，见下一条）——配置的 `contextWindow` 超没超引擎能力，只有这里能知道；
 2. 发 **3 次**极小请求（1 条 user + 1 个工具声明 + `max_tokens: 256`），看 `tool_calls` 与 `finish_reason`，
    给出三态之一：**稳定支持**（3/3）/ **不稳定**（N/3，会提示"agent 任务可能步数为 0"）/ **不支持**（0/3）；
    被 `max_tokens` 截断的样本（`finish_reason: length`，思考型模型常见）判为**不可判定**，不当作"不支持"；
+   （引擎实际加载的模型名从 chat 响应的 `model` 字段读——**不**额外打 `GET /models`：有的端点没实现它，
+   而 llama.cpp 在流式响应里直接回完整文件路径，语义等价且少一个请求。）
 3. 再发一次 **参考 prefill**（约 2000 tokens 的提示）测耗时；
 4. 与本机历史值比对：**同一端点明显变慢**（≥3 倍）会提示"该端点可能仍在处理上一个请求，建议重启引擎"。
 
+#### 预检读「引擎自述上下文」（v0.6.13）
+
+本地端点预检时**额外读一次引擎自述**（`GET /props`，只读、不改配置）：
+
+- llama.cpp 的 `/props` 通常返回 `default_generation_settings.n_ctx`（有的版本另有顶层 `n_ctx`/`n_ctx_train`）；
+  其他引擎能读多少读多少（`max_model_len`、`context_length`、`model_info.*.context_length`），
+  **读不到就跳过并说明**（不猜、不编造、也不据此判定端点不行）。
+  `/props` 挂在根上，而 `baseUrl` 通常带 `/v1`，预检会先剥掉 `/v\d+` 再试，失败再退回原样。
+- **什么时候会去打这个请求**：只有端点**自报了模型名**才打。llama.cpp 家族（含 llama-cpp-python/
+  koboldcpp/LM Studio）总会在响应里回模型名或模型文件路径；回不了名的多半是"只实现了
+  `/v1/chat/completions`"的网关或测试桩——它们不认识 `/props`，多打一个 GET 可能把对方打断
+  （本仓 `test/e2e-web.js` 的 mock 就是这样被打挂的：它只按 `POST + JSON body` 解析）。
+  跳过时结论里会写「引擎自述上下文：跳过（该端点未自报模型名，不确认它实现 /props）」，
+  不会假装核对过。
+- 结论会与配置**并排**写出来，同时出现在界面 banner、`web-server.log`
+  （`预检 <模型> … 引擎自述上下文=… 配置=…`）与发送前的规模预告里：
+
+  ```
+  ⚠ 引擎自述上下文 32768 vs 配置 131072 —— 配置超出引擎能力，长上下文将直接被引擎拒绝
+  ```
+
+- 为什么这条必须有：真机实测配置 `contextWindow: 131072`、引擎只装了 32768，
+  15,983 tokens 的 prompt 在 prefill 阶段就被引擎拒绝（`insufficient memory: the request exceeded
+  available GPU memory … during prefill`）。此时**换预设、调小 `contextBudget`、调大 `timeout.*`
+  都无效**——它们改不了引擎的 `n_ctx`；要么在引擎侧把上下文窗口调大
+  （llama.cpp 的 `--ctx-size` / `--context-window`），要么把 `customModels.<名>.contextWindow` 改成 ≤ 引擎值。
+
+#### 发送前的规模预告由预检实测推导（v0.6.13）
+
+回合开始前的 `📏 本轮上下文 ≈ …` 预告，在**有预检实测**时按
+`参考 prefill 耗时 × 本轮 tokens ÷ 参考 tokens` 线性外推，并在文案里注明这是外推、以及
+"长上下文下引擎可能显著变慢"的实测差值（本机 16k tokens 首帧 53.7s，而按同一份预检外推只有 0.6s）——
+只报乐观值会训练用户忽略这条告警。**只有拿不到预检数据**（端点不可达 / 不可判定）时才退回
+"prefill 可能需数分钟至数十分钟"的保守文案；外推超过 60s（`PREFILL_SLOW_WARN_MS`）才告警，
+且必须写出依据（预检实测值 + 本轮 tokens + 阈值）。
+
 预检结论会出现在：回合开始时的界面 banner、`web-server.log`（`预检 <模型> …` 行）、
 以及发送前的规模预告里。并且**按实测 TTFT 自适应**超时：首帧上限 = clamp(max(实测首帧×20, 参考prefill×5),
 既有默认, 1800s)、无进展看门狗 = clamp(max(实测首帧×100, 参考prefill×20), 10min, 60min)；
@@ -497,7 +550,9 @@ curl -s http://127.0.0.1:8081/v1/models | head -c 400      # 端口按你的部
 | 引擎没起来 / 端口不对 | 预检 `❌ 不可达：…`；请求以 `网络请求失败` 报错（几秒内） |
 | 连上但不发首帧 | 到 `timeout.firstTokenMs` 报「首 token 等待超限（Ns，本地模型长上下文 prefill 可能很慢）——可调大 config.timeout.firstTokenMs…」 |
 | 有帧但长时间没新数据 | 到 `timeout.streamIdleMs`（默认 120s）报「流式响应空闲超限（Ns 无新数据）」 |
-| 每轮都能返回、但什么都没做成 | 到 `noProgressTimeoutMs`（默认 60min，快端点自适应到 10min）报「连续 N 分钟没有任何工具调用、也没有新内容，已中止」 |
+| 每轮都能返回、但什么都没做成 | 到 `noProgressTimeoutMs`（默认 60min，快端点自适应到 10min）报「连续 N 分钟没有任何工具调用、也没有新内容，已中止」，并附**中止时正在等待哪个工具/等了多久**；界面另有告警 banner（与 `capped` 跑满步数、`aborted` 你点的停止**区分开**） |
+| 一直在等 `task` 子代理 | 进度行/状态条会写出**子代理自己的进度**（第几轮、几次工具调用、最后进展距今多久）；子代理有进展时父回合不会被判无进展，子代理真卡住则由**它自己的**看门狗先中止并把原因回传父回合 |
+| 引擎装不下配置的窗口 | 预检读 `GET /props` 得到引擎自述上下文，与配置并排；配置超出即告警「配置超出引擎能力，长上下文将直接被引擎拒绝」（换预设/调 `contextBudget` 都无效） |
 | 上游 4xx/5xx（模板/内存/鉴权…） | 错误里带**上游原文**并附一条可操作判断（例如"该端点的模板不接受当前 messages 形态"） |
 
 **第 5 步：模型不支持工具调用时会怎样**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mingdao-harness",
-  "version": "0.6.12",
+  "version": "0.6.13",
   "description": "MingDao Harness —— 开源智能体框架（Agent Harness）。零依赖、开箱即用，针对 DeepSeek-V4 系列优化，开放主流模型接入。",
   "type": "module",
   "bin": {

package/src/agent.js

@@ -67,6 +67,15 @@ const SUBAGENT_MAX_STEPS = 24;
  *  可配置：config.noProgressTimeoutMs（0/负数/NaN/Infinity 一律回落默认——**不能**用它关掉看门狗）。 */
 export const DEFAULT_NO_PROGRESS_TIMEOUT_MS = 3600000;
 
+/** 父回合在等待 `task` 子代理时额外给的一点点宽限（ms）。
+ *
+ *  v0.6.13（问题 3）：子代理的看门狗与父回合是**同一个阈值**，两者会在同一刻到点；
+ *  必须让**子代理先响**——否则父回合先掐断，`task` 的工具结果里只剩"父回合中止"，
+ *  用户看不出子代理自己卡在哪一步、跑到了第几轮（真机现场正是这种形态）。
+ *  这不是"把阈值调大掩盖问题"：判据没动、默认值没动，只是在"父回合正等子代理"这一种
+ *  形态下多等 15s（相对默认 60 分钟是 0.4%），换"子代理自己的结论能回传父回合"。 */
+export const SUBAGENT_WAIT_GRACE_MS = 15000;
+
 /** 解析无进展阈值：非正/非有限一律回落默认（fail-safe，防"配置写 0 就静默失去看门狗"）。 */
 export function resolveNoProgressTimeoutMs(/** @type {any} */ cfg) {
   const v = Number(cfg?.noProgressTimeoutMs);
@@ -75,17 +84,69 @@ export function resolveNoProgressTimeoutMs(/** @type {any} */ cfg) {
 
 /** 上下文占窗口比例的告警线（≥ 此值 → 显式警告"缩小任务/或调大 firstTokenMs"）。 */
 export const PREFILL_WARN_RATIO = 0.8;
-/** 本地端点的 prompt 规模告警线（tokens）：超过即提示 prefill 可能数十分钟。 */
+/** 本地端点的 prompt 规模告警线（tokens）：**只在没有预检数据时**用它兜底（有实测就不用规模猜）。 */
 export const PREFILL_WARN_TOKENS = 60000;
+/** 由预检外推的 prefill 超过它就显式告警（ms）。依据见下面 prefillForecast 的注释。 */
+export const PREFILL_SLOW_WARN_MS = 60000;
+/** "线性外推会低估"的**实测证据**（写进文案，让用户知道外推值不是承诺）。
+ *
+ *  真机（负责人 2026-10-09，同一个 taskId t424aaab2aecab8a3）：
+ *    04:13:27 预告 本轮上下文 ≈ 15,983 tokens；预检「参考 prefill 2000 tokens 0.08s」
+ *    04:14:17 chat 首帧 t424aaab2aecab8a3 **53.7s**
+ *  线性外推 = 0.08s × 15983/2000 ≈ 0.6s，实测 53.7s —— **差约 90 倍**。
+ *  原因：2000 tokens 的参考样本落在引擎的短上下文快路径上；真实任务把 KV cache 占满后，
+ *  dequant/内存压力会让 prefill 显著变慢（真机现场还有 `insufficient memory … during prefill`）。
+ *  所以文案**只报外推值是不够的**，必须同时说出这条实测差值。 */
+export const PREFILL_LONGCTX_EVIDENCE = '本机实测 16k tokens 首帧 53.7s，而按同一份预检外推只有 0.6s（约 90 倍）';
+
+/** 把毫秒格式化成给人看的时长（<60s 用秒、否则 m分s秒）。 */
+const fmtDur = (/** @type {number} */ ms) => {
+  const s = Number(ms) / 1000;
+  if (!Number.isFinite(s) || s < 0) return '？';
+  return s < 60 ? `${s.toFixed(1)}s` : `${Math.floor(s / 60)}m${String(Math.round(s % 60)).padStart(2, '0')}s`;
+};
+
+/** 参考 prefill 的耗时格式化：保留两位（76ms → 0.08s），否则"0.1s/2000 tokens 外推"会把
+ *  预检实测值四舍五入到看不出量级（真机预检正是 0.08s 这一档）。 */
+const fmtRefDur = (/** @type {number} */ ms) => {
+  const s = Number(ms) / 1000;
+  if (!Number.isFinite(s) || s < 0) return '？';
+  return s < 60 ? `${s.toFixed(2)}s` : fmtDur(ms);
+};
+
+/**
+ * 由**预检实测**外推本轮 prefill 耗时（纯函数，便于断言/变异）。
+ *
+ * 为什么是线性外推而不是照搬老文案：老文案对任何本地端点都说"prefill 可能需数分钟至数十分钟"，
+ * 而同一条预告的后半句又写着"参考 prefill 2000 tokens 0.08s"——**同一行自相矛盾**，
+ * 结果就是用户学会忽略这条告警（本次真机 04:13:27 的现场）。
+ *
+ * 判据（只认实测，不认规模）：
+ *   · 有 `probe.prefillMs`（预检测过固定参考 prefill）→ `prefillMs × 本轮tokens / 参考tokens`；
+ *   · 没有 → 返回 null，调用方**退回**保守文案（不可达 / 不可判定 / 未预检）。
+ * 外推的已知偏差（长上下文下引擎显著变慢）不由本函数掩盖——由调用方写进文案（见 PREFILL_LONGCTX_EVIDENCE）。
+ * @param {{ promptTokens: number, probe?: any }} input
+ * @returns {{ ms: number, refTokens: number, refMs: number, tokens: number }|null}
+ */
+export function prefillEstimateMs({ promptTokens, probe = null }) {
+  const p = Math.max(0, Math.round(Number(promptTokens) || 0));
+  const refMs = Number(probe?.prefillMs);
+  if (!(refMs > 0) || p <= 0) return null;
+  const refTokens = Number(probe?.prefillTokens) > 0 ? Number(probe.prefillTokens) : 2000;
+  return { ms: Math.round((refMs * p) / refTokens), refTokens, refMs, tokens: p };
+}
 
 const fmtTok = (/** @type {any} */ n) => Number(n || 0).toLocaleString('en-US');
 
 /**
  * 发送前的规模预告（纯函数，便于断言/变异）：把"这次要 prefill 多少"在**请求发出前**说出来。
  * 本地端点尤其重要——它既不提供 prefill 进度，首帧又可能是几十分钟。
+ *
+ * v0.6.13（问题 1 修法）：**有预检实测就必须由它推导**，并在文案里如实标注
+ * ①这是外推、②长上下文下外推会低估（附实测差值）；只有在**没有预检数据**时才退回保守文案。
  * @param {{ promptTokens: number, contextWindow?: number, isLocal?: boolean,
  *           firstTokenMs?: number, budget?: number, probe?: any }} input
- * @returns {{ text: string, warn: boolean, promptTokens: number, ratio: number }}
+ * @returns {{ text: string, warn: boolean, promptTokens: number, ratio: number, estimateMs: number|null }}
  */
 export function prefillForecast({ promptTokens, contextWindow, isLocal, firstTokenMs, budget, probe = null }) {
   const p = Math.max(0, Math.round(Number(promptTokens) || 0));
@@ -94,38 +155,97 @@ export function prefillForecast({ promptTokens, contextWindow, isLocal, firstTok
   const pct = Math.round(ratio * 100);
   const secs = Number(firstTokenMs) > 0 ? Math.round(Number(firstTokenMs) / 1000) : 0;
   const head = `📏 本轮上下文 ≈ ${fmtTok(p)} tokens${win ? `（${fmtTok(win)} 窗口的 ${pct}%）` : ''}${Number(budget) > 0 ? `，预算 ${fmtTok(budget)}` : ''}`;
-  const timing = isLocal
-    ? `本地端点：prefill 可能需数分钟至数十分钟（该端点不提供进度预告，只能等首帧）；首帧等待上限 ${secs}s（config.timeout.firstTokenMs）`
-    : `远程端点：首帧通常在数十秒内；首帧等待上限 ${secs}s（config.timeout.firstTokenMs）`;
-  // 两条告警线：占窗口 ≥80%（任何端点都危险），或本地端点 + prompt 规模 ≥ PREFILL_WARN_TOKENS。
+  const est = prefillEstimateMs({ promptTokens: p, probe });
+  const estNote = est ? `按预检 ${fmtRefDur(est.refMs)}/${fmtTok(est.refTokens)} tokens 外推，本轮 ≈${fmtDur(est.ms)}` : '';
+  // 三个分支（顺序即优先级）：
+  //   ① 有预检实测 → 报外推值 + **如实**说明长上下文会低估（附真机差值）；
+  //   ② 无预检数据（不可达/不可判定/未预检）→ 退回既有保守文案（真机 01:26 那次就是这一支）；
+  //   ③ 远程端点 → 各自一句。
+  const timing = est
+    ? `${isLocal ? '本地端点' : '远程端点'}：${estNote}` +
+      `（**线性外推**，只作量级参考——长上下文下引擎可能显著变慢：${PREFILL_LONGCTX_EVIDENCE}；` +
+      `外推低估时以首帧等待为准）；首帧等待上限 ${secs}s（config.timeout.firstTokenMs）`
+    : isLocal
+      ? `本地端点：prefill 可能需数分钟至数十分钟（该端点不提供进度预告，只能等首帧）；首帧等待上限 ${secs}s（config.timeout.firstTokenMs）`
+      : `远程端点：首帧通常在数十秒内；首帧等待上限 ${secs}s（config.timeout.firstTokenMs）`;
+  // 三条告警线：
+  //   · 占窗口 ≥80%：任何端点都危险（与 prefill 快慢无关，这是"上下文压力"）；
+  //   · **外推** prefill ≥ PREFILL_SLOW_WARN_MS：端点实测明显慢，依据 = 预检实测 × 本轮 tokens；
+  //   · 本地端点 + prompt ≥ PREFILL_WARN_TOKENS：**仅在拿不到预检数据时**兜底
+  //     （有实测就不再用规模猜——那正是"0.08s 的端点被说成需要数十分钟"的来源）。
   const hitRatio = ratio >= PREFILL_WARN_RATIO;
-  const hitLocal = Boolean(isLocal) && p >= PREFILL_WARN_TOKENS;
-  const warn = hitRatio || hitLocal;
+  const hitSlow = est != null && est.ms >= PREFILL_SLOW_WARN_MS;
+  const hitLocal = est == null && Boolean(isLocal) && p >= PREFILL_WARN_TOKENS;
+  const warn = hitRatio || hitSlow || hitLocal;
+  const why = hitRatio
+    ? `上下文已占窗口 ${pct}%（≥${Math.round(PREFILL_WARN_RATIO * 100)}%）`
+    : hitSlow
+      ? `按预检外推本轮 prefill ≈${fmtDur(est ? est.ms : 0)}（${est ? fmtRefDur(est.refMs) : '？'}/${est ? fmtTok(est.refTokens) : '？'} tokens × ${fmtTok(p)} tokens，≥${Math.round(PREFILL_SLOW_WARN_MS / 1000)}s 告警线）`
+      : `本地端点 + 上下文 ${fmtTok(p)} tokens（≥${fmtTok(PREFILL_WARN_TOKENS)}），且本次没有任何预检实测可外推`;
   const advice = warn
-    ? `\n   ⚠ ${hitRatio ? `上下文已占窗口 ${pct}%（≥${Math.round(PREFILL_WARN_RATIO * 100)}%）` : `本地端点 + 上下文 ${fmtTok(p)} tokens（≥${fmtTok(PREFILL_WARN_TOKENS)}）`}：` +
+    ? `\n   ⚠ ${why}：` +
       `建议缩小任务（新建会话、只给必要文件、先 /compact）或调大 config.timeout.firstTokenMs——` +
       `但注意调大它只会让"失败"更晚被发现，不会让 prefill 变快。`
     : '';
   // v0.6.13（A 追加）：把**端点预检**结果并进这条预告——"这个端点行不行"与"这次要 prefill 多少"
   // 必须一起出现在发送前，而不是等出事后翻日志（引擎实际加载的模型名与配置名不一致也在这里说）。
   const probeLine = probe && probe.note ? `\n   端点预检：${probe.note}` : '';
-  return { text: `${head}\n   ${timing}${probeLine}${advice}`, warn, promptTokens: p, ratio };
+  return { text: `${head}\n   ${timing}${probeLine}${advice}`, warn, promptTokens: p, ratio, estimateMs: est ? est.ms : null };
 }
 
 /**
- * 无进展中止文案（纯函数）：必须同时说清「多久没进展」「发生了什么」「下一步怎么办」。
- * @param {{ waitedMs: number, toolCalls?: number, modelRounds?: number, unproductive?: number }} input
+ * 无进展中止文案（纯函数）：必须同时说清「多久没进展」「发生了什么」「在等谁」「下一步怎么办」，
+ * 并且**与 capped/aborted 区分开**（v0.6.13 问题 4：真机上用户只看到一句"回合收尾"，
+ * 分不清"跑满了步数（可续跑）""我点了停止"和"再等下去也不会有新东西"）。
+ * @param {{ waitedMs: number, toolCalls?: number, modelRounds?: number, unproductive?: number,
+ *           pendingTool?: { name: string, ms: number }|null,
+ *           subagent?: { label?: string, modelRounds?: number, toolCalls?: number, at?: number }|null }} input
  */
-export function noProgressNotice({ waitedMs, toolCalls = 0, modelRounds = 0, unproductive = 0 }) {
+export function noProgressNotice({ waitedMs, toolCalls = 0, modelRounds = 0, unproductive = 0, pendingTool = null, subagent = null }) {
+  // v0.6.13（问题 3 附带修）：不足 1 分钟必须按**秒**说。原实现 Math.max(1, round(ms/60000)) 会把
+  // 600ms 说成"连续 1 分钟"——真机上子代理被掐时就谎报过"连续 1 分钟"（它其实一直在干活）。
   const min = Math.max(1, Math.round(Number(waitedMs) / 60000));
+  const howLong = Number(waitedMs) >= 60000 ? `${min} 分钟` : `${Math.max(1, Math.round(Number(waitedMs) / 1000))} 秒`;
   const extra = Number(unproductive) > 0 ? `——其中 ${Number(unproductive)} 次工具调用是**重复调用或失败**（没有产生任何新信息）` : '';
+  const waiting = pendingTool
+    ? `\n   ⏳ 中止时**正在等待工具 ${pendingTool.name}**（已 ${Math.round(Number(pendingTool.ms) / 1000)}s）` +
+      (subagent
+        ? `；该子代理最后进展：第 ${Number(subagent.modelRounds) || 0} 轮 / ${Number(subagent.toolCalls) || 0} 次工具调用` +
+          (Number(subagent.at) > 0 ? `（${Math.max(0, Math.round((Date.now() - Number(subagent.at)) / 1000))}s 前）` : '') +
+          '。子代理自己的看门狗会先于父回合中止它并回传原因；这里先响说明**连子代理也没有新进展**。'
+        : '。')
+    : '';
   return (
-    `⏹ 连续 ${min} 分钟没有任何工具调用、也没有新内容（模型请求 ${modelRounds} 轮、工具调用 ${toolCalls} 次${extra}），已中止。\n` +
-    `   常见原因：① 该端点/模型不做 function calling（tool_calls 恒为空）；② 本地引擎的 prefill 已停滞或内存吃紧；③ 上游连接还在但不再产出。\n` +
+    `⏹ 连续 ${howLong}没有任何工具调用、也没有新内容（模型请求 ${modelRounds} 轮、工具调用 ${toolCalls} 次${extra}），已中止。\n` +
+    `   ⓘ 这是**整轮零进展**（不是步数上限 capped、也不是你点的停止 aborted）：capped 的回合可以接着续跑，本条是"再等下去也不会产出新东西"。` +
+    waiting +
+    `\n   常见原因：① 该端点/模型不做 function calling（tool_calls 恒为空）；② 本地引擎的 prefill 已停滞或内存吃紧；③ 上游连接还在但不再产出。\n` +
     `   下一步：把任务拆小（新建会话、只给必要文件）或换支持工具调用的端点；阈值可调 config.noProgressTimeoutMs（默认 ${Math.round(DEFAULT_NO_PROGRESS_TIMEOUT_MS / 60000)} 分钟）。`
   );
 }
 
+/**
+ * 子代理因**父回合的截止时刻**收口时的文案（纯函数）。
+ *
+ * 为什么必须与 noProgressNotice 分开：真机现场（~/.mingdao/sessions/2026-10-09T02-42-31-qaaa.jsonl
+ * 第 28/29 行）两条 `task` 结果都写「连续 1 分钟没有任何工具调用」，而同一句话里又写着
+ * 「模型请求 15 轮、工具调用 18 次」——子代理**一直在干活**。原因是继承的截止时刻是
+ * spawn 那一刻的**绝对快照**，到点即掐，触发时又拿"子代理自己的最后进展"当等待时长，于是谎报。
+ * 修法：①截止时刻随父回合进展前移（不再掐正在干活的子代理）；②真到点时必须如实说
+ * "是父回合判定整轮无进展、不是子代理卡住"。
+ * @param {{ waitedMs?: number, toolCalls?: number, modelRounds?: number }} input
+ */
+export function inheritedStopNotice({ waitedMs = 0, toolCalls = 0, modelRounds = 0 }) {
+  const secs = Math.max(0, Math.round(Number(waitedMs) / 1000));
+  const ago = secs >= 60 ? `${Math.round(secs / 60)} 分钟` : `${secs} 秒`;
+  return (
+    `⏹ 父回合已判定**整轮无进展**，子代理随整棵子代理树一起收口，已中止。\n` +
+    `   子代理自身最后一次真实进展在 ${ago}前（模型请求 ${modelRounds} 轮、工具调用 ${toolCalls} 次）——` +
+    `即**不是子代理卡住**，而是父回合整体零进展（父回合没有把子代理的进展计为进展时就会走到这里）。\n` +
+    `   下一步：把子任务拆小、减少并行子代理数，或调大 config.noProgressTimeoutMs（默认 ${Math.round(DEFAULT_NO_PROGRESS_TIMEOUT_MS / 60000)} 分钟）。`
+  );
+}
+
 /**
  * 回合结束时的「0 次工具调用」提示（纯函数）。
  * 触发条件：**任务态**（用户消息含写/执行意图）或发了多轮请求，却一次工具调用都没有——
@@ -181,9 +301,10 @@ export function describeUpstreamError(/** @type {any} */ err) {
  * 进度行（纯函数）：web-server.log 与界面状态条**共用同一份文案**，口径不会漂移。
  * @param {{ phase?: string, elapsedMs: number, modelRounds?: number, toolCalls?: number,
  *           toolExecuted?: number, contentChars?: number, ttftMs?: number|null,
- *           pendingTool?: { name: string, ms: number }|null, tokensPerSec?: number|null }} p
+ *           pendingTool?: { name: string, ms: number }|null, tokensPerSec?: number|null,
+ *           subagent?: { label?: string, modelRounds?: number, toolCalls?: number, at?: number }|null }} p
  */
-export function formatTurnProgress({ phase, elapsedMs, modelRounds = 0, toolCalls = 0, toolExecuted = 0, contentChars = 0, ttftMs = null, pendingTool = null, tokensPerSec = null }) {
+export function formatTurnProgress({ phase, elapsedMs, modelRounds = 0, toolCalls = 0, toolExecuted = 0, contentChars = 0, ttftMs = null, pendingTool = null, tokensPerSec = null, subagent = null }) {
   const s = Math.max(0, Math.round(Number(elapsedMs) / 1000));
   const parts = [
     `已跑 ${Math.floor(s / 60)}m${String(s % 60).padStart(2, '0')}s`,
@@ -195,6 +316,16 @@ export function formatTurnProgress({ phase, elapsedMs, modelRounds = 0, toolCall
   if (tokensPerSec != null) parts.push(`≈${Number(tokensPerSec).toFixed(1)} tok/s`);
   parts.push(`已收正文=${contentChars} 字`);
   if (pendingTool) parts.push(`正在等待工具 ${pendingTool.name}（已 ${Math.round(Number(pendingTool.ms) / 1000)}s）`);
+  // v0.6.13（问题 3）：等 `task` 子代理时必须能看出"这个子任务跑到哪一步"——
+  // 否则"等子代理 620s"与"卡死 620s"在日志上完全同形（真机现场正是如此）。
+  if (subagent) {
+    const label = String(subagent.label || '').trim();
+    const ago = Number(subagent.at) > 0 ? Math.max(0, Math.round((Date.now() - Number(subagent.at)) / 1000)) : null;
+    parts.push(
+      `子代理${label ? `「${label}」` : ''}已跑 ${Number(subagent.modelRounds) || 0} 轮 / ${Number(subagent.toolCalls) || 0} 次工具调用` +
+        (ago != null ? `，最后进展 ${ago}s 前` : '')
+    );
+  }
   return parts.join(' · ');
 }
 
@@ -372,20 +503,36 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
       : { check: (/** @type {any} */ name, /** @type {any} */ args) => permission.check(name, args, '（子任务）') };
     // 自动路由：子代理固定走 executor 模型（便宜的执行单元）
     const subModel = subagentModel(cfg, modelName);
+    // v0.6.13（A）：子代理**继承父回合的无进展截止时刻**——24 个并行子代理各自跑几十分钟时，
+    // 父回合不该等它们把各自的看门狗超时跑完（真机实测：一个回合因此跑了 4+ 小时）。
+    // v0.6.13（问题 3 修法）：这个 `turnProgressDeadlineAt` **只是 spawn 时刻的快照兜底**；
+    // 真正的判据在子代理侧取 `parentProgress`（父回合的进度对象，**活的引用**）：
+    //   · 快照版的问题（真机 02:42–03:13）：子代理刚有进展（15 轮 / 18 次工具调用）也被
+    //     "父回合剩余时间"掐掉，而且触发时按子代理自己的最后进展算等待时长 → 谎报"连续 1 分钟"；
+    //   · 现在子代理每次真实进展都会回调父回合（onSubagentProgress）→ 父回合续期 →
+    //     父回合的 lastProgressAt 前移 → 子代理读到的截止时刻随之前移。**真在干活就不收口**。
     const subAgent = createAgent({
       provider,
       permission: subPermission,
       io: subIo,
       modelName: subModel,
       workingDir,
-      // v0.6.13（A）：子代理**继承父回合的无进展截止时刻**——24 个并行子代理各自跑几十分钟时，
-      // 父回合不该等它们把各自的看门狗超时跑完（真机实测：一个回合因此跑了 4+ 小时）。
       cfg: {
         ...cfg,
         contextBudget: Math.min(budget, 64000),
         ...(currentTurnProgress
           ? { turnProgressDeadlineAt: currentTurnProgress.lastProgressAt + currentTurnProgress.noProgressMs }
           : {}),
+        // 下面是 v0.6.13（问题 3）补的两项。**上面三行一个字都不动**：那个 spread 是 §139 与
+        // batch28 ⑥ 共同钉住的形状（改缩进/换写法会让既有变异变成"变异点未找到"——本轮实际踩到过），
+        // 而它现在的语义只当"spawn 时刻的快照兜底"，真正的判据是 parentProgress（活引用）。
+        ...(currentTurnProgress ? { parentProgress: currentTurnProgress } : {}),
+        ...(description ? { subagentLabel: description } : {}),
+        onSubagentProgress: (/** @type {any} */ info) => {
+          try {
+            currentTurnProgress?.onSubagentProgress?.(info);
+          } catch {}
+        },
       },
       undoStore: undo,
       maxSteps: SUBAGENT_MAX_STEPS,
@@ -423,11 +570,22 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
     }
     // v0.4.1：子代理空输出给主线程可用的失败信号（含 note 原因），而非笼统「无输出」——
     // 主智能体据此决定是否重试/换法，而非把子代理静默当作「已完成但没说话」。
+    // v0.6.13（问题 3）：把子代理**自己跑到哪一步**一并回传（轮次/工具调用/最后进展距今）——
+    // 真机上父回合只知道"在等 task 620s"，完全看不出子代理是在干活还是卡死；
+    // 而子代理被收口的**原因**（自己无进展 / 父回合整轮无进展）也必须原样带给父回合。
+    const subTp = /** @type {any} */ (/** @type {any} */ (subIo).turnProgress);
+    const subStat = subTp
+      ? `已跑 ${Number(subTp.modelRounds) || 0} 轮 / ${Number(subTp.toolCalls) || 0} 次工具调用` +
+        (Number(subTp.lastProgressAt) > 0 ? `，最后进展 ${Math.max(0, Math.round((Date.now() - Number(subTp.lastProgressAt)) / 1000))}s 前` : '') +
+        (subTp.stallCause === 'inherited' ? '（因父回合整轮无进展而收口）' : subTp.stalled ? '（子代理自身无进展而收口）' : '')
+      : '';
     const text =
       res.text ||
-      (res.truncated ? '（子任务达到步骤上限，未完成' : '（子任务无输出') +
-      (res.note ? '：' + res.note : '') + ')';
-    io.print(style(`  ↳ 子任务完成（${ms}ms）`, C.magenta));
+      `（子任务${res.stalled ? '被无进展看门狗中止' : res.truncated ? '达到步骤上限，未完成' : '无输出'}` +
+        (subStat ? `；${subStat}` : '') +
+        (res.note ? '：' + res.note : '') +
+        ')';
+    io.print(style(`  ↳ 子任务完成（${ms}ms${res.stalled ? '，被无进展看门狗中止' : ''}）`, C.magenta));
     return text;
   }
 
@@ -631,6 +789,10 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
       llmCalls: turnProgress.llmCalls,
       ttftMs: turnProgress.ttftMs,
       stalled: turnProgress.stalled,
+      // v0.6.13（问题 3/4）：stalled 的**原因**（'own' 自己零进展 / 'inherited' 父回合整轮零进展）——
+      // 前端与日志据此区分"子代理卡住"和"父回合没算子代理的进展"（真机上这两者被混成一句）。
+      stallCause: turnProgress.stallCause,
+      subagent: turnProgress.subagent,
       // v0.6.13（A）：收尾提示的**单一来源**（服务端直接取这条字符串，不再自己拼一遍文案）。
       // 注意：return 里的 perf() 先于 finally 求值，所以这里必须**惰性计算**（否则返回值里恒为 null，
       // 而日志/界面那边却已经打印过——同一事实两个说法，正是本项目反复栽过的那类不一致）。
@@ -678,8 +840,6 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
     // 快照挂在 io 上：WebUI 服务端（src/web/server.js）每 5s 读它下发状态条、每 30s 落一行日志。
     // 这里不改 web-io.js 的接口（它不在本次改动面内），字段是"只读约定"。
     const noProgressMs = resolveNoProgressTimeoutMs(cfg);
-    // 子代理共享父回合的"最迟进展时刻"：24 个并行子代理各跑几十分钟时，父回合不该等它们各自的超时。
-    const inheritedDeadline = Number(cfg.turnProgressDeadlineAt) > 0 ? Number(cfg.turnProgressDeadlineAt) : null;
     /** @type {any} */
     const turnProgress = {
       startedAt,
@@ -695,11 +855,15 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
       ttftMs: null,
       lastTtftMs: null,
       pendingTool: null,
+      // v0.6.13（问题 3）：当前正在跑的子代理快照（由 onSubagentProgress 刷新）——
+      // 界面/日志据此显示"在等哪个子任务、它跑到第几轮 / 几次工具调用"
+      subagent: null,
       forecast: null,
       noProgressMs,
       lastProgressAt: Date.now(),
       progressReason: '回合开始',
       stalled: false,
+      stallCause: null,
       note: null,
       zeroToolCalls: false,
     };
@@ -711,26 +875,66 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
     let noProgressFired = false;
     // 本回合的"调用签名 → 次数"：完全相同（name+args）的重复调用不算进展（见 finishTool）
     const turnSigCounts = new Map();
-    /** 中止原因（看门狗触发时写，供各处如实报告） */
+    /**
+     * 继承来的"整棵树一起收口"截止时刻——**每次都重新取**，不是 spawn 那一刻的快照。
+     *
+     * 真机 bug（02:42–03:13，`status=stalled`）：快照版把子代理的等待压到"父回合剩余时间"，
+     * 子代理刚有进展（会话记录里写着「模型请求 15 轮、工具调用 18 次」）就被掐掉，
+     * 且文案按子代理自己的最后进展算时长 → 谎报"连续 1 分钟没有任何工具调用"。
+     * 现在父回合的 lastProgressAt 会被子代理的进展续期（见 markProgress / onSubagentProgress），
+     * 于是这个截止时刻**只前移不倒退**：真在干活就不收口，真停了才一起收口。
+     */
+    const inheritedDeadlineAt = () => {
+      const snap = Number(cfg.turnProgressDeadlineAt) > 0 ? Number(cfg.turnProgressDeadlineAt) : 0;
+      const pp = /** @type {any} */ (cfg.parentProgress);
+      const live = pp && Number(pp.noProgressMs) > 0 && Number(pp.lastProgressAt) > 0 ? Number(pp.lastProgressAt) + Number(pp.noProgressMs) : 0;
+      const d = Math.max(snap, live);
+      return d > 0 ? d : null;
+    };
+    /**
+     * 看门狗到点。`cause` 必须如实区分（问题 3/4）：
+     *   · 'own'       —— 本回合自己连续 N 没有真实进展；
+     *   · 'inherited' —— 父回合已判定整轮无进展，子代理随整棵树收口（**不是**子代理卡住）。
+     */
+    // 触发原因由 armNoProgress 在**安排计时器前**写入（而不是当参数传进 fireNoProgress）：
+    // `noProgressTimer = setTimeout(fireNoProgress, left);` 这一行的形状被 §139 与 batch28 ① 共同钉住，
+    // 不能为了多带一个参数去改它（那会让既有变异验证变成"变异点未找到"——本轮实际踩到过）。
+    let noProgressCause = /** @type {'own'|'inherited'} */ ('own');
     const fireNoProgress = () => {
+      const cause = noProgressCause;
       noProgressFired = true;
       const waited = Date.now() - turnProgress.lastProgressAt;
       turnProgress.stalled = true;
-      turnProgress.phase = '已中止（无进展）';
+      turnProgress.stallCause = cause;
+      turnProgress.phase = cause === 'inherited' ? '已中止（父回合无进展）' : '已中止（无进展）';
       turnProgress.waitedMs = waited;
-      turnProgress.note = noProgressNotice({
-        waitedMs: waited,
-        toolCalls: turnProgress.toolCalls,
-        modelRounds: turnProgress.modelRounds,
-        unproductive: turnProgress.unproductive,
-      });
+      const pt = turnProgress.pendingTool;
+      turnProgress.note =
+        cause === 'inherited'
+          ? inheritedStopNotice({ waitedMs: waited, toolCalls: turnProgress.toolCalls, modelRounds: turnProgress.modelRounds })
+          : noProgressNotice({
+              waitedMs: waited,
+              toolCalls: turnProgress.toolCalls,
+              modelRounds: turnProgress.modelRounds,
+              unproductive: turnProgress.unproductive,
+              // 问题 4：必须说清"在等哪个工具、等了多久"，否则用户无从判断该调什么
+              pendingTool: pt ? { name: String(pt.name || ''), ms: Date.now() - Number(pt.startedAt || Date.now()) } : null,
+              subagent: turnProgress.subagent,
+            });
       try { io.print(style(turnProgress.note, C.yellow)); } catch {}
       try { currentAc?.abort(new Error(`无进展 ${Math.max(1, Math.round(waited / 60000))} 分钟，已中止`)); } catch {}
     };
     const armNoProgress = () => {
       if (noProgressTimer) clearTimeout(noProgressTimer);
-      // 子代理：以父回合的截止时刻为准（取更早的那个），保证整棵子代理树一起收口
-      const left = inheritedDeadline ? Math.min(noProgressMs, Math.max(1000, inheritedDeadline - Date.now())) : noProgressMs;
+      const ownDeadline = turnProgress.lastProgressAt + noProgressMs;
+      const inh = inheritedDeadlineAt();
+      // 正等子代理时给一点点宽限，保证**子代理自己的看门狗先响**并把原因回传父回合（见常量注释）。
+      const grace = turnProgress.subagent && turnProgress.pendingTool ? SUBAGENT_WAIT_GRACE_MS : 0;
+      // 继承的截止时刻只**提前**（"一整棵树一起收口"）；自己的判据之外只多那点宽限。
+      const useInherited = inh != null && inh < ownDeadline;
+      const target = useInherited ? inh : ownDeadline + grace;
+      const left = Math.max(1000, target - Date.now());
+      noProgressCause = useInherited ? 'inherited' : 'own';
       noProgressTimer = setTimeout(fireNoProgress, left);
       try { noProgressTimer.unref?.(); } catch {} // 不因为这个计时器拖住进程退出
     };
@@ -744,10 +948,46 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
       return turnProgress.zeroToolCallsNote;
     };
     /** 有真实进展才续期：工具结果返回 / 模型正文或推理增量。 */
+    let lastSubNotifyAt = 0;
     const markProgress = (/** @type {string} */ why) => {
-      turnProgress.lastProgressAt = Date.now();
+      const now = Date.now();
+      turnProgress.lastProgressAt = now;
       turnProgress.progressReason = why;
       armNoProgress();
+      // v0.6.13（问题 3 的核心修法）：**子代理的进展必须算父回合的进展**。
+      // 真机现场：父回合第 12 轮派出两个只读子代理，子代理在 10 分钟里跑了 15 轮 / 18 次工具调用
+      // （会话记录原文），父回合却只看得到"正在等待工具 task（已 620s）"→ 看门狗判"整轮无进展"
+      // 把父子一起掐了。父回合此刻并不能从工具结果里拿到任何中间信号，所以进展必须由子代理
+      // **主动回传**（onSubagentProgress）——父回合据此续期，并把快照挂到 turnProgress.subagent，
+      // 让界面/日志能写出"在等哪个子任务、它跑到第几轮"。
+      // 节流 1s：增量帧可能成百上千，父回合的续期只需"还在动"这个事实。
+      // 例外：**工具结果**是低频且高价值的进展信号（"子代理跑到第几步"就靠它），一律照原样回传。
+      const isToolStep = /^工具 /.test(why);
+      if (typeof cfg?.onSubagentProgress === 'function' && (isToolStep || now - lastSubNotifyAt >= 1000)) {
+        lastSubNotifyAt = now;
+        try {
+          cfg.onSubagentProgress({
+            label: String(cfg?.subagentLabel || ''),
+            modelRounds: turnProgress.modelRounds,
+            toolCalls: turnProgress.toolCalls,
+            reason: why,
+          });
+        } catch {}
+      }
+    };
+    /** 子代理进展 → 本回合续期 + 记录快照（供 UI/日志"在等哪个子任务、它到哪一步了"）。 */
+    turnProgress.onSubagentProgress = (/** @type {any} */ info) => {
+      const label = String(info?.label || '');
+      const rounds = Number(info?.modelRounds) || 0;
+      const calls = Number(info?.toolCalls) || 0;
+      // 只前进不后退：并行子代理里"后到的旧快照"不得把更靠前的进展覆盖回去
+      const prev = turnProgress.subagent;
+      if (!prev || rounds + calls >= (Number(prev.modelRounds) || 0) + (Number(prev.toolCalls) || 0)) {
+        turnProgress.subagent = { label, modelRounds: rounds, toolCalls: calls, at: Date.now(), reason: String(info?.reason || '') };
+      } else if (prev) {
+        prev.at = Date.now();
+      }
+      markProgress(`子代理进展${label ? `（${label}）` : ''}`);
     };
     armNoProgress();
     // ⚠ 两个 ctx，别混：

package/src/model-discovery.js

@@ -11,7 +11,7 @@ import path from 'node:path';
 import { mingdaoHome, ensureHome } from './config.js';
 import { PROVIDERS, MODELS } from './models.js';
 import { getStoredKey } from './credentials.js';
-import { isLocalBaseUrl } from './model-caps.js';
+import { isLocalBaseUrl, resolveModelCaps } from './model-caps.js';
 import { resolveProviderConfig } from './providers/index.js';
 
 const TTL_MS = 60 * 60 * 1000;
@@ -198,6 +198,17 @@ export async function probeEndpoint(/** @type {any} */ cfg, /** @type {string} *
       ttftBaselineMs: null,
       prefillBaselineMs: null,
       slowdown: null,
+      // v0.6.13（问题 2）：引擎自述上下文（本地端点读 GET /props）——读不到就是 null，**不猜**
+      engineCtx: null,
+      engineCtxSource: null,
+      engineProbed: false,
+      configuredWindow: (() => {
+        try {
+          return resolveModelCaps(cfg, modelName).contextWindow;
+        } catch {
+          return null;
+        }
+      })(),
       state: /** @type {string} */ ('unreachable'),
       error: /** @type {string|null} */ (null),
       note: '',
@@ -298,6 +309,37 @@ export async function probeEndpoint(/** @type {any} */ cfg, /** @type {string} *
       info.note = `❌ 不可达：${info.error}${info.isLocal ? '（本地引擎没起来？先确认端口/进程）' : ''}`;
       return info;
     }
+    // ⑤ 引擎自述上下文（v0.6.13 问题 2）：**本地端点**额外读一次 `GET /props`。
+    //    · 放在 chat 探测之后、结论拼装之前：chat 通不通与"引擎装得下多少"是两件事；
+    //    · 只打一次、只读不改（GET），失败/非 JSON/没有 n_ctx 一律视为"未读到"，绝不编造；
+    //    · llama.cpp 的 /props 挂在**根**上（`http://host:port/props`），而 baseUrl 通常带 `/v1`，
+    //      所以先试剥掉 `/v\d+` 的根路径，再退回 baseUrl 原样（兼容把 /props 挂在前缀下的网关）。
+    //    · **门槛**：只有引擎**自报了模型名**（`info.loadedModel`）才多打这一个请求。理由有两条：
+    //      ① llama.cpp 家族（含 llama-cpp-python/koboldcpp/LM Studio）总会在响应里回模型名/文件路径，
+    //         回不了名的多半是"只实现了 /v1/chat/completions"的网关或测试桩——它们不认识 /props；
+    //      ② 实测教训：`test/e2e-web.js` 的 mock 只按 POST+JSON body 解析（收到空 body 的 GET 会抛
+    //         `JSON.parse('')`），多打一个 GET 会把整条 e2e 打断——不认识 /props 的端点**一个字节都不该多发**。
+    //      跳过时结论里会写"跳过"（`engineContextNotice` 的 skipReason），不会假装核对过。
+    if (info.isLocal && info.loadedModel) {
+      info.engineProbed = true;
+      const strippedBase = base.replace(/\/v\d+$/, '');
+      const propsUrls = strippedBase !== base ? [`${strippedBase}/props`, `${base}/props`] : [`${base}/props`];
+      for (const u of propsUrls) {
+        try {
+          const res = await once(u, { method: 'GET', headers }, Math.min(5000, left()));
+          if (!res || !res.ok) continue;
+          const raw = String(await res.text()).slice(0, 65536);
+          const ctx = engineContextFromProps(JSON.parse(raw));
+          if (ctx != null) {
+            info.engineCtx = ctx;
+            info.engineCtxSource = u;
+            break;
+          }
+        } catch {
+          /* 读不到就跳过（端点没实现 /props、返回非 JSON、超时）——结论里会如实写"未读到" */
+        }
+      }
+    }
     info.ttftMs = median(info.ttftSamples);
     const n = info.toolCallRuns;
     info.toolState = n === 0 ? 'unknown' : info.toolCallHits === n ? 'stable-tools' : info.toolCallHits === 0 ? 'no-tools' : 'unstable-tools';
@@ -370,11 +412,21 @@ export async function probeEndpoint(/** @type {any} */ cfg, /** @type {string} *
               `agent 任务可能步数为 0，**不要**据此判定"不支持工具调用"`;
     const ttftNote = info.ttftMs != null ? `首帧 ${(info.ttftMs / 1000).toFixed(2)}s` : '首帧未测到';
     const prefillNote = info.prefillMs != null ? `参考 prefill ${prefillTokens} tokens ${(info.prefillMs / 1000).toFixed(2)}s` : `参考 prefill 未测到`;
+    // v0.6.13（问题 2）：引擎自述上下文 vs 配置——**必须在结论里**（界面 banner 与 web-server.log 都用这条 note）
+    const engineNote = engineContextNotice({
+      engineCtx: info.engineCtx,
+      configuredWindow: info.configuredWindow,
+      source: info.engineCtxSource,
+      probed: info.engineProbed,
+      isLocal: info.isLocal,
+      // 跳过的**具体**原因要写出来（否则"跳过"与"没读"分不清，等于没说）
+      skipReason: info.isLocal ? (info.loadedModel ? null : '该端点未自报模型名，不确认它实现 /props') : '非本地端点不预检 /props',
+    });
     const slowNote =
       (info.slowdown?.ttftRatio != null && info.slowdown.ttftRatio >= 3) || (info.slowdown?.prefillRatio != null && info.slowdown.prefillRatio >= 3)
         ? `\n   ⚠ 与上次预检相比明显变慢（首帧 ${info.ttftBaselineMs != null ? (info.ttftBaselineMs / 1000).toFixed(2) + 's → ' : '？'}${info.ttftMs != null ? (info.ttftMs / 1000).toFixed(2) + 's' : '？'}）：该端点**可能仍在处理上一个请求**（引擎 slot 被占/排队），建议重启引擎后再跑长任务。`
         : '';
-    info.note = `${toolNote} · ${ttftNote} · ${prefillNote}${info.partial ? ' ·（预检超过时间预算，样本未跑满）' : ''} · ${nameNote}${slowNote}`;
+    info.note = `${toolNote} · ${ttftNote} · ${prefillNote}${info.partial ? ' ·（预检超过时间预算，样本未跑满）' : ''} · ${nameNote} · ${engineNote}${slowNote}`;
     return info;
   })();
   probeInflight.set(key, run);
@@ -492,6 +544,79 @@ function prefillTokensLabel() {
   return '2000 tokens';
 }
 
+// ---------------------------------------------------------------------------
+// v0.6.13（问题 2）：**引擎自述上下文** vs **配置上下文**
+//
+// 真机证据（~/.mingdao/logs/web-server.log:229，2026-10-09T02:41:48）：
+//   chat 错误 t820945ac81c9ce5f [流式响应错误] insufficient memory: the request exceeded
+//   available GPU memory (sustained critical memory pressure during prefill … Reduce
+//   --context-window, close other apps, or try q8 KV quantization.
+// 而 ~/.mingdao/config.json 里 customModels.MLocalModel3.6.2.contextWindow = 131072，
+// 引擎（llama.cpp，127.0.0.1:60091）自述 n_ctx = 32768 —— 配置是引擎能力的 **4 倍**。
+// 后果：内核按 131072 推导预算（98,304），把 15,983 tokens 的 prompt 发给一个只装了 32k 的
+// 引擎，长上下文**在 prefill 阶段就被引擎直接拒绝**——此时换预设、调 contextBudget、
+// 调 timeout.firstTokenMs 全都无济于事（那些都改不了引擎的 n_ctx）。这正是负责人"换预设也没用"
+// 的根因，所以它必须在预检阶段就被读出来、并且**在日志与界面上各说一次**。
+//
+// 读法：llama.cpp 的 `GET /props` 返回 `default_generation_settings.n_ctx`（有的版本另有顶层
+// `n_ctx` / `n_ctx_train`）；其他引擎（vLLM 风格 / Ollama 风格 / 自研网关）能读多少读多少，
+// 读不到就**跳过并说明**（不猜、不编造、不把它当成"引擎不行"）。
+// ---------------------------------------------------------------------------
+
+/** 从引擎自述（/props 的 JSON）里抽"真实上下文窗口"（纯函数，便于断言/变异）。
+ *
+ *  候选字段按"越贴近引擎真实装载值越靠前"排序：
+ *    · llama.cpp /props：`default_generation_settings.n_ctx`（服务端实际 n_ctx）、顶层 `n_ctx`、`n_ctx_train`；
+ *    · vLLM 风格：顶层 `max_model_len`；
+ *    · 通用/自研：`context_length`、`model_info.*.context_length`（Ollama /api/show 的形态）。
+ *  一律要求**正整数**（0/负数/字符串/NaN 视为读不到）——绝不拿一个假值去和配置比。 */
+export function engineContextFromProps(/** @type {any} */ json) {
+  if (!json || typeof json !== 'object') return null;
+  const dgs = json.default_generation_settings || {};
+  const candidates = [
+    dgs.n_ctx,
+    json.n_ctx,
+    dgs.params?.n_ctx,
+    json.n_ctx_train,
+    json.max_model_len,
+    json.context_length,
+    json.model_info?.context_length,
+    ...Object.values(json.model_info || {}).map((/** @type {any} */ v) => v?.context_length),
+  ];
+  for (const c of candidates) {
+    const n = Number(c);
+    if (Number.isFinite(n) && n > 0) return Math.round(n);
+  }
+  return null;
+}
+
+/**
+ * 「引擎自述上下文 vs 配置」的**用户可见结论**（纯函数，日志/界面 banner/规模预告共用同一份文案）。
+ *
+ * 三态（不合并、不省略）：
+ *   · 读到了且配置 ≤ 引擎 → 明确说"一致"（用户才知道这条核对**做过**了）；
+ *   · 读到了且配置 > 引擎 → **警告**："配置超出引擎能力，长上下文将直接被引擎拒绝"，
+ *     并点明"换预设/调 contextBudget 都改不了引擎上限"（负责人现场正是卡在这里）；
+ *   · 没读到（端点不提供 /props、字段缺失、非本地端点或不确认实现 /props 而跳过）→ 如实说"未读到/跳过"，
+ *     **不**据此判定端点不行，也不假装核对过。
+ * @param {{ engineCtx?: number|null, configuredWindow?: number|null, source?: string|null, probed?: boolean, isLocal?: boolean, skipReason?: string|null }} input
+ */
+export function engineContextNotice({ engineCtx = null, configuredWindow = null, source = null, probed = false, isLocal = false, skipReason = null } = {}) {
+  const eng = Number(engineCtx) > 0 ? Math.round(Number(engineCtx)) : null;
+  const conf = Number(configuredWindow) > 0 ? Math.round(Number(configuredWindow)) : null;
+  const where = source ? `（读自 ${source}）` : '';
+  if (eng == null) {
+    if (!probed) {
+      return `引擎自述上下文：跳过（${skipReason || (isLocal ? '该端点未自报模型名，不确认它实现 /props' : '非本地端点不预检 /props')}）——无法核对配置的 ${conf ?? '？'} 是否超出引擎能力`;
+    }
+    return `引擎自述上下文：**未读到**（该端点不提供 /props 或其中没有 n_ctx/default_generation_settings.n_ctx 字段）——无法核对配置的 ${conf ?? '？'} 是否超出引擎能力`;
+  }
+  if (conf != null && conf > eng) {
+    return `⚠ 引擎自述上下文 ${eng} vs 配置 ${conf} —— 配置超出引擎能力，长上下文将直接被引擎拒绝${where}。换预设/调小 config.contextBudget 都**改不了引擎上限**：要么在引擎侧把上下文窗口调大（llama.cpp 的 --ctx-size / --context-window），要么把配置改成 ≤ ${eng}。`;
+  }
+  return `引擎自述上下文 ${eng} vs 配置 ${conf ?? '（未声明）'} —— 配置未超出引擎能力${where}`;
+}
+
 export function modelCacheFile() {
   return path.join(mingdaoHome(), 'model-cache.json');
 }

package/src/web/app.js

@@ -454,6 +454,9 @@ async function send(){
         if(ev.tokensPerSec!=null) bits.push('≈'+Number(ev.tokensPerSec).toFixed(1)+' tok/s');
         if(ev.contentChars) bits.push('正文 '+ev.contentChars+' 字');
         if(ev.pendingTool) bits.push('等待工具 '+ev.pendingTool.name+' 已 '+Math.round((ev.pendingTool.ms||0)/1000)+'s');
+        // v0.6.13（问题 3）：等 `task` 子代理时把**子代理自己的进度**摆出来——
+        // 真机现场界面/日志只有"等待工具 task 已 620s"，与"卡死 620s"完全同形。
+        if(ev.subagent) bits.push('子 Agent'+(ev.subagent.label?'「'+ev.subagent.label+'」':'')+'已跑 '+(ev.subagent.modelRounds||0)+' 轮 / '+(ev.subagent.toolCalls||0)+' 次工具调用'+(ev.subagent.ms!=null?'（最后进展 '+Math.round(ev.subagent.ms/1000)+'s 前）':''));
         if(ev.stalled) bits.push('已判定无进展，正在中止');
         think.textContent='💭 正在工作 '+Math.floor(p/60)+' 分 '+Math.round(p%60)+' 秒 · 第 '+msg._steps+' 回合 · '+curPhase+' · '+bits.join(' · ')+'…';
         renderWorkStatus(); }
@@ -474,7 +477,23 @@ async function send(){
         // 这里把作废的确认收掉：该确认已经死了，界面上不该再留一个能点的假弹窗。
         if(/权限确认超时/.test(String(ev.message||''))) dismissAskModals();
         const d=document.createElement('div'); d.className='errline'; d.textContent=ev.message; msg.appendChild(d); scroll(); }
-      else if(ev.type==='done'){ console.log('[MingDao] done 事件：session=' + ev.session); onActivity(); if(ev.budget){ const b=ev.budget; if(hintTextEl) hintTextEl.textContent='预算 '+Math.round(b.used/1000)+'K/'+Math.round(b.total/1000)+'K（'+Math.round(b.used/b.total*100)+'%）· 本轮完成 · 提示栏右侧为今日费用与命中率'; } refreshStatusBar(); if(ev.stats&&ev.stats.deliverables&&ev.stats.deliverables.length){ const card=document.createElement('div'); card.className='deliver'; card.innerHTML='<div class="t">📦 交付物（'+ev.stats.deliverables.length+' 个文件）</div>'+ev.stats.deliverables.map(f=>'<div class="i">'+esc(f)+(f.toLowerCase().endsWith('.html')?' <span style="color:var(--accent2)">— 浏览器打开即可运行</span>':'')+'</div>').join(''); msg.appendChild(card); } if(ev.note){ const d=document.createElement('div'); d.className='errline'; d.style.color='var(--warn)'; d.textContent=ev.note; msg.appendChild(d); } currentSession=ev.session; update(); refreshSessions(); updateTasksPanel(); }
+      else if(ev.type==='done'){
+        // v0.6.13（问题 4）：把**结局**写进控制台。桌面壳的日志就是渲染进程的 console（转存到
+        // ~/Library/Application Support/mingdao-desktop/logs/mingdao.log），此前那里只有
+        // 「回合收尾：generating=false，按钮恢复发送」——同一时刻内核写的是 `status=stalled`，
+        // 事后取证完全对不上（真机 2026-10-09T03:13:16 两条日志并列就是证据）。
+        const endStatus=ev.stalled?(ev.stallCause==='inherited'?'stalled(父回合整轮无进展)':'stalled(长时间无进展)'):ev.aborted?'aborted':(ev.truncated?'capped':'done');
+        console.log('[MingDao] done 事件：session=' + ev.session + ' status=' + endStatus + ' durationMs=' + (ev.durationMs||0));
+        onActivity();
+        if(ev.budget){ const b=ev.budget; if(hintTextEl) hintTextEl.textContent='预算 '+Math.round(b.used/1000)+'K/'+Math.round(b.total/1000)+'K（'+Math.round(b.used/b.total*100)+'%）· 本轮完成 · 提示栏右侧为今日费用与命中率'; }
+        refreshStatusBar();
+        if(ev.stats&&ev.stats.deliverables&&ev.stats.deliverables.length){ const card=document.createElement('div'); card.className='deliver'; card.innerHTML='<div class="t">📦 交付物（'+ev.stats.deliverables.length+' 个文件）</div>'+ev.stats.deliverables.map(f=>'<div class="i">'+esc(f)+(f.toLowerCase().endsWith('.html')?' <span style="color:var(--accent2)">— 浏览器打开即可运行</span>':'')+'</div>').join(''); msg.appendChild(card); }
+        // v0.6.13（问题 4）：stalled 必须**用户可见**，而且与 capped/aborted 区分开（复用既有 done.note 渲染）。
+        // 内核已发了一条同文案的告警 banner（服务端 `if (r.stalled) send({type:'banner'…})`），
+        // 这里再在消息下方留一条——用户滚动回看时不必去翻日志才知道"这轮为什么停了"。
+        if(ev.stalled){ const d=document.createElement('div'); d.className='errline'; d.style.color='var(--warn)'; d.textContent='⏹ 本轮因长时间无进展已中止（不是步数上限 capped、也不是你点的停止 aborted）——'+(ev.note||'详情见上方告警条。'); msg.appendChild(d); }
+        else if(ev.note){ const d=document.createElement('div'); d.className='errline'; d.style.color='var(--warn)'; d.textContent=ev.note; msg.appendChild(d); }
+        currentSession=ev.session; update(); refreshSessions(); updateTasksPanel(); }
     });
   }catch(e){ onActivity(); // 诊断（v0.4.2 network error 排查）：静默中断此前无任何日志，无法区分
     // 「手点停止 / 看门狗 / fetch 流静默断裂」。v0.4.3 修：第二参改 JSON 字符串——Electron 日志

package/src/web/server.js

@@ -24,7 +24,7 @@ import { createApiDispatch } from './routes/api.js';
 import { ensureHome, loadConfig, saveConfig, mingdaoHome } from '../config.js';
 import { setStoredKey, removeStoredKey, getStoredKey, maskKey } from '../credentials.js';
 import { availableModels, fetchProviderModels, providerHasKey, probeEndpoint, adaptiveTimeouts } from '../model-discovery.js';
-import { isLocalBaseUrl } from '../model-caps.js';
+import { isLocalBaseUrl, resolveModelCaps } from '../model-caps.js';
 import { createProvider, resolveProviderConfig, helperProvider, resolveVisionSupport } from '../providers/index.js';
 import { MODELS, modelPreset, PROVIDERS } from '../models.js';
 import { routeTask, routingConfig } from '../routing.js';
@@ -314,9 +314,22 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken,
     let probe = null;
     try {
       probe = await probeEndpoint(cfg, m, { timeoutMs: 15000 });
+      // v0.6.13（问题 2）：这行日志此前用 `probe.toolCalls` 判工具支持——该字段**从来不存在**
+      // （真机日志里恒为 `tools=未知`，见 web-server.log:48/169/303），预检结论等于没落日志。
+      // 现在取真实的四态 toolState，并把**引擎自述上下文 vs 配置**也写进来。
+      const toolText =
+        probe.toolState === 'stable-tools'
+          ? `支持（${probe.toolCallHits}/${probe.toolCallRuns}）`
+          : probe.toolState === 'unstable-tools'
+            ? `不稳定（${probe.toolCallHits}/${probe.toolCallRuns}）`
+            : probe.toolState === 'no-tools'
+              ? `不返回 tool_calls（${probe.toolCallHits}/${probe.toolCallRuns}）`
+              : '未知/不可判定';
       srvlog(
         `预检 ${m} ${probe.state} ttft=${probe.ttftMs == null ? 'n/a' : Math.round(probe.ttftMs) + 'ms'} ` +
-          `tools=${probe.toolCalls === true ? '支持' : probe.toolCalls === false ? '未返回' : '未知'} endpoint=${probe.endpoint || '（无）'}`
+          `prefill2000=${probe.prefillMs == null ? 'n/a' : Math.round(probe.prefillMs) + 'ms'} ` +
+          `tools=${toolText} endpoint=${probe.endpoint || '（无）'} ` +
+          `引擎自述上下文=${probe.engineCtx == null ? '未读到' : probe.engineCtx} 配置=${probe.configuredWindow ?? '？'}`
       );
     } catch (/** @type {any} */ e) {
       srvlog(`预检 ${m} 失败（忽略，按默认超时继续）：${String(e?.message || e)}`);
@@ -547,6 +560,9 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken,
             ttftMs: tp.ttftMs ?? null,
             tokensPerSec: decodeS && tp.contentTokens ? tp.contentTokens / decodeS : null,
             pendingTool: tp.pendingTool ? { name: tp.pendingTool.name, ms: Date.now() - tp.pendingTool.startedAt } : null,
+            // v0.6.13（问题 3）：等 `task` 子代理时把子代理自己的进度也写进日志——
+            // 真机现场只有"正在等待工具 task（已 620s）"，看不出子代理是在干活还是卡死。
+            subagent: tp.subagent ?? null,
           })
       );
     };
@@ -572,6 +588,10 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken,
           contentChars: tp?.contentChars ?? 0,
           tokensPerSec: decodeS && tp?.contentTokens ? Number((tp.contentTokens / decodeS).toFixed(1)) : null,
           pendingTool: tp?.pendingTool ? { name: tp.pendingTool.name, ms: Date.now() - tp.pendingTool.startedAt } : null,
+          // v0.6.13（问题 3）：正在跑的子代理快照——界面状态条据此显示"子 Agent 已跑 N 轮 / M 次工具调用"
+          subagent: tp?.subagent
+            ? { label: tp.subagent.label ?? '', modelRounds: tp.subagent.modelRounds ?? 0, toolCalls: tp.subagent.toolCalls ?? 0, ms: tp.subagent.at ? Date.now() - tp.subagent.at : null }
+            : null,
           stalled: Boolean(tp?.stalled),
         });
       } catch {}
@@ -827,6 +847,31 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken,
             noProgressCfg: cfg.noProgressTimeoutMs,
           });
           send({ type: 'banner', text: `🔎 本地端点预检：${probe.note}` });
+          // v0.6.13（问题 2）：**配置超出引擎能力**必须是一条独立的告警 banner，而且要在开工前出现。
+          // 真机根因（web-server.log:229）：配置 contextWindow=131072，引擎（llama.cpp）自述 n_ctx=32768，
+          // 长上下文在 prefill 阶段被引擎直接拒绝（insufficient memory）；用户当时反复"换预设"无效——
+          // 因为预设只改 contextBudget，**改不了引擎的 n_ctx**。所以这条要说清"换预设也没用"。
+          try {
+            const capsNow = resolveModelCaps(cfg, runModel);
+            if (Number(probe.engineCtx) > 0 && Number(capsNow.contextWindow) > Number(probe.engineCtx)) {
+              send({
+                type: 'banner',
+                warn: true,
+                text:
+                  `⚠ 引擎自述上下文 ${probe.engineCtx} vs 配置 ${capsNow.contextWindow} —— 配置超出引擎能力，长上下文将直接被引擎拒绝` +
+                  `（真机现场报的是 insufficient memory / 显存不足）。换预设、调 config.contextBudget、调 timeout.* 都**改不了引擎上限**：` +
+                  `要么在引擎侧把上下文窗口调大（llama.cpp 的 --ctx-size / --context-window），要么把 customModels.${runModel}.contextWindow 改成 ≤ ${probe.engineCtx}。`,
+              });
+            } else if (probe.engineProbed && !(Number(probe.engineCtx) > 0)) {
+              // 真的读了却没读到 → 也要说一句（"读不到就跳过并说明"），否则用户会以为内核核对过引擎能力了。
+              // 条件是 engineProbed：压根没读（非本地端点 / 端点未自报模型名）时不刷这条噪音，
+              // 那种情形的原因已经写在 probe.note 的"引擎自述上下文：跳过（…）"里。
+              send({
+                type: 'banner',
+                text: 'ℹ 引擎自述上下文：未读到（该端点不提供 /props 或其中没有 n_ctx 字段）——无法核对配置是否超出引擎能力；不影响继续使用。',
+              });
+            }
+          } catch {}
           send({
             type: 'banner',
             text:
@@ -979,6 +1024,21 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken,
         const { resolveModelCaps, safeBudget } = await import('../model-caps.js');
         budgetInfo = { used, total: safeBudget(cfg, resolveModelCaps(cfg, runModel)) };
       } catch {}
+      // v0.6.13（问题 4）：**stalled 必须有用户可见的说明**。
+      // 真机现场：内核写了 `chat 发送 done … status=stalled`，而桌面壳日志里只有
+      // `[renderer] [MingDao] 回合收尾：generating=false，按钮恢复发送` —— 用户完全不知道
+      // 这一轮是"跑满了步数（可续跑）""我点了停止"还是"再等下去也不会有新东西"。
+      // 这里发一条**告警 banner**（与 done.note 同一份文案，单一来源就是 agent 的 r.note），
+      // 前端 renderBanner 直接渲染；done.note 仍照旧带上，两条通道都不丢。
+      if (r.stalled) {
+        send({
+          type: 'banner',
+          warn: true,
+          text:
+            `⏹ 本轮因**长时间无进展**已中止（不是步数上限 capped、也不是你点的停止 aborted）。\n` +
+            String(r.note || '').trim(),
+        });
+      }
       // v0.6.13（A）：**"0 次工具调用"必须出现在收尾里**——否则端点不返回 tool_calls 时，
       // 界面看起来一切正常（ok:true + 正文），实际一次工具都没调（"看起来在工作、其实什么都没做"）。
       const zeroNote = String(r.perf?.zeroToolCalls || '');
@@ -993,6 +1053,9 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken,
         truncated: r.truncated,
         aborted: r.aborted,
         stalled: Boolean(r.stalled),
+        // v0.6.13（问题 3/4）：stalled 的**原因**也一并下发——'inherited' = 父回合整轮零进展
+        //（子代理被一起收口），'own' = 本回合自己零进展。前端据此给出不同的处置建议。
+        stallCause: r.perf?.stallCause ?? null,
         perf: r.perf ? { llmCalls: r.perf.llmCalls ?? null, toolCalls: r.perf.toolCalls ?? null, ttftMs: r.perf.ttftMs ?? null, noToolCalls: Boolean(r.perf.noToolCalls) } : null,
         note: [baseNote, zeroNote].filter(Boolean).join('\n'),
         stats: io.stats(),