mingdao-harness 0.6.17 → 0.6.18

package/docs/CODE-SIGNING.md

@@ -6,7 +6,7 @@
 
 > 自动更新包的**来源签名**是**另一件事**（防"更新源被投毒"，不是防 SmartScreen），见 §五：
 > 代码已就位且判据 fail-closed，但**发布链路尚未接入**——默认档为 `warn-and-install`
-> （照旧安装，但 UI/日志明确写出"本次更新未验证来源签名"）。
+> （照旧安装，弹窗只给两行「未验证来源签名 + 怎么变严」，完整说明写进日志）。
 
 ---
 
@@ -102,9 +102,12 @@ macOS 作业的 `--mac dmg` 在检测到 `CSC_LINK` + Apple 凭证时自动完
 >
 > **本轮状态（诚实标注）**：代码已就位并 fail-closed，但**发布链路尚未接入签名**——
 > `desktop/gen-update-yml.mjs` 与服务器发布脚本都没有签名步骤，feed 里**没有** `.sig` 文件。
-> 因此客户端当前实际走的是**默认档 `warn-and-install`**：照旧安装，但在日志与 UI 里明确写出
-> 「**本次更新未验证来源签名**」。要让"没签名就拒绝"生效，发行方需要：① 按下面步骤接入签名；
-> ② 在客户端设 `MINGDAO_REQUIRE_UPDATE_SIGNATURE=1`（或改成默认值）。
+> 因此客户端当前实际走的是**默认档 `warn-and-install`**：照旧安装，弹窗给两行——
+> 「本次更新未验证来源签名（发布链路尚未接入签名）——已按默认策略安装。」+
+> 「高安全场景可设 `MINGDAO_REQUIRE_UPDATE_SIGNATURE=1` 拒绝无签名更新；详情见日志与官网。」
+> 完整解释（为什么无法用密码学证明来源、feed 被投毒时无法区分、不改配置与会话）写在**日志**里：
+> 桌面版 `<userData>/logs/mingdao.log` 的 `更新来源校验：…` 行。要让"没签名就拒绝"生效，发行方需要：
+> ① 按下面步骤接入签名；② 在客户端设 `MINGDAO_REQUIRE_UPDATE_SIGNATURE=1`（或改成默认值）。
 
 ### 5.1 为什么不是"再算一次 sha512"
 
@@ -154,7 +157,7 @@ node scripts/update-sign.mjs --verify desktop/dist/mingdao-setup-<ver>-x64.exe -
 | --- | --- | --- |
 | 有签名 + 验签通过 | `install` | 提示"来源签名校验通过（ed25519 · keyId=…）"，正常安装 |
 | **有签名 + 验签失败 / 拿不到证据** | `reject` | **一律拒绝**：UI"更新包来源不可信，已拒绝"+ 引导官网手动下载；并**关闭 `autoInstallOnAppQuit`**（否则退出应用时照样装） |
-| 无签名 + 默认 | `warn-and-install` | 照旧安装，但日志与 UI 都写明"**本次更新未验证来源签名**"、并说明当前发布链路没有签名步骤 |
+| 无签名 + 默认 | `warn-and-install` | 照旧安装；弹窗**两行**（"未验证来源签名…已按默认策略安装" + "可设 `REQUIRE=1` 拒绝；详情见日志与官网"），完整解释写进日志行 |
 | 无签名 + `MINGDAO_REQUIRE_UPDATE_SIGNATURE=1` | `reject` | fail-closed：发行方/高安全用户的开关 |
 
 **为什么不默认 reject**：当前发布链路还没有签名，默认 reject 等于一夜之间掐死所有存量用户的自动更新。

package/docs/CONFIG.md

@@ -552,6 +552,11 @@ API id，不参与 `modelLabels`（其条目仍带 `id`，等于自定义模型
   模型兜底 **32k**、远程兜底 **128k**。
 - **安全预算**：`contextBudget` 会被自动收紧到 `min(contextBudget, 窗口×75%, 窗口−maxOutput−余量)`，
   prompt 永不逼近窗口边缘（75% 舒适区以上 prefill 时间陡增）。
+- **按引擎自述 `n_ctx` clamp（v0.6.18 §3.74）**：预检（`GET /props`）读到引擎真实 `n_ctx` 后，
+  若预算超过 `n_ctx × 0.8`，**发请求前**就 clamp 到该上限并打印
+  `⚠ 引擎自述上下文 32768：config.contextBudget 131072 超过其 80%（26214），发请求前已自动 clamp …`。
+  这是为了避免"明知引擎装不下还照发"——那种请求只会在 prefill 阶段被 `insufficient memory` 拒绝。
+  想真正用更大上下文，必须调引擎侧 `--ctx-size`，改 `config.contextBudget` 只会被 clamp。
 - **边缘检测**：模型每轮上报真实 `prompt_tokens`，≥ 窗口 85% 时下一轮强制压缩历史（即使启发式
   计数低估也强制触发）。
 - **工具输出截断**：单条工具结果按 `窗口/16` 封顶（最少 2000 字），小窗口不再整条回灌大段代码。
@@ -729,6 +734,37 @@ request failed.` 同一错误此前在 60091 的 35B 上也出现过 → **不
   3. 临时把 `localConcurrency` 保持 `1`，并减少子代理数量（读只读子代理在本地模型下已不并行）；
   4. **不要**因为 `engine shed its caches and stays up` 去重启引擎——它没有崩；重启只会重新加载模型。
 
+#### 内存/显存不足时的自动降级重试（v0.6.18 §3.74）
+
+即使有串行化，本地引擎仍可能因**子代理并发 / 长解码 / 其他进程占显存**在 prefill 时拒绝请求：
+
+```
+insufficient memory: the request exceeded available GPU memory
+(sustained critical memory pressure during prefill; aborted before the allocator wall).
+The engine shed its caches and stays up; this request failed.
+```
+
+真机（v0.6.17，8081 qwen）当时上下文只有 ≈2,773 tokens、预算 32,768——**整回合却直接失败**。
+现在对**本地端点**（`isLocalBaseUrl` 为真，或 `customModels.<名>.local: true`）改为**一次**有界降级重试：
+
+| 动作 | 数值 |
+| --- | --- |
+| 压缩上下文预算 | 本回合 `contextBudget × 0.6`，**下限 4096**（例：32,768 → ~19,660） |
+| 降低输出上限 | 本回合 `maxOutputTokens × 0.5`（例：8,192 → 4,096） |
+| 串行化加强 | 该重试传 `localConcurrency: 1`（复用既有的 `acquireLocalSlot`），即便你配了 0/2 |
+| 重试次数 | **最多一次**；第二次仍失败即如实报错，绝不无限重试 |
+
+- **可见性**：界面与日志出现
+  `♻ 因本地引擎内存不足，已压缩上下文（32,768 → ~19,660）…并重试一次`；
+  回合成功时 `done.note` 追加压缩前后数值、重试次数与最终结果（`↩ 内存降级重试（1 次）…重试后成功`）。
+- **第二次仍失败**：回合失败，错误文案带压缩前后数值与具体建议——把 `config.contextBudget` 调到多少、
+  关闭其他占用显存的模型进程/并行会话、引擎侧调大 `--ctx-size` 或使用 q8 KV 量化。
+- **云端端点不重试**：云 API 的 507/容量问题不是本地上下文能改的，压缩重试只会多烧一次请求；
+  400/401/429 等非内存错误同样不触发该恢复。
+- **判据单一来源**：`isMemoryPressureError`（协议层：507 / `insufficient memory` / `memory_refusal` /
+  `allocator wall` / `engine shed its caches and stays up` / OOM 措辞）＋
+  `describeUpstreamError(err, { isLocal })` 的 `recoverableByShrinking` 才决定是否重试。
+
 ### 用本地模型测 harness（测试者步骤清单）
 
 > 这一段是**操作清单**，不是原理说明。按顺序做，能在几分钟内区分"端点不行"和"harness 不行"。

package/package.json

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

package/src/agent.js

@@ -8,7 +8,9 @@ import { compactConversation } from './compact.js';
 // 两个对象从此分开：内核 ctx（makeCtx() 的产物）只在循环内用；工具只拿到 makeToolCtx() 的白名单对象。
 import { buildToolSchemas, dispatch, makeToolCtx } from './tools/index.js';
 import { DEFAULT_MODEL, modelPreset } from './models.js';
-import { resolveModelCaps, safeBudget, EDGE_RATIO } from './model-caps.js';
+import { resolveModelCaps, safeBudget, EDGE_RATIO, isLocalBaseUrl } from './model-caps.js';
+// v0.6.18 §3.74：预检已读到引擎自述 n_ctx 时，**发请求前**按 n_ctx×0.8 clamp 预算（纯函数）。
+import { clampContextBudgetToEngine } from './model-discovery.js';
 import { makeTokenCounter } from './tokenizer.js';
 import { createHooks } from './hooks.js';
 import { createIO, style, C } from './ui.js';
@@ -18,7 +20,7 @@ import { redactSecrets } from './redact.js';
 import { checkCostGuard, costGuardConfig, todayCost, preflightBlockMessage, roundGuardAction } from './cost-guard.js';
 import { recordCacheStats, packDailyCost } from './cachestats.js';
 import { estimateCost, cacheSplit, isPeakHour } from './pricing.js';
-import { resolveProviderConfig, createProvider, localGateSnapshot, localConcurrencyLimit } from './providers/index.js';
+import { resolveProviderConfig, createProvider, localGateSnapshot, localConcurrencyLimit, isMemoryPressureError } from './providers/index.js';
 import { compileConstraints, checkPreTool, checkPostTool, checkOutput, blockedOutputText } from './constraints.js';
 import { createLedger, newRunId } from './ledger.js';
 import { registerEgressSink } from './net-guard.js';
@@ -77,6 +79,13 @@ export const DEFAULT_NO_PROGRESS_TIMEOUT_MS = 3600000;
  *  形态下多等 15s（相对默认 60 分钟是 0.4%），换"子代理自己的结论能回传父回合"。 */
 export const SUBAGENT_WAIT_GRACE_MS = 15000;
 
+/** 本地引擎内存不足时允许的**降级重试次数**（v0.6.18 §3.74）。
+ *
+ *  只允许一次：内存墙不是网络抖动——同一份大 prompt 重发只会再撞一次。第一次失败后
+ *  agent 会压缩上下文 + 输出减半 + 强制串行；第二次仍失败就如实报错，绝不无限重试。
+ *  抽成常量是为了让"最多一次"可被断言/变异钉住（不是散在 if 里的魔法值）。 */
+export const MAX_MEMORY_RETRIES = 1;
+
 /** 解析无进展阈值：非正/非有限一律回落默认（fail-safe，防"配置写 0 就静默失去看门狗"）。 */
 export function resolveNoProgressTimeoutMs(/** @type {any} */ cfg) {
   const v = Number(cfg?.noProgressTimeoutMs);
@@ -281,13 +290,20 @@ export function zeroToolCallNotice({ modelRounds, steps = 0, taskLike = false })
 /**
  * 上游/引擎错误的可操作解读（纯函数）：把「HTTP 400 + 一段 Jinja/模板报错」这类原文
  * 变成「原文 + 这是什么 + 该怎么办」。识别不出时 hint 为 null（**绝不改原文**）。
+ *
+ * v0.6.18 §3.74：额外返回 `recoverableByShrinking`——**只有本地端点**的内存/显存不足
+ * 才是"压缩上下文 + 降输出 + 串行重试一次"能救的；云端 API 的 507/内存报错不在此列
+ * （云端的容量/配额不是本地上下文能改的，对云 API 做压缩重试只会多烧一次请求）。
  * @param {any} err
- * @returns {{ message: string, hint: string|null, status: number|null }}
+ * @param {{ isLocal?: boolean }} [opts]
+ * @returns {{ message: string, hint: string|null, status: number|null, recoverableByShrinking: boolean }}
  */
-export function describeUpstreamError(/** @type {any} */ err) {
+export function describeUpstreamError(/** @type {any} */ err, opts = {}) {
   const raw = String(err?.message ?? err ?? '').trim();
   const status = Number(err?.status) > 0 ? Number(err.status) : null;
   const t = raw.toLowerCase();
+  const memoryPressure = isMemoryPressureError(err);
+  const recoverableByShrinking = Boolean(memoryPressure && opts?.isLocal === true);
   /** @type {string|null} */
   let hint = null;
   if (/jinja|template|no user query|parser for this template/.test(t)) {
@@ -321,7 +337,7 @@ export function describeUpstreamError(/** @type {any} */ err) {
   }
   // 上游原文可能很长（内核只保留前 400 字）：如实标注它被截断过，避免用户以为这就是全部
   const truncated = /…|\.\.\.$/.test(raw) || raw.length >= 380;
-  return { message: raw, hint: hint ? `💡 ${hint}${truncated ? '（上面的上游原文可能被截断）' : ''}` : null, status };
+  return { message: raw, hint: hint ? `💡 ${hint}${truncated ? '（上面的上游原文可能被截断）' : ''}` : null, status, recoverableByShrinking };
 }
 
 /**
@@ -436,7 +452,17 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
   const caps = resolveModelCaps(cfg, modelName);
   // safeBudget 恒用：即使用户显式 contextBudget 也套「窗口−输出−余量」上限与 75% 舒适区，
   // 防显式值撑爆窗口（本地模型窗口可能只有 32k/131k，用户却留了默认 128000）。
-  const budget = safeBudget(cfg, caps);
+  const safeB = safeBudget(cfg, caps);
+  // v0.6.18 §3.74（自适应上下文）：预检若已读到**引擎自述 n_ctx**，配置预算再大也没用——
+  // 发出去就会在 prefill 阶段被引擎以 insufficient memory 拒绝。这里在**创建 agent 时**
+  // （即第一次请求之前）就 clamp 到 n_ctx×0.8，并在第一回合开始前打印一条明确提示。
+  const budgetClamp = clampContextBudgetToEngine({
+    contextBudget: safeB,
+    configuredBudget: Number(cfg?.contextBudget) > 0 ? Number(cfg.contextBudget) : null,
+    engineCtx: cfg?.endpointProbe?.engineCtx ?? null,
+  });
+  const budget = budgetClamp.budget ?? safeB;
+  const budgetClampNotice = budgetClamp.clamped ? budgetClamp.notice : '';
   // maxOutput 也按窗口封顶：显式配超大 maxOutputTokens 时，prompt(预算)+output 仍不得越过窗口
   // （预算已按 caps.maxOutputTokens 留余量，但显式值可能更大——此处兜底，防服务端截断/拒绝）
   const maxOutput = Math.min(
@@ -480,6 +506,13 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
   // （CLI/REPL 每次派子代理都漏计；README 主推的「多方向并行调研」场景漏计最重）。
   // runTurn 开始时指向本轮 usage，finally 清空；runTurn 之外调用 spawnTask 时为 null（安全跳过）。
   let currentUsage = /** @type {any} */ (null);
+  // v0.6.18 §3.74：本回合的「内存降级重试」记录（runTurn 内写、runTurn 包装层读）与本回合
+  // 必须进 done.note 的提示（clamp 提示 / 压缩重试提示）。声明在 runTurn 之外，包装层才能把
+  // 这些提示统一追加到**每一条** return 路径上（runTurn 内部有十几个 return，逐条补会漏）。
+  let lastMemoryRecovery = /** @type {any} */ (null);
+  let turnNotes = /** @type {string[]} */ ([]);
+  /** clamp 提示每个 agent 只打一次（子代理各自持有一份，但只在各自第一回合出现）。 */
+  let clampNoticeShown = false;
   // v0.6.0 C1：当前回合的账本写入器（与 currentUsage 同款：runTurn 内赋值、finally 清空）。
   // 账本不可用/被关闭时它是 no-op，**绝不影响主流程**——与 writeAudit 同款容错。
   let turnLedger = /** @type {any} */ (null);
@@ -746,9 +779,16 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
     };
   }
 
-  async function runTurn(/** @type {any} */ messages) {
+  async function runTurnInner(/** @type {any} */ messages) {
     let steps = 0;
     let finish = null;
+    // v0.6.18 §3.74：本回合实际生效的 prompt 预算 / 输出上限——内存不足时**只在本回合内**
+    // 压小（contextBudget ×0.6、maxOutputTokens ×0.5），不写回用户配置。
+    let turnBudget = budget;
+    let turnMaxOutput = maxOutput;
+    /** 本回合已用掉的内存降级重试次数（上限 MAX_MEMORY_RETRIES，默认 1）。 */
+    let memoryRetries = 0;
+    lastMemoryRecovery = null;
     /** v0.6.3（M-16）：本回合是否出现过"上游提前关流"（回答可能不完整）。
      * 刻意不叫 truncated——既有 `truncated` 的含义是"步数兜底总结也失败了"，两者必须分开。 */
     let upstreamTruncated = false;
@@ -1163,7 +1203,7 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
           if (turnProgress.phase !== '已中止（无进展）') turnProgress.phase = '压缩上下文';
           const compacted = await compactConversation({
             messages,
-            budget,
+            budget: turnBudget,
             count,
             provider,
             executorModel: subagentModel(cfg, modelName),
@@ -1203,7 +1243,7 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
           }
         } catch {}
       }
-      const trimmed = trimMessages(messages, budget, count);
+      const trimmed = trimMessages(messages, turnBudget, count);
 
       // reasoning 回填防护（Kimi P0 修正）：带 tool_calls 的 assistant 消息必须「完整」回传
       // reasoning_content（DeepSeek thinking_mode 官方要求：后续请求含 tools 时缺/截断即 400，
@@ -1239,7 +1279,7 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
         if (g && Number(g.dailyLimitYuan) > 0 && g.action !== 'downgrade') {
           let promptTokens = 0;
           for (const m of sanitized) promptTokens += messageTokens(m, count);
-          const worst = estimateCost(activeModel, promptTokens, maxOutput, null, new Date());
+          const worst = estimateCost(activeModel, promptTokens, turnMaxOutput, null, new Date());
           // 判据本身抽到 cost-guard.js 的 preflightBlockMessage（v0.6.11 / P1-1 第一刀）：
           // 它能被单测逐条钉边界，而 runTurn 只负责"拿到数字 → 问判据 → 该拦就拦"。
           // 统计不可读 / 无价格数据时判据返回 null（不误拦、也不静默放行——主检查会告警）。
@@ -1332,7 +1372,7 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
             contextWindow: caps.contextWindow,
             isLocal: caps.isLocal,
             firstTokenMs: Number(cfg?.timeout?.firstTokenMs) > 0 ? Number(cfg.timeout.firstTokenMs) : effFirstTokenMs,
-            budget,
+            budget: turnBudget,
             probe: cfg?.endpointProbe || null,
             localBusy: Boolean(caps.isLocal && (gate.active > 0 || gate.queued > 0)),
             localActive: gate.active,
@@ -1358,9 +1398,12 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
           messages: sanitized,
           tools: toolsFor(readOnlyPhase, turnStrippedSet),
           temperature,
-          maxTokens: maxOutput,
+          maxTokens: turnMaxOutput,
           // MiniMax P0：仅当 activeModel 声明支持 reasoning 才发送（否则 400 终止回合）；'off' 显式禁用例外
           reasoningEffort: modelPreset(activeModel)?.supportsReasoning || reasoningEffort === 'off' ? reasoningEffort : undefined,
+          // v0.6.18 §3.74：发生过内存降级后，本回合后续请求**一律压回单并发**（即便用户把
+          // config.localConcurrency 配成 0/2）——provider 会把它传给 acquireLocalSlot。
+          ...(memoryRetries > 0 ? { localConcurrency: 1 } : {}),
           signal: ac.signal,
           // v0.6.15（§3.59 第 1 条）：本地端点串行化必须**在界面上可见**——
           // 排队时状态条/进度行写"排队等待本地端点（已串行化防内存压力）"，
@@ -1440,6 +1483,68 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
         // MacBook 本地 507 memory_refusal 根因（v0.4.5）：服务端内存拒绝不是「空输出」——
         // 直接终结合合并透出降级提示，不计入空轮、不注入续写重试（内存未释放必再 507，空烧请求）。
         const e = /** @type {any} */ (err);
+        // ---------------------------------------------------------------------------
+        // v0.6.18 §3.74：**本地引擎内存/显存不足 → 压缩上下文 + 降输出 + 强制串行，重试一次**
+        //
+        // 真机（v0.6.17，8081 qwen）：子代理并发/长解码导致显存峰值超限，引擎在 prefill 前拒绝，
+        // 整回合直接失败；而当时上下文只有 ≈2,773 tokens、预算 32,768——压小预算/输出上限后
+        // 极可能成功。这里不再立刻判失败，而是**只对本地端点**做一次有界降级重试：
+        //   · contextBudget ×0.6（下限 4k，避免压到连系统提示都放不下）；
+        //   · maxOutputTokens ×0.5（只用于本回合后续请求）；
+        //   · 该次重试传 localConcurrency=1（provider 的 acquireLocalSlot 会把并发上限压回 1）；
+        //   · 只重试一次：memoryRetryUsed 一旦置真，第二次失败就如实抛错（不无限重试）。
+        // 云端端点不在此列：云 API 的 507/容量问题不是本地上下文能改的，压缩重试只会多烧一次请求。
+        // ---------------------------------------------------------------------------
+        let localEndpoint = false;
+        try {
+          // 用**本回合实际使用**的模型判本地：费用护栏可能把 activeModel 降级到云端模型，
+          // 此时不能拿原始 modelName 的 caps.isLocal 误判成"本地内存不足"。
+          const activeCaps = resolveModelCaps(cfg, activeModel);
+          const pcNow = resolveProviderConfig(cfg, activeModel);
+          localEndpoint = Boolean(activeCaps.isLocal || isLocalBaseUrl(pcNow?.baseUrl || provider?.config?.baseUrl || ''));
+        } catch {}
+        const localMemory = describeUpstreamError(e, { isLocal: localEndpoint });
+        if (localMemory.recoverableByShrinking) {
+          if (memoryRetries >= MAX_MEMORY_RETRIES) {
+            // 第二次仍失败：不掩盖，把压缩前后数值、重试次数、具体建议一起抛给用户/日志。
+            const rec = /** @type {any} */ (lastMemoryRecovery) || {};
+            const suggest = Math.max(4096, Math.floor(Number(rec.toBudget) > 0 ? Number(rec.toBudget) * 0.7 : 8192));
+            const detail =
+              `本地引擎内存不足：已压缩上下文（${fmtTok(rec.fromBudget)} → ~${fmtTok(rec.toBudget)}）、` +
+              `输出上限 ${fmtTok(rec.fromMaxOutput)} → ${fmtTok(rec.toMaxOutput)}，并重试 1 次（最多一次），仍失败——不再重试。` +
+              `建议：把 config.contextBudget 调到 ${fmtTok(suggest)} 左右（或更低），关闭其他占用显存的模型进程/并行会话，` +
+              `并在引擎侧调大 --ctx-size 或使用 q8 KV 量化。`;
+            try { io.print(style(`⚠ ${localMemory.message}\n   ${detail}`, C.yellow)); } catch {}
+            const enriched = new Error(`${localMemory.message}\n   ${localMemory.hint || ''}\n   ↩ ${detail}`);
+            /** @type {any} */ (enriched).status = e?.status ?? 507;
+            if (e?.headers !== undefined) /** @type {any} */ (enriched).headers = e.headers;
+            throw enriched;
+          }
+          memoryRetries += 1;
+          const fromBudget = turnBudget;
+          const fromMaxOutput = turnMaxOutput;
+          // 压缩比例 0.6、下限 4096：0.6 在真机 32,768 → ~19,660 的区间内足够把 KV cache 峰值压下来；
+          // 再低会伤任务质量，且 4k 以下连系统提示 + 一轮工具结果都放不下（重启永远失败）。
+          turnBudget = Math.max(4096, Math.floor(fromBudget * 0.6));
+          turnMaxOutput = Math.max(256, Math.floor(fromMaxOutput * 0.5));
+          lastMemoryRecovery = {
+            attempts: memoryRetries,
+            fromBudget,
+            toBudget: turnBudget,
+            fromMaxOutput,
+            toMaxOutput: turnMaxOutput,
+            at: Date.now(),
+          };
+          const msg =
+            `♻ 因本地引擎内存不足，已压缩上下文（${fmtTok(fromBudget)} → ~${fmtTok(turnBudget)}）、` +
+            `输出上限 ${fmtTok(fromMaxOutput)} → ${fmtTok(turnMaxOutput)}，并重试一次（串行化：并发上限 1）`;
+          try { io.print(style(msg, C.yellow)); } catch {}
+          turnNotes.push(msg);
+          turnProgress.phase = '内存降级重试（已压缩上下文）';
+          turnProgress.memoryRecovery = lastMemoryRecovery;
+          steps = Math.max(0, steps - 1); // 重试不额外消耗一步，避免 maxSteps=1 时根本没机会重试
+          continue;
+        }
         // v0.6.15（§3.59 第 2 条）：`engine shed its caches and stays up` / `allocator wall`
         // 说明引擎**活着**（自己丢缓存后继续服务）——不走这条"507 旧文案"（那里建议重启引擎，
         // 对活着但内存吃紧的引擎是错误处置）；交给下面 describeUpstreamError 的独立分型。
@@ -1552,7 +1657,7 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
         if (steps === stepLimit) {
           io.endTurn();
           if (res.text) {
-            const ap = await applyOutputConstraints(res.text, { messages, provider, activeModel, temperature, maxOutput, usage, signal: currentAc?.signal });
+            const ap = await applyOutputConstraints(res.text, { messages, provider, activeModel, temperature, maxOutput: turnMaxOutput, usage, signal: currentAc?.signal });
             messages.push({ role: 'assistant', content: ap.text });
             // 步数已耗尽：这一条与下方 `break`（→ 兜底总结/截断收尾）必须是同一口径
             markOutcome('capped', { capHit: true });
@@ -1907,7 +2012,7 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
         if (res.text) {
           // v0.5.0 A3 ③：输出前领域约束必须在**回填历史之前**应用——
           // 否则被拦下的违规措辞会留在会话里，下一轮又被当作既成事实喂回模型。
-          const ap = await applyOutputConstraints(res.text, { messages, provider, activeModel, temperature, maxOutput, usage, signal: currentAc?.signal });
+          const ap = await applyOutputConstraints(res.text, { messages, provider, activeModel, temperature, maxOutput: turnMaxOutput, usage, signal: currentAc?.signal });
           finalText = ap.text;
           outputNote = ap.note;
           messages.push({ role: 'assistant', content: finalText });
@@ -2080,7 +2185,7 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
           messages: wrapReq,
           tools: [],
           temperature,
-          maxTokens: Math.min(maxOutput, 2048),
+          maxTokens: Math.min(turnMaxOutput, 2048),
           reasoningEffort: modelPreset(activeModel)?.supportsReasoning ? 'low' : undefined,
           signal: currentAc.signal,
           onDelta(/** @type {any} */ d) {
@@ -2094,7 +2199,7 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
         }
         // v0.5.0 A3 ③：兜底总结同样过一遍输出约束
         const wrapApplied = wrapRes.text
-          ? await applyOutputConstraints(wrapRes.text, { messages, provider, activeModel, temperature, maxOutput, usage, signal: currentAc?.signal })
+          ? await applyOutputConstraints(wrapRes.text, { messages, provider, activeModel, temperature, maxOutput: turnMaxOutput, usage, signal: currentAc?.signal })
           : { text: null, note: null };
         if (wrapApplied.text) messages.push({ role: 'assistant', content: wrapApplied.text });
         // capHit：本轮因步数上限被迫收尾（任务可能未真正完成）→ 供上层落检查点续跑
@@ -2213,6 +2318,38 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
     }
   }
 
+  /**
+   * 回合包装层（v0.6.18 §3.74）：把「本回合必须让用户看见」的提示统一追加到 done.note。
+   *
+   * 为什么需要包装：`runTurnInner` 有十几个 return 路径（工具收尾、cap、stalled、aborted…），
+   * 逐条补 note 必漏。这里只做两件事：
+   *   ① 第一回合发请求前打印「按引擎 n_ctx clamp 预算」的提示（只打一次，避免每回合刷屏）；
+   *   ② 回合结束后把 clamp 提示与内存降级重试的**压缩前后数值 / 重试次数 / 最终结果**
+   *      追加到 `note`——WebUI 的 done.note、CLI 的收尾说明因此共用同一份口径。
+   */
+  async function runTurn(/** @type {any} */ messages) {
+    turnNotes = [];
+    if (budgetClampNotice && !clampNoticeShown) {
+      clampNoticeShown = true;
+      try { io.print(style(budgetClampNotice, C.yellow)); } catch {}
+      turnNotes.push(budgetClampNotice);
+    }
+    const r = await runTurnInner(messages);
+    const notes = turnNotes.filter(Boolean);
+    if (lastMemoryRecovery && r) {
+      const rec = lastMemoryRecovery;
+      const final = r.aborted ? '重试后被中断' : r.stalled ? '重试后无进展中止' : r.text ? '重试后成功' : '重试后仍无正文';
+      notes.push(
+        `↩ 内存降级重试（${Number(rec.attempts) || 1} 次）：上下文预算 ${fmtTok(rec.fromBudget)} → ${fmtTok(rec.toBudget)}、` +
+          `输出上限 ${fmtTok(rec.fromMaxOutput)} → ${fmtTok(rec.toMaxOutput)}；${final}。`
+      );
+    }
+    if (notes.length && r && typeof r === 'object') {
+      r.note = [r.note, ...notes].filter(Boolean).join('\n');
+    }
+    return r;
+  }
+
   return {
     modelName,
     budget,

package/src/model-discovery.js

@@ -866,6 +866,45 @@ export function engineContextNotice({ engineCtx = null, configuredWindow = null,
   return `引擎自述上下文 ${eng} vs 配置 ${conf ?? '（未声明）'} —— 配置未超出引擎能力${where}`;
 }
 
+// ---------------------------------------------------------------------------
+// v0.6.18 §3.74：**发请求前按引擎自述 n_ctx clamp 预算**
+//
+// 只"提示配置超出引擎能力"还不够：真机（v0.6.17，8081 qwen）配置 contextBudget=32768、
+// 引擎自述 n_ctx 也很小，请求照样发出去，然后整回合被 `insufficient memory` 拒绝。
+// 既然预检已经读到了 n_ctx，就在**发请求之前**把 prompt 预算压到 n_ctx×0.8 以下——
+// 明知会炸还发，等于把一次必然失败的 prefill 再烧一遍。
+//
+// 为什么留 20%：引擎的 n_ctx 是 prompt+输出/KV cache 的总窗口，输出上限、模板开销与
+// 并发请求都要占同一份窗口；贴着 n_ctx 发等于没有余量。0.8 与 PREFILL_WARN_RATIO 同口径。
+// ---------------------------------------------------------------------------
+
+/** 引擎自述 n_ctx 的预算占比（超过即 clamp）。 */
+export const ENGINE_BUDGET_RATIO = 0.8;
+
+/**
+ * 按引擎自述上下文 clamp prompt 预算（纯函数，便于断言/变异）。
+ *
+ * @param {{ contextBudget?: number|null, configuredBudget?: number|null, engineCtx?: number|null, ratio?: number }} [input]
+ * @returns {{ clamped: boolean, budget: number|null, from: number|null, to: number|null,
+ *             engineCtx: number|null, ceiling: number|null, ratio: number, notice: string }}
+ */
+export function clampContextBudgetToEngine({ contextBudget = null, configuredBudget = null, engineCtx = null, ratio = ENGINE_BUDGET_RATIO } = {}) {
+  const raw = Number(contextBudget) > 0 ? Math.floor(Number(contextBudget)) : null;
+  const confRaw = Number(configuredBudget) > 0 ? Math.floor(Number(configuredBudget)) : raw;
+  const eng = Number(engineCtx) > 0 ? Math.floor(Number(engineCtx)) : null;
+  const r = Number(ratio) > 0 && Number(ratio) < 1 ? Number(ratio) : ENGINE_BUDGET_RATIO;
+  const base = { clamped: false, budget: raw, from: raw, to: raw, engineCtx: eng, ceiling: null, ratio: r, notice: '' };
+  if (raw == null || eng == null) return base; // 没配置/没读到 n_ctx → 不猜、不 clamp
+  const ceiling = Math.max(1024, Math.floor(eng * r));
+  if (raw <= ceiling) return { ...base, ceiling };
+  const to = ceiling;
+  const notice =
+    `⚠ 引擎自述上下文 ${eng}：config.contextBudget ${confRaw} 超过其 ${Math.round(r * 100)}%（${ceiling}），` +
+    `发请求前已自动 clamp 上下文预算 ${raw} → ${ceiling}——否则长上下文会在 prefill 阶段被引擎直接拒绝` +
+    `（insufficient memory）。如需更大上下文，请在引擎侧调大 --ctx-size，而不是只改 config.contextBudget。`;
+  return { clamped: true, budget: to, from: raw, to, engineCtx: eng, ceiling, ratio: r, notice };
+}
+
 export function modelCacheFile() {
   return path.join(mingdaoHome(), 'model-cache.json');
 }

package/src/providers/index.js

@@ -11,7 +11,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { chat as openaiChat } from './openai-compatible.js';
+import { chat as openaiChat, isMemoryPressureError } from './openai-compatible.js';
+// 供 agent/model-discovery 与回归套件复用同一条「内存压力」判据（单一来源，避免各层各写一份正则）。
+export { isMemoryPressureError };
 import { modelPreset, providerPreset } from '../models.js';
 import { mingdaoHome } from '../config.js';
 import { resolveApiKey, getStoredKey } from '../credentials.js';
@@ -421,6 +423,11 @@ const sleep = (/** @type {any} */ ms, /** @type {any} */ signal) =>
   });
 
 function isTransient(/** @type {any} */ err) {
+  // v0.6.18 §3.74：内存/显存不足**不是瞬态网络抖动**——原样重发同一份大 prompt 只会再撞一次
+  // 内存墙（真机 8081：父回合 + 子代理并发 prefill）。这类错误交给 agent 做「压缩上下文 +
+  // 输出减半 + 强制串行」的一次性恢复；这里必须**不重试**，否则同回合会白烧 2 次请求
+  // （且 500+insufficient memory 会被 `status >= 500` 误判成瞬态）。
+  if (isMemoryPressureError(err)) return false;
   const status = err?.status;
   if (status === 429 || (status >= 500 && status <= 504)) return true;
   // 注意：不含 abort —— 用户 Ctrl+C 主动中断不应触发重试
@@ -511,7 +518,9 @@ export async function createProvider(/** @type {any} */ cfg, /** @type {any} */
           // 必须在**首 token 计时之前**排队：排队是内核自己的调度，不是"引擎迟迟不出首帧"。
           // 云端端点由 acquireLocalSlot 内部直接放行（不排队、不记日志、不加延迟）。
           releaseLocal = await acquireLocalSlot(pc.baseUrl, {
-            cfg,
+            // v0.6.18 §3.74：内存降级重试时 agent 传 localConcurrency=1，**临时把该端点压回单并发**
+            // （即便用户把 config.localConcurrency 配成 0/2）——重试期间不允许父回合/子代理再同时 prefill。
+            cfg: opts.localConcurrency != null ? { ...cfg, localConcurrency: opts.localConcurrency } : cfg,
             signal: ac.signal,
             onWait: opts.onQueueWait,
             endpoint: pc.name || pc.baseUrl,

package/src/providers/openai-compatible.js

@@ -17,9 +17,36 @@ function extractStreamError(/** @type {any} */ json) {
   /** @type {ApiError} */
   const e = new Error(`[流式响应错误${code ? ' ' + code : ''}] ${msg}`);
   if (code) e.status = code;
+  if (isMemoryPressureError(e)) /** @type {any} */ (e).memoryPressure = true;
   return e;
 }
 
+// 本地引擎「内存/显存不足」的判据（纯函数，v0.6.18 §3.74）：
+//   · HTTP 507（Insufficient Storage，llama.cpp / vLLM 的内存拒绝常用）；
+//   · 真机原文 `insufficient memory … aborted before the allocator wall` /
+//     `The engine shed its caches and stays up` / `memory_refusal`；
+//   · 中文本地引擎常见措辞（内存不足 / 内存拒绝 / 显存不足）；
+//   · 通用 OOM 措辞（CUDA out of memory / OOM）。
+// **只认"内存类"**：400/401/429 与普通 5xx 一律不命中——否则会把重试/压缩用在无意义的场景上。
+// 注意：这是**协议层**判据（有没有可能是内存问题）；「能不能压缩重试」还要叠加
+// `isLocalBaseUrl` —— 云 API 的 507 不压缩重试（见 agent.js 的 describeUpstreamError）。
+const MEMORY_PRESSURE_RE =
+  /insufficient memory|memory_refusal|allocator wall|engine shed its caches and stays up|out of memory|\boom\b|cuda.*memory|gpu memory|显存(?:不足|不够)|内存(?:不足|拒绝|不够)/i;
+
+/**
+ * 这次错误是否属于「本地引擎内存/显存不足」（纯函数）。
+ * @param {any} err
+ * @returns {boolean}
+ */
+export function isMemoryPressureError(/** @type {any} */ err) {
+  const status = Number(err?.status);
+  if (status === 507) return true;
+  const text = String(err?.message ?? err ?? '');
+  if (!text) return false;
+  if (MEMORY_PRESSURE_RE.test(text)) return true;
+  return Boolean(err?.memoryPressure);
+}
+
 export async function chat(/** @type {any} */ { baseUrl, apiKey, model, messages, tools, temperature, maxTokens, signal, onDelta, onActivity, includeUsage = true, responseFormat, reasoningEffort }) {
   const url = String(baseUrl).replace(/\/+$/, '') + '/chat/completions';
   const payload = /** @type {Record<string, any>} */ ({ model, messages });
@@ -76,6 +103,7 @@ export async function chat(/** @type {any} */ { baseUrl, apiKey, model, messages
     const e = new Error(`[${model}] API 错误 ${res.status}: ${detail}${hint}`);
     e.status = res.status;
     e.headers = res.headers; // 重试退避读取 Retry-After 用
+    if (isMemoryPressureError(e)) /** @type {any} */ (e).memoryPressure = true;
     throw e;
   }
 

package/src/web/app.js

@@ -203,7 +203,9 @@ let ctxLimit = 128000; // /api/state.contextBudget（上下文上限）
 let lastBudgetUsed = 0; // 上一回合 done.budget.used：生成中用"上一轮 used + 本轮字符估算"（诚实标 ≈）
 // 状态条的悬浮详情：最近一次工具 / 子 Agent / 本地队列 / 权限来源（不占常驻行）
 if ($('#runStrip')) attachTip($('#runStrip'), () => runState.detail || '运行状态：阶段 · 首帧 · 吞吐 · 上下文 · 工具步数 · 本轮费用');
-const sessionSubs=[]; // 本会话全部子代理（task 工具）条目：{seq, question, result, msg}
+const sessionSubs=[]; // 本会话全部子代理（task 工具）条目：{seq, question, result, msg, round, toolCalls, modelRounds, lastProgressAgoMs, status}
+let turnSeq=0; // 本会话的轮次序号（对话流一行摘要 / 右栏轨迹分组的同一键）
+let pendingSubagent=null; // 正在运行的 task 子代理快照（progress.subagent 刷新；任务完成后固化进 sessionSubs）
 // 回到底部悬浮按钮：滚动容器为 main；上滚超过 300px 时出现，点击平滑回底
 (function(){
   const scroller = document.querySelector('main');
@@ -234,16 +236,16 @@ function addReasoning(msg){ const d=document.createElement('details'); d.classNa
 function addUser(text){ const el=document.createElement('div'); el.className='msg-user'; el.innerHTML='<div class="bubble">'+esc(text)+'</div>'; chatEl.appendChild(el); renderEmptyState(); scrollBottom(); }
 
 const runningTools = new Map();
-// P1-1 工具时间线（v0.6.19 §3.70）：同一轮所有工具调用聚合成**一张**卡，节点复用不跳位。
-// 开始/完成只更新同一行（不再"删掉旧卡、在消息末尾重建一张"），结论顺序稳定；失败行红边高亮。
+// P1-1 工具时间线（v0.6.19 §3.70）保留为轨迹详情的渲染原语（toolStepNode/paintToolStep/
+// toolTimelineSummary）；§3.73 起对话流不再挂载内联卡——每轮只留一行摘要，详情进右栏/末尾区块。
 function renderToolStartEvent(ev){
-  timelineToolStart(activeAiMsg, ev);
+  traceToolStarted(activeAiMsg, ev);
 }
 function renderToolEvent(ev){
-  timelineToolDone(activeAiMsg, ev);
+  traceToolFinished(activeAiMsg, ev);
 }
 function renderToolDeniedEvent(ev){
-  timelineToolDenied(activeAiMsg, ev);
+  traceToolDenied(activeAiMsg, ev);
 }
 function renderTodos(todos,msg){
   const ul=document.createElement('ul'); ul.className='todo';
@@ -484,7 +486,7 @@ async function send(){
   attachments=[]; renderAttachments();
   addUser(text||(sentAttachments.map(a=>(a.type==='image'?'🖼 ':'📄 ')+a.name).join(' ')));
   const msg=newAiMsg(); const content=aiContent(msg); let raw='';
-  activeAiMsg=msg; msg._traj=[]; msg._steps=0; curSteps=0; curWorkT0=Date.now();
+  activeAiMsg=msg; msg._traj=[]; msg._steps=0; msg._round=++turnSeq; msg._startedAt=Date.now(); msg._endedAt=null; pendingSubagent=null; curSteps=0; curWorkT0=Date.now();
   // P0-1：本轮开始 → 运行状态条归零（上一轮的费用/首帧/工具数不许泄漏到本轮；上下文基数保留）
   runState.rawPhase='发请求（等首帧）'; runState.phase='等首帧'; runState.aborted=false;
   runState.ttftMs=null; runState.tokensPerSec=null; runState.toolCalls=0; runState.contentChars=0;
@@ -562,14 +564,18 @@ async function send(){
         if(ev.stalled) bits.push('已判定无进展，正在中止');
         runState.detail=bits.join(' · ');
         think.textContent='💭 正在工作 '+Math.floor(p/60)+' 分 '+Math.round(p%60)+' 秒 · 第 '+msg._steps+' 回合 · '+curPhase+' · '+bits.join(' · ')+'…';
-        renderWorkStatus(); }
+        renderWorkStatus();
+        // §3.73：子代理运行中随既有 progress.subagent 实时更新右侧/末尾那一行（不新增轮询）。
+        if (ev.subagent && pendingSubagent) pendingSubagent = mergeSubagentProgress(pendingSubagent, ev.subagent);
+        updateTraceSummary(activeAiMsg);
+        if (ev.subagent) renderSubagentSections(); }
       if(ev.type==='text'){ curPhase='模型输出中'; runState.rawPhase='解码中（收到增量）'; runState.phase='解码中'; runState.contentChars=raw.length; onActivity(); raw+=ev.delta; update(); }
       else if(ev.type==='reasoning'){ if(!reason){ reason=addReasoning(msg); reason.dataset.full=''; } if(!reason.parentElement.open) reason.parentElement.open=true; reason.parentElement.querySelector('summary').classList.add('live'); reason.dataset.full+=ev.delta; const full=reason.dataset.full; reason.textContent=(full.length>9000?full.slice(-9000)+'\n…（思考内容较长，仅显示末尾；已 '+full.length+' 字符）':full); reason.scrollTop=reason.scrollHeight; scroll(); }
       else if(ev.type==='turnStart'){ stepsCount+=1; curSteps+=1; msg._steps=curSteps; curPhase='模型推理中'; runState.rawPhase='发请求（等首帧）'; runState.phase='等首帧'; msg._traj.push({kind:'turn', t:Date.now()}); showThink(); think.textContent='💭 第 '+msg._steps+' 回合：模型推理中…'; renderWorkStatus(); scroll(); }
       else if(ev.type==='turnEnd'){ curPhase='回合完成，进入下一回合'; showThink(); think.textContent='⏸ 第 '+msg._steps+' 回合完成（累计 '+(ev.toolSteps||0)+' 工具步）· 进入下一回合…'; renderWorkStatus(); }
       else if(ev.type==='toolStart'){ stepsCount+=1; curSteps+=1; curPhase=ev.name==='task'?'子 Agent 执行中':'执行工具中'; runState.rawPhase=curPhase; runState.phase='执行工具'; msg._steps=curSteps; msg._traj.push({kind:'tool', seq:ev.seq, name:ev.name, args:ev.args, t:Date.now(), done:false}); onActivity(); update(); renderToolStartEvent(ev); renderWorkStatus(); }
       else if(ev.type==='code'){ onActivity(); const pre=document.createElement('pre'); pre.innerHTML='<code>'+highlight(ev.code,ev.lang)+'</code>'; insertBeforeActiveMsg(pre); scroll(); }
-      else if(ev.type==='tool'){ onActivity(); update(); runningTools.delete(ev.seq); const tj=msg._traj.find(x=>x.kind==='tool'&&x.seq===ev.seq); if(tj){ tj.done=true; tj.result=ev.result; tj.durationMs=ev.durationMs; } if(ev.name==='task'){ sessionSubs.push({seq:ev.seq, question:String(ev.args?.question||ev.args?.prompt||''), result:ev.result, durationMs:ev.durationMs, msg}); renderSubPanel(); } renderToolEvent(ev); }
+      else if(ev.type==='tool'){ onActivity(); update(); runningTools.delete(ev.seq); const tj=msg._traj.find(x=>x.kind==='tool'&&x.seq===ev.seq); if(tj){ tj.done=true; tj.result=ev.result; tj.durationMs=ev.durationMs; } renderToolEvent(ev); }
       else if(ev.type==='toolDenied'){ onActivity(); const tj=msg._traj.find(x=>x.kind==='tool'&&x.seq===ev.seq); if(tj){ tj.done=true; tj.denied=ev.reason||'未授权'; } renderToolDeniedEvent(ev); const d=document.createElement('div'); d.className='errline'; d.textContent='✖ '+(ev.reason==='未授权'||!ev.reason?'未授权':ev.reason)+'：'+ev.name; msg.appendChild(d); scroll(); }
       else if(ev.type==='banner'){ renderBanner(ev); }
       else if(ev.type==='ask'){ runState.rawPhase='等待权限确认'; runState.phase='执行工具'; update(); renderWorkStatus(); handleAskEvent(ev); }
@@ -618,7 +624,7 @@ async function send(){
     // 具体错误形态已进日志（fetch failed 等不再绕开续跑提示）。
     d.textContent=(e&&e.name==='AbortError')?(killedByWatchdog?'响应超时已中断（120 秒无任何响应），请重试':'已中断'):('连接中断，本轮未完成。已执行的工作已保存检查点——直接发送「继续」即可从断点续跑（' + Math.round((Date.now() - workT0) / 1000) + 's · ' + stepsCount + ' 步）。');
     msg.appendChild(d); scroll(); }
-  finally{ clearInterval(hintTimer); disarm(); clearTimeout(stopFallbackTimer); stopFallbackTimer=null; stopping=false; turnAbortCtrl=null; generating=false; setBtn(); curTaskId=null; curPhase='模型推理中'; console.log('[MingDao] 回合收尾：generating=false，按钮恢复发送'); hintEl.classList.remove('working'); if(hintTextEl) hintTextEl.textContent=defaultHint; pending=false; content.innerHTML=renderMarkdown(raw); attachTrajMeta(msg); activeAiMsg=null; curWorkT0=0; if(!runState.aborted){ runState.rawPhase='空闲'; runState.phase='空闲'; } else { runState.rawPhase='已中止'; runState.phase='已中止'; } renderWorkStatus(); scroll(); updateTasksPanel(); }
+  finally{ clearInterval(hintTimer); disarm(); clearTimeout(stopFallbackTimer); stopFallbackTimer=null; stopping=false; turnAbortCtrl=null; generating=false; setBtn(); curTaskId=null; curPhase='模型推理中'; console.log('[MingDao] 回合收尾：generating=false，按钮恢复发送'); hintEl.classList.remove('working'); if(hintTextEl) hintTextEl.textContent=defaultHint; pending=false; msg._endedAt=Date.now(); finalizePendingSubagent(msg); content.innerHTML=renderMarkdown(raw); attachTrajMeta(msg); renderTracePanels(); activeAiMsg=null; curWorkT0=0; if(!runState.aborted){ runState.rawPhase='空闲'; runState.phase='空闲'; } else { runState.rawPhase='已中止'; runState.phase='已中止'; } renderWorkStatus(); scroll(); updateTasksPanel(); }
 }
 
 let curTaskId=null; // 本轮 SSE 任务 id（质检 L1：主停止按钮只断本任务，不再误伤其他 tab）
@@ -1041,6 +1047,107 @@ function applyThemePreference(pref, deps) {
   return { pref: p, theme };
 }
 
+// —— 轨迹 / 子 Agent 视图（v0.6.21 §3.73；smoke §151 直接 eval 这段做行为断言） ——
+// 唯一统计口径：对话流每轮那一行摘要与右栏「轨迹」都走 traceRoundView / traceSummaryText，
+// 由 traceRoundForMsg 统一装配。**不允许**两处各算一套（§151 断言两处都调用同一函数）。
+function fmtTraceDur(ms) {
+  const total = Math.max(0, Math.round((Number(ms) || 0) / 1000));
+  if (total < 60) return total + 's';
+  const m = Math.floor(total / 60);
+  const s = total % 60;
+  if (m < 60) return m + 'm' + (s ? s + 's' : '');
+  const h = Math.floor(m / 60);
+  const rm = m % 60;
+  return h + 'h' + (rm ? rm + 'm' : '');
+}
+/** 子代理一行的视图：名称 · 轮次 · 工具次数 · 最后进展 · 状态（缺失字段如实显示 —，不编造）。 */
+function subagentRowView(sub) {
+  const s = sub || {};
+  const toolCalls = s.toolCalls == null || !Number.isFinite(Number(s.toolCalls)) ? null : Math.max(0, Math.round(Number(s.toolCalls)));
+  const modelRounds = s.modelRounds == null || !Number.isFinite(Number(s.modelRounds)) ? null : Math.max(0, Math.round(Number(s.modelRounds)));
+  const ago = s.lastProgressAgoMs == null || !Number.isFinite(Number(s.lastProgressAgoMs)) ? null : Math.max(0, Math.round(Number(s.lastProgressAgoMs)));
+  const running = Boolean(s.running);
+  const failed = !running && (s.status === 'failed' || Boolean(s.result && s.result.ok === false));
+  const status = running ? 'running' : failed ? 'failed' : 'done';
+  const round = Math.max(0, Math.round(Number(s.round) || 0));
+  return {
+    key: 'sub:' + String(s.seq == null ? '?' : s.seq),
+    seq: s.seq,
+    round,
+    roundText: round ? '第 ' + round + ' 轮' : '—',
+    name: String(s.label || s.description || s.question || '子代理').slice(0, 80),
+    question: String(s.question || ''),
+    toolCalls,
+    toolText: toolCalls == null ? '工具次数 —' : toolCalls + ' 次工具',
+    modelRounds,
+    roundsText: modelRounds == null ? '自身轮次 —' : modelRounds + ' 轮',
+    progress: ago == null ? '最后进展 —' : '最后进展 ' + (ago < 1000 ? '<1s' : Math.round(ago / 1000) + 's') + ' 前',
+    status,
+    statusText: running ? '运行中' : failed ? '失败' : '完成',
+    statusCls: running ? 'run' : failed ? 'bad' : 'ok',
+    running,
+    durationMs: s.durationMs == null ? null : Number(s.durationMs),
+    result: s.result,
+  };
+}
+/** 一轮的完整视图（工具步 + 子代理 + 摘要文案）；对话流与右栏消费同一个对象。 */
+function traceRoundView(round) {
+  const r = round || {};
+  const now = Number(r.now) || Date.now();
+  const tools = (r.tools || []).map((t) => toolStepView(t, t.done));
+  const subs = (r.subs || []).map(subagentRowView);
+  const started = Number(r.startedAt) || 0;
+  const ended = r.endedAt != null ? Number(r.endedAt) : now;
+  const durationMs = started ? Math.max(0, ended - started) : 0;
+  const durationText = started ? fmtTraceDur(durationMs) : '';
+  const parts = ['本轮 ' + tools.length + ' 次工具调用'];
+  if (subs.length) parts.push(subs.length + ' 个子代理');
+  if (durationText) parts.push(durationText);
+  return {
+    round: Math.max(0, Math.round(Number(r.round) || 0)),
+    tools,
+    subs,
+    toolCount: tools.length,
+    subCount: subs.length,
+    failed: tools.filter((t) => t.failed).length,
+    durationMs,
+    durationText,
+    summary: parts.join(' · '),
+  };
+}
+function traceSummaryText(view) { return String((view && view.summary) || ''); }
+/** 每轮的数据装配：只读 msg._traj 与传入的 sessionSubs/pending，不读 runState、不另算。 */
+function traceRoundData(msg, subs, pending, now) {
+  const m = msg || {};
+  const round = Math.max(0, Math.round(Number(m._round) || 0));
+  const tools = (m._traj || []).filter((t) => t.kind === 'tool');
+  const list = (subs || []).filter((s) => s && (s.msg === msg || (round && Number(s.round) === round)));
+  if (pending && pending.msg === msg && pending.running && !list.some((s) => s.seq != null && s.seq === pending.seq)) list.push(pending);
+  return { round, startedAt: m._startedAt, endedAt: m._endedAt, now, tools, subs: list };
+}
+/** 子代理运行中的实时快照（progress 事件已有字段；不新增轮询）。 */
+function mergeSubagentProgress(pending, sub) {
+  if (!pending || !sub) return pending;
+  const toolCalls = sub.toolCalls != null ? Number(sub.toolCalls) : pending.toolCalls;
+  const modelRounds = sub.modelRounds != null ? Number(sub.modelRounds) : pending.modelRounds;
+  return Object.assign({}, pending, {
+    toolCalls: Number.isFinite(toolCalls) ? toolCalls : pending.toolCalls,
+    modelRounds: Number.isFinite(modelRounds) ? modelRounds : pending.modelRounds,
+    lastProgressAgoMs: sub.ms != null ? Number(sub.ms) : pending.lastProgressAgoMs,
+    label: String(sub.label || pending.label || '子代理'),
+    running: true,
+    status: 'running',
+  });
+}
+/** 窄窗口（<1180 右栏收起）且右栏不可见时，轨迹落到对话流末尾的可折叠区块。 */
+function traceDockVisible(width, panelVisible) {
+  return layoutClassesFor(width).narrowRun && !panelVisible;
+}
+/** 点摘要时的定位目标：窄屏 → 末尾区块；宽屏/抽屉已开 → 右侧面板。 */
+function traceFocusTarget(width, panelVisible) {
+  return traceDockVisible(width, panelVisible) ? 'dock' : 'panel';
+}
+
 // —— 窄屏断点：<900 侧栏收起；<1180 右栏收起（同一判据供 initResponsive 与断言使用） ——
 function layoutClassesFor(width) {
   const w = Number(width) || 0;
@@ -1060,6 +1167,12 @@ let workingDirCache = '';
 let compactAvailable = false; // Web 端当前没有 /api/compact；为 true 时才显示压缩入口
 let runPanelOpen = false;
 let responsiveInitialized = false;
+// —— 轨迹收纳状态（§3.73）：两个折叠区 + 展开过的轮次/工具/子代理（重渲染后保持展开） ——
+const traceFoldState = { trace: true, subs: true };
+const openTraceRounds = new Set();
+const openTraceTools = new Set();
+const openTraceSubs = new Set();
+let traceAutoOpened = false;
 
 // —— 主题：偏好写 localStorage；显式 light/dark 优先，'system' 跟随系统并实时响应 ——
 function themeSystemPrefersDark() {
@@ -1127,6 +1240,8 @@ function initResponsive() {
   const col = $('#rpCollapse'); if (col) col.onclick = () => setRunPanel(false);
 }
 initResponsive();
+// §3.73：绑定两个折叠区 + 末尾区块总开关（渲染入口在下面的轨迹收纳块）。
+initTraceUI();
 
 // —— 工具时间线 DOM：一张卡 + 可复用行（开始/完成不换节点） ——
 function toolStepNode(step) {
@@ -1153,7 +1268,7 @@ function toolStepNode(step) {
     li.classList.toggle('open', open);
     row.setAttribute('aria-expanded', String(open));
   };
-  const entry = { li, row, no, st, tool, args, dur, res, argsFull, meta, pre, more, step, fullOpen: false };
+  const entry = { li, row, out, no, st, tool, args, dur, res, argsFull, meta, pre, more, step, fullOpen: false };
   more.onclick = () => { pre.textContent = step.output.full; more.hidden = true; entry.fullOpen = true; };
   return entry;
 }
@@ -1295,6 +1410,312 @@ function renderRunPanel() {
 $('#rpStop').onclick = () => stopTurnFromButton();
 $('#rpCompact').onclick = () => renderBanner({ text: '⚠ Web 端没有 /compact 端点（只有 CLI 有），本入口未启用。', warn: true });
 
+// ============================================================================
+// §3.73 轨迹 / 子 Agent 收纳：
+//   · 对话流：每轮只留**一行**摘要（.trace-row > .trace-summary），不再内联工具卡；
+//   · 宽屏：详情在右栏「轨迹 / 子Agent」两个可折叠区；
+//   · 窄屏（<1180 右栏收起）：同样的两块在对话流末尾的 #traceDock 里（JS 切换 hidden）。
+//   · 统计口径：对话流摘要与右栏轮头都调用 traceRoundForMsg → traceRoundView，只有一套。
+// ============================================================================
+function traceRoundForMsg(msg, now) {
+  return traceRoundView(traceRoundData(msg, sessionSubs, pendingSubagent, now));
+}
+function collectTraceViews() {
+  return [...document.querySelectorAll('#chat .msg-ai')]
+    .map((m) => traceRoundForMsg(m))
+    .filter((v) => v.toolCount || v.subCount);
+}
+function ensureTraceSummary(msg) {
+  if (!msg) return null;
+  if (msg._traceRow) return msg._traceRow;
+  const row = document.createElement('div');
+  row.className = 'trace-row'; row.dataset.traceRow = '1';
+  const btn = document.createElement('button');
+  btn.type = 'button'; btn.className = 'trace-summary';
+  btn.dataset.round = String(msg._round || 0);
+  btn.dataset.src = 'traceRoundForMsg';
+  btn.onclick = () => focusTraceRound(msg._round);
+  row.appendChild(btn);
+  msg._traceRow = row;
+  msg.appendChild(row);
+  return row;
+}
+/** 对话流每轮的那**一行**摘要：文案与右栏轮头同源（traceSummaryText(traceRoundView(...))）。 */
+function updateTraceSummary(msg) {
+  if (!msg) return;
+  const v = traceRoundForMsg(msg);
+  if (!v.toolCount && !v.subCount) { if (msg._traceRow) msg._traceRow.hidden = true; return; }
+  const row = ensureTraceSummary(msg);
+  row.hidden = false;
+  const btn = row.querySelector('.trace-summary') || row.firstChild;
+  const summary = traceSummaryText(v);
+  btn.textContent = '🧭 ' + summary + '  ›';
+  btn.dataset.summary = summary;
+  btn.dataset.round = String(v.round);
+  btn.setAttribute('aria-label', '定位本轮轨迹：' + summary);
+  row.classList.toggle('has-fail', v.failed > 0);
+  msg.appendChild(row); // 收在本轮正文末尾（不在正文之间堆卡）
+}
+function traceToolStarted(msg, ev) {
+  if (msg && ev && ev.name === 'task') {
+    const question = String((ev.args && (ev.args.question || ev.args.prompt)) || '');
+    pendingSubagent = {
+      seq: ev.seq, msg, round: Number(msg._round) || 0,
+      label: String((ev.args && ev.args.description) || question.slice(0, 60) || '子代理'),
+      question, toolCalls: 0, modelRounds: 0, lastProgressAgoMs: null, running: true, status: 'running',
+    };
+  }
+  updateTraceSummary(msg);
+  renderTracePanels();
+}
+function traceToolFinished(msg, ev) {
+  if (msg && ev && ev.name === 'task') {
+    const question = String((ev.args && (ev.args.question || ev.args.prompt)) || '');
+    const snap = pendingSubagent && pendingSubagent.seq === ev.seq ? pendingSubagent : null;
+    sessionSubs.push({
+      seq: ev.seq,
+      label: String((snap && snap.label) || (ev.args && ev.args.description) || question.slice(0, 60) || '子代理'),
+      question,
+      result: ev.result,
+      durationMs: ev.durationMs,
+      msg,
+      round: Number(msg._round) || 0,
+      toolCalls: snap ? snap.toolCalls : null,
+      modelRounds: snap ? snap.modelRounds : null,
+      lastProgressAgoMs: snap ? snap.lastProgressAgoMs : null,
+      status: ev.result && ev.result.ok === false ? 'failed' : 'done',
+    });
+    if (snap) pendingSubagent = null;
+    renderSubPanel();
+  }
+  updateTraceSummary(msg);
+  renderTracePanels();
+}
+function traceToolDenied(msg, ev) {
+  if (msg && ev && ev.name === 'task') {
+    const question = String((ev.args && (ev.args.question || ev.args.prompt)) || '');
+    const snap = pendingSubagent && pendingSubagent.seq === ev.seq ? pendingSubagent : null;
+    sessionSubs.push({
+      seq: ev.seq, label: String((snap && snap.label) || question.slice(0, 60) || '子代理'), question,
+      result: { ok: false, error: ev.reason || '未授权' }, durationMs: ev.durationMs, msg,
+      round: Number(msg._round) || 0, toolCalls: snap ? snap.toolCalls : null,
+      modelRounds: snap ? snap.modelRounds : null, lastProgressAgoMs: snap ? snap.lastProgressAgoMs : null,
+      status: 'failed',
+    });
+    if (snap) pendingSubagent = null;
+    renderSubPanel();
+  }
+  updateTraceSummary(msg);
+  renderTracePanels();
+}
+/** 回合收尾时仍在跑的子代理：如实落成失败行（不让它从界面上凭空消失）。 */
+function finalizePendingSubagent(msg) {
+  const p = pendingSubagent;
+  if (!p || (msg && p.msg !== msg)) return;
+  sessionSubs.push({
+    seq: p.seq, label: p.label, question: p.question,
+    result: { ok: false, error: '本轮结束时子代理仍未回传结果' }, durationMs: null, msg: p.msg,
+    round: p.round, toolCalls: p.toolCalls, modelRounds: p.modelRounds,
+    lastProgressAgoMs: p.lastProgressAgoMs, status: 'failed',
+  });
+  pendingSubagent = null;
+  renderSubPanel();
+}
+function syncTraceFoldButtons() {  document.querySelectorAll('[data-fold]').forEach((btn) => {
+    const key = btn.dataset.fold;
+    const open = traceFoldState[key] !== false;
+    btn.setAttribute('aria-expanded', String(open));
+    const body = document.getElementById(btn.getAttribute('aria-controls'));
+    if (body) body.hidden = !open;
+  });
+}
+function toggleTraceFold(key) {
+  traceFoldState[key] = !(traceFoldState[key] !== false);
+  syncTraceFoldButtons();
+}
+function traceScrollParent(root) {
+  if (!root || !root.closest) return null;
+  return root.closest('.rp-body') || root.closest('#tdBody');
+}
+function renderTraceRoundList(root, views) {
+  if (!root) return;
+  const scroller = traceScrollParent(root);
+  const top = scroller ? scroller.scrollTop : 0;
+  root.innerHTML = '';
+  if (!views.length) {
+    const empty = document.createElement('div'); empty.className = 'tr-empty';
+    empty.textContent = '还没有可展示的轨迹——发起任务后这里按轮分组。';
+    root.appendChild(empty);
+    return;
+  }
+  for (const v of views) root.appendChild(buildTraceRoundNode(v));
+  if (scroller) scroller.scrollTop = top;
+}
+function buildTraceRoundNode(v) {
+  const box = document.createElement('div');
+  box.className = 'tr-round' + (v.failed ? ' has-fail' : '');
+  box.dataset.round = String(v.round);
+  const head = document.createElement('button');
+  head.type = 'button'; head.className = 'tr-round-head';
+  const no = document.createElement('span'); no.className = 'tr-round-no'; no.textContent = '第 ' + v.round + ' 轮';
+  const sum = document.createElement('span'); sum.className = 'tr-round-sum';
+  sum.textContent = traceSummaryText(v);
+  sum.dataset.summary = traceSummaryText(v); sum.dataset.src = 'traceRoundForMsg';
+  head.appendChild(no); head.appendChild(sum);
+  const body = document.createElement('div'); body.className = 'tr-round-body';
+  if (v.tools.length) {
+    const list = document.createElement('ol'); list.className = 'tl-steps tr-steps';
+    for (const step of v.tools) {
+      const entry = toolStepNode(step);
+      paintToolStep(entry, step);
+      const key = v.round + ':' + String(step.seq);
+      if (openTraceTools.has(key)) { entry.out.hidden = false; entry.li.classList.add('open'); entry.row.setAttribute('aria-expanded', 'true'); }
+      entry.row.addEventListener('click', () => {
+        if (!entry.out.hidden) openTraceTools.add(key); else openTraceTools.delete(key);
+      });
+      list.appendChild(entry.li);
+    }
+    body.appendChild(list);
+  } else {
+    const d = document.createElement('div'); d.className = 'tr-empty'; d.textContent = '本轮没有工具调用'; body.appendChild(d);
+  }
+  const open = openTraceRounds.has(v.round);
+  if (open) box.classList.add('open');
+  head.setAttribute('aria-expanded', String(open));
+  head.onclick = () => {
+    const next = !box.classList.contains('open');
+    box.classList.toggle('open', next);
+    head.setAttribute('aria-expanded', String(next));
+    if (next) openTraceRounds.add(v.round); else openTraceRounds.delete(v.round);
+  };
+  box.appendChild(head); box.appendChild(body);
+  return box;
+}
+function renderTraceSubList(root, views) {
+  if (!root) return;
+  const scroller = traceScrollParent(root);
+  const top = scroller ? scroller.scrollTop : 0;
+  root.innerHTML = '';
+  const rows = [];
+  for (const v of views) for (const s of v.subs) rows.push(s);
+  if (!rows.length) {
+    const empty = document.createElement('div'); empty.className = 'tr-empty';
+    empty.textContent = '本会话还没有子 Agent（task 工具会派生子 Agent）';
+    root.appendChild(empty);
+    return;
+  }
+  for (const s of rows) root.appendChild(buildTraceSubNode(s));
+  if (scroller) scroller.scrollTop = top;
+}
+function buildTraceSubNode(s) {
+  const box = document.createElement('div');
+  box.className = 'tr-sub ' + (s.statusCls || '');
+  box.dataset.seq = String(s.seq == null ? '' : s.seq);
+  box.dataset.round = String(s.round);
+  const head = document.createElement('button');
+  head.type = 'button'; head.className = 'tr-sub-head';
+  const name = document.createElement('span'); name.className = 'tr-sub-name'; name.textContent = '🤖 ' + s.name;
+  const round = document.createElement('span'); round.className = 'tr-sub-meta'; round.textContent = s.roundText;
+  const tools = document.createElement('span'); tools.className = 'tr-sub-meta'; tools.textContent = s.toolText;
+  const progress = document.createElement('span'); progress.className = 'tr-sub-meta'; progress.textContent = s.progress;
+  const state = document.createElement('span'); state.className = 'tr-sub-state ' + (s.statusCls || ''); state.textContent = s.statusText;
+  [name, round, tools, progress, state].forEach((n) => head.appendChild(n));
+  const body = document.createElement('div'); body.className = 'tr-sub-body';
+  const q = document.createElement('div'); q.className = 'tr-sub-q'; q.textContent = '任务：' + (s.question || '—');
+  const stats = document.createElement('div'); stats.className = 'tr-sub-stats';
+  stats.textContent = '子代理自身：' + s.roundsText + ' · ' + s.toolText + ' · ' + s.progress
+    + '（实时快照来自既有 progress.subagent，未新增轮询）';
+  const rl = document.createElement('div'); rl.className = 'tr-sub-rl'; rl.textContent = '结果：';
+  body.appendChild(q); body.appendChild(stats); body.appendChild(rl);
+  if (s.running) { const w = document.createElement('div'); w.className = 'tr-sub-wait'; w.textContent = '仍在运行——工具次数与最后进展随 progress 事件更新…'; body.appendChild(w); }
+  else body.appendChild(textBody(resultText(s.result)));
+  const open = openTraceSubs.has(s.key);
+  if (open) box.classList.add('open');
+  head.setAttribute('aria-expanded', String(open));
+  head.onclick = () => {
+    const next = !box.classList.contains('open');
+    box.classList.toggle('open', next);
+    head.setAttribute('aria-expanded', String(next));
+    if (next) openTraceSubs.add(s.key); else openTraceSubs.delete(s.key);
+  };
+  box.appendChild(head); box.appendChild(body);
+  return box;
+}
+function renderTracePanels() {
+  const views = collectTraceViews();
+  const totalTools = views.reduce((a, v) => a + v.toolCount, 0);
+  const totalSubs = views.reduce((a, v) => a + v.subCount, 0);
+  const meta = views.length ? views.length + ' 轮 · ' + totalTools + ' 次工具 · ' + totalSubs + ' 个子代理' : '—';
+  ['#rpTraceMeta', '#tdTraceMeta'].forEach((sel) => { const n = $(sel); if (n) n.textContent = meta; });
+  ['#rpSubMeta', '#tdSubMeta'].forEach((sel) => { const n = $(sel); if (n) n.textContent = totalSubs ? totalSubs + ' 个' : '—'; });
+  const dockMeta = $('#tdMeta'); if (dockMeta) dockMeta.textContent = meta;
+  if (!traceAutoOpened && views.length) { openTraceRounds.add(views[views.length - 1].round); traceAutoOpened = true; }
+  renderTraceRoundList($('#rpTraceList'), views);
+  renderTraceRoundList($('#tdTraceList'), views);
+  renderTraceSubList($('#rpSubList'), views);
+  renderTraceSubList($('#tdSubList'), views);
+  syncTraceFoldButtons();
+}
+/** 子代理运行中只刷新子代理两块（progress≈1s；不重建工具列表，少打扰）。 */
+function renderSubagentSections() {
+  const views = collectTraceViews();
+  const totalSubs = views.reduce((a, v) => a + v.subCount, 0);
+  ['#rpSubMeta', '#tdSubMeta'].forEach((sel) => { const n = $(sel); if (n) n.textContent = totalSubs ? totalSubs + ' 个' : '—'; });
+  renderTraceSubList($('#rpSubList'), views);
+  renderTraceSubList($('#tdSubList'), views);
+}
+function syncTraceDock() {
+  const dock = $('#traceDock'); if (!dock) return;
+  const show = traceDockVisible(window.innerWidth || 0, !$('#runPanel').hidden);
+  dock.hidden = !show;
+  if (show) renderTracePanels();
+}
+function focusTraceRound(round) {
+  const n = Math.max(0, Math.round(Number(round) || 0)); if (!n) return;
+  const target = traceFocusTarget(window.innerWidth || 0, !$('#runPanel').hidden);
+  if (target === 'dock') {
+    const dock = $('#traceDock'); if (dock) dock.hidden = false;
+    const body = $('#tdBody'); if (body) body.hidden = false;
+    const toggle = $('#tdToggle'); if (toggle) toggle.setAttribute('aria-expanded', 'true');
+  } else {
+    setRunPanel(true);
+  }
+  traceFoldState.trace = true;
+  openTraceRounds.add(n);
+  renderTracePanels();
+  const root = target === 'dock' ? $('#tdTraceList') : $('#rpTraceList');
+  const el = root ? root.querySelector('[data-round="' + n + '"]') : null;
+  if (el) {
+    el.classList.add('focus');
+    try { el.scrollIntoView({ block: 'nearest', behavior: 'smooth' }); } catch { /* 老浏览器/无布局：跳过平滑滚动 */ }
+    setTimeout(() => el.classList.remove('focus'), 1600);
+  }
+}
+function initTraceUI() {
+  document.querySelectorAll('[data-fold]').forEach((btn) => { btn.onclick = () => toggleTraceFold(btn.dataset.fold); });
+  const toggle = $('#tdToggle');
+  if (toggle) toggle.onclick = () => {
+    const body = $('#tdBody'); if (!body) return;
+    const show = body.hidden;
+    body.hidden = !show;
+    toggle.setAttribute('aria-expanded', String(show));
+  };
+  syncTraceFoldButtons();
+  renderTracePanels();
+}
+/** 新对话/切换会话：轮次、子代理、展开状态一起归零（旧会话的轨迹不得串到新会话）。 */
+function resetTraceState() {
+  turnSeq = 0;
+  pendingSubagent = null;
+  sessionSubs.length = 0;
+  openTraceRounds.clear();
+  openTraceTools.clear();
+  openTraceSubs.clear();
+  traceAutoOpened = false;
+  renderTracePanels();
+  try { renderSubPanel(); } catch { /* 子代理面板未初始化时忽略 */ }
+}
+
 // —— 会话设置弹层：模型 / 预设 / 权限（生效值 + 来源） ——
 function permissionModeLabel(mode) {
   return ({ ask: '询问', auto: '自动', readonly: '只读' })[String(mode || '')] || String(mode || '—');
@@ -1612,15 +2033,8 @@ document.addEventListener('keydown', (e) => {
 });
 
 function attachTrajMeta(msg){
-  if(!msg || !msg._traj || !msg._traj.length) return;
-  const tools=msg._traj.filter(x=>x.kind==='tool');
-  const subs=tools.filter(x=>x.name==='task');
-  const meta=document.createElement('div'); meta.className='msg-meta';
-  const b=document.createElement('button'); b.className='trajBtn';
-  b.textContent='🧭 轨迹：'+(msg._steps||tools.length)+' 步 · '+subs.length+' 个子 Agent';
-  b.onclick=()=>openTraj(msg);
-  meta.appendChild(b);
-  msg.insertBefore(meta, msg.firstChild);
+  // §3.73：不再插入 #chat 里的旧轨迹按钮卡；每轮只留一行摘要。
+  updateTraceSummary(msg);
 }
 function openTraj(msg){
   const list=$('#tjList'); list.innerHTML='';
@@ -1677,6 +2091,8 @@ function syncPanelLayout(){
   const rp=$('#runPanel'); if(rp) rp.hidden=!showRun;
   document.body.classList.toggle('run-open', showRun&&!narrow);
   document.body.classList.toggle('run-drawer', showRun&&narrow);
+  // §3.73：窄屏右栏收起时，轨迹/子Agent 在对话流末尾显示；右栏（抽屉）一开就让位。
+  syncTraceDock();
 }
 $('#tjClose').onclick=()=>{ $('#trajPanel').style.display='none'; $('#trajRailBtn').classList.remove('on'); syncPanelLayout(); };
 $('#trajRailBtn').onclick=()=>{
@@ -1917,6 +2333,7 @@ async function init(){
   renderSessionSettings();
   renderEmptyState();
   renderRunPanel();
+  renderTracePanels();
 }
 
 // v0.4.7（T24）：IDE「发送选中代码」此前不生效——扩展 POST /api/draft 时只带 text（写进**全局槽**），
@@ -2382,13 +2799,13 @@ function finalizeCurrentSession(){
   if(!currentSession) return;
   fetch('/api/session-finalize',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({file:currentSession})}).catch(()=>{});
 }
-async function loadSession(file){ if(currentSession && currentSession!==file) finalizeCurrentSession(); currentSession=file; chatEl.innerHTML=''; const r=await fetch('/api/session?file='+encodeURIComponent(file)); const j=await r.json(); for(const m of j.messages||[]){ if(typeof m.content==='string'&&m.content.startsWith('（系统提示）')) continue; if(m.role==='user') addUser(m.content); else { const el=newAiMsg(); aiContent(el).innerHTML=renderMarkdown(m.content); } } if(j.workspace){ const sel=$('#wsSel'); const has=[...sel.options].some(o=>o.value===j.workspace); if(has){ sel.value=j.workspace; } else { refreshWsSel(); } renderBanner({text:'↩ 已回到该会话的工作空间：'+j.workspace}); } if(j.taskState&&(j.taskState.status==='cap'||j.taskState.status==='interrupted')){ renderBanner({text:'⚠ 该会话有未完成任务（步数上限中断）——直接发送消息即可从断点续跑，已完成文件不会重复做。', warn:true}); } scrollBottom(); renderEmptyState(); }
+async function loadSession(file){ if(currentSession && currentSession!==file) finalizeCurrentSession(); currentSession=file; chatEl.innerHTML=''; resetTraceState(); const r=await fetch('/api/session?file='+encodeURIComponent(file)); const j=await r.json(); for(const m of j.messages||[]){ if(typeof m.content==='string'&&m.content.startsWith('（系统提示）')) continue; if(m.role==='user') addUser(m.content); else { const el=newAiMsg(); aiContent(el).innerHTML=renderMarkdown(m.content); } } if(j.workspace){ const sel=$('#wsSel'); const has=[...sel.options].some(o=>o.value===j.workspace); if(has){ sel.value=j.workspace; } else { refreshWsSel(); } renderBanner({text:'↩ 已回到该会话的工作空间：'+j.workspace}); } if(j.taskState&&(j.taskState.status==='cap'||j.taskState.status==='interrupted')){ renderBanner({text:'⚠ 该会话有未完成任务（步数上限中断）——直接发送消息即可从断点续跑，已完成文件不会重复做。', warn:true}); } scrollBottom(); renderEmptyState(); }
 
 // §138：主按钮在生成态=停止，必须走**同一个**停止出口（stopTurnFromButton → stopTurn → POST /api/abort）
 sendBtn.onclick=()=>{ if(generating){ stopTurnFromButton(); } else { send(); } };
 input.addEventListener('keydown',e=>{ if(e.key==='Enter'&&!e.shiftKey){ e.preventDefault(); send(); } });
 input.addEventListener('input',()=>{ input.style.height='44px'; input.style.height=Math.min(input.scrollHeight,200)+'px'; });
-$('#newChat').onclick=()=>{ finalizeCurrentSession(); currentSession=null; chatEl.innerHTML=''; renderEmptyState(); refreshSessions(); };
+$('#newChat').onclick=()=>{ finalizeCurrentSession(); currentSession=null; chatEl.innerHTML=''; resetTraceState(); renderEmptyState(); refreshSessions(); };
 $('#sessMgrBtn').onclick=openSessModal;
 $('#sessClose').onclick=()=>{ $('#sessModal').style.display='none'; };
 async function openSessModal(){
@@ -2404,6 +2821,6 @@ async function openSessModal(){
     div.appendChild(rn); div.appendChild(dl); list.appendChild(div);
   }
 }
-$('#sessions').onchange=e=>{ if(e.target.value){ loadSession(e.target.value); } else { finalizeCurrentSession(); currentSession=null; chatEl.innerHTML=''; renderEmptyState(); } };
+$('#sessions').onchange=e=>{ if(e.target.value){ loadSession(e.target.value); } else { finalizeCurrentSession(); currentSession=null; chatEl.innerHTML=''; resetTraceState(); renderEmptyState(); } };
 if('serviceWorker' in navigator){ navigator.serviceWorker.register('/sw.js').catch(()=>{}); }
 init();

package/src/web/index.html

@@ -386,6 +386,64 @@ body.run-open #scrollBottomBtn{right:326px}
 #rpStop{color:var(--err);border-color:rgba(242,90,90,.45);background:transparent;padding:4px 10px;font-size:12px}
 #rpStop[disabled]{opacity:.45}
 #rpCompact{padding:4px 10px;font-size:12px}
+
+/* —— §3.73 轨迹收纳：对话流一行摘要 + 右栏/末尾两块（轨迹 · 子Agent） —— */
+.trace-row{display:flex;justify-content:flex-end;margin:6px 0 2px}
+.trace-summary{border:1px solid var(--border);background:var(--bg3);color:var(--dim);border-radius:999px;padding:2px 11px;font-size:11.5px;cursor:pointer;max-width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.trace-summary:hover{border-color:var(--accent2);color:var(--text)}
+.trace-row.has-fail .trace-summary{border-color:rgba(242,90,90,.45);color:var(--err)}
+.rp-fold-head{width:100%;border:0;background:transparent;padding:0 0 6px;margin:0;cursor:pointer;font:inherit;font-size:10.5px;letter-spacing:.5px;color:var(--faint);text-transform:uppercase;display:flex;align-items:center;gap:6px}
+.rp-fold-head:hover{color:var(--text)}
+.rp-fold-head .rp-fold-meta{margin-left:auto;font-size:10px;letter-spacing:0;text-transform:none;color:var(--faint)}
+.rp-fold-tri{width:0;height:0;border-top:4px solid currentColor;border-left:3px solid transparent;border-right:3px solid transparent;transition:transform .15s}
+.rp-fold-head[aria-expanded="false"] .rp-fold-tri{transform:rotate(-90deg)}
+.tr-round{border:1px solid var(--border);border-radius:8px;background:var(--bg3);margin-bottom:6px;overflow:hidden}
+.tr-round:last-child{margin-bottom:0}
+.tr-round.has-fail{border-color:rgba(242,90,90,.35)}
+.tr-round-head{display:flex;align-items:center;gap:6px;width:100%;padding:5px 8px;border:0;background:transparent;color:var(--dim);text-align:left;font-size:11.5px}
+.tr-round-head:hover{background:var(--bg2);color:var(--text)}
+.tr-round-no{flex:none;color:var(--faint);font-size:10.5px;font-variant-numeric:tabular-nums}
+.tr-round-sum{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.tr-round.has-fail .tr-round-sum{color:var(--err)}
+.tr-round-body{display:none;border-top:1px dashed var(--border)}
+.tr-round.open .tr-round-body{display:block}
+.tr-round.focus{outline:1px solid var(--accent2);outline-offset:1px}
+.tr-round-body .tl-row{grid-template-columns:18px 14px 52px minmax(0,1fr) 40px 8px;gap:5px;padding:4px 8px;font-size:12px}
+.tr-round-body .tl-row .tl-args{font-size:11.5px}
+.tr-round-body .tl-res{padding:0 8px 4px 86px;font-size:11px}
+.tr-round-body .tl-out{padding:0 8px 8px 86px}
+.tr-empty{padding:7px 9px;color:var(--faint);font-size:11.5px}
+.tr-sub{border:1px solid var(--border);border-radius:8px;background:var(--bg3);margin-bottom:6px;overflow:hidden}
+.tr-sub:last-child{margin-bottom:0}
+.tr-sub.failed{border-color:rgba(242,90,90,.35)}
+.tr-sub-head{display:flex;flex-wrap:wrap;align-items:center;gap:2px 6px;width:100%;padding:5px 8px;border:0;background:transparent;color:var(--dim);text-align:left;font-size:11.5px}
+.tr-sub-head:hover{background:var(--bg2);color:var(--text)}
+.tr-sub-name{min-width:0;max-width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--text);font-weight:600}
+.tr-sub-meta{font-size:10.5px;color:var(--faint);white-space:nowrap}
+.tr-sub-state{margin-left:auto;font-size:10.5px;border:1px solid var(--border);border-radius:999px;padding:0 5px;line-height:15px;color:var(--faint);white-space:nowrap}
+.tr-sub-state.run{color:var(--accent2);border-color:rgba(55,196,210,.4)}
+.tr-sub-state.ok{color:var(--accent)}
+.tr-sub-state.bad{color:var(--err);border-color:rgba(242,90,90,.4)}
+.tr-sub-body{display:none;border-top:1px dashed var(--border);padding:6px 8px;font-size:11.5px;color:var(--dim);line-height:1.6}
+.tr-sub.open .tr-sub-body{display:block}
+.tr-sub-q{color:var(--text);word-break:break-word}
+.tr-sub-stats{margin-top:3px;color:var(--faint);font-size:10.5px}
+.tr-sub-rl{margin-top:5px;color:var(--faint);font-size:10.5px}
+.tr-sub-wait{color:var(--faint);font-size:11px;padding:2px 0}
+#traceDock{margin:10px auto 4px;max-width:760px;border:1px solid var(--border);border-radius:12px;background:var(--bg2);overflow:hidden}
+#tdToggle{display:flex;align-items:center;gap:8px;width:100%;padding:8px 12px;border:0;background:transparent;color:var(--text);font:inherit;font-size:12.5px;font-weight:600;text-align:left;cursor:pointer}
+#tdToggle:hover{background:var(--bg3)}
+.td-meta{margin-left:auto;font-size:10.5px;font-weight:400;color:var(--faint);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+#tdBody{border-top:1px solid var(--border);padding:8px 12px 10px}
+.td-fold{margin-bottom:10px}
+.td-fold:last-child{margin-bottom:0}
+.td-fold-head{width:100%;display:flex;align-items:center;gap:8px;border:0;background:transparent;padding:0 0 6px;color:var(--faint);font:inherit;font-size:10.5px;letter-spacing:.5px;text-transform:uppercase;cursor:pointer}
+.td-fold-head:hover{color:var(--text)}
+.td-fold-head .td-fold-meta{margin-left:auto;font-size:10px;letter-spacing:0;text-transform:none}
+.td-fold-body .tr-round-body .tl-row{grid-template-columns:20px 16px 64px minmax(0,1fr) 54px 10px;gap:7px;padding:5px 12px;font-size:12.5px}
+.td-fold-body .tr-round-body .tl-res{padding:0 12px 5px 138px;font-size:11.5px}
+.td-fold-body .tr-round-body .tl-out{padding:0 12px 9px 138px}
+
 @media (max-width:1180px){
   body.run-open{padding-right:0}
   #runPanel{display:none}
@@ -578,6 +636,21 @@ body.run-open #sessSheet{right:318px}
     </div>
   </div>
   <div id="chat"></div>
+  <!-- §3.73：窄屏（<1180）右栏收起时，轨迹/子Agent 落在对话流末尾的这一个可折叠区块里，
+       不塞回每条消息之间。宽屏隐藏（详情在 #runPanel）。 -->
+  <section id="traceDock" aria-label="轨迹与子 Agent" hidden>
+    <button id="tdToggle" type="button" aria-expanded="true">🧭 轨迹与子 Agent<span class="td-meta" id="tdMeta">—</span><span class="td-tri" aria-hidden="true">⌄</span></button>
+    <div id="tdBody">
+      <section class="td-fold">
+        <button class="td-fold-head" type="button" data-fold="trace" aria-controls="tdTraceFoldBody" aria-expanded="true">轨迹<span class="td-fold-meta" id="tdTraceMeta">—</span></button>
+        <div id="tdTraceFoldBody"><div id="tdTraceList"></div></div>
+      </section>
+      <section class="td-fold">
+        <button class="td-fold-head" type="button" data-fold="subs" aria-controls="tdSubFoldBody" aria-expanded="true">子Agent<span class="td-fold-meta" id="tdSubMeta">—</span></button>
+        <div id="tdSubFoldBody"><div id="tdSubList"></div></div>
+      </section>
+    </div>
+  </section>
 </main>
 <footer>
   <!-- P0-1 常驻运行状态条（v0.6.18 §3.68）：唯一刷新出口 renderWorkStatus()。
@@ -639,6 +712,16 @@ body.run-open #sessSheet{right:318px}
         <div class="rp-metric wide"><span class="l">本轮费用（估算）</span><span class="v" data-rk="cost" id="rpCost">—</span></div>
       </div>
     </section>
+    <!-- §3.73：轨迹 / 子Agent 两块可折叠区。对话流每轮只留一行摘要，细节都收在这里；
+         统计与摘要同源（renderTracePanels → 同一 traceRoundForMsg 视图）。 -->
+    <section class="rp-sec" id="rpTraceSec">
+      <button class="rp-sec-title rp-fold-head" type="button" data-fold="trace" aria-controls="rpTraceFoldBody" aria-expanded="true">轨迹<span class="rp-fold-meta" id="rpTraceMeta">—</span><span class="line"></span><span class="rp-fold-tri" aria-hidden="true"></span></button>
+      <div id="rpTraceFoldBody"><div id="rpTraceList" class="tr-list"></div></div>
+    </section>
+    <section class="rp-sec" id="rpSubSec">
+      <button class="rp-sec-title rp-fold-head" type="button" data-fold="subs" aria-controls="rpSubFoldBody" aria-expanded="true">子Agent<span class="rp-fold-meta" id="rpSubMeta">—</span><span class="line"></span><span class="rp-fold-tri" aria-hidden="true"></span></button>
+      <div id="rpSubFoldBody"><div id="rpSubList" class="tr-list"></div></div>
+    </section>
   </div>
   <div class="rp-foot"><span class="grow" id="rpFootNote">停止与压缩：与状态条同一条停止出口</span><button id="rpCompact" type="button" hidden title="后端有 /compact 时才显示">压缩上下文</button><button id="rpStop" type="button" disabled>■ 停止</button></div>
 </aside>

package/src/web/server.js

@@ -1131,6 +1131,12 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken,
       // 界面看起来一切正常（ok:true + 正文），实际一次工具都没调（"看起来在工作、其实什么都没做"）。
       const zeroNote = String(r.perf?.zeroToolCalls || '');
       const baseNote = r.note || (r.text ? '' : `（任务已执行 ${io.stats().toolCount} 步工具操作${io.stats().deliverables.length ? `、交付 ${io.stats().deliverables.length} 个文件` : ''}，自动收尾总结未能生成——可追问「总结一下刚才的工作」）`);
+      // v0.6.18 §3.74：内存降级/clamp 的事实必须同时进 **web-server.log**（不只 done.note 与 banner）——
+      // 真机事后取证只拿得到日志文件；「重试了几次、压缩前后多少、最后成没成」不能只存在于界面里。
+      const mergedNote = [baseNote, zeroNote].filter(Boolean).join('\n');
+      if (/已压缩上下文|内存降级重试|已自动 clamp|引擎自述上下文/.test(mergedNote)) {
+        srvlog('chat 内存降级 ' + taskId + ' ' + mergedNote.replace(/\n/g, ' | '));
+      }
       send({
         type: 'done',
         budget: budgetInfo,