mingdao-harness 0.6.38 → 0.6.40

package/docs/CODE-SIGNING.md

@@ -209,30 +209,45 @@ node scripts/update-sign.mjs --verify desktop/dist/mingdao-setup-<ver>-x64.exe -
 下载 → 取到 `.sig` → 用旧公钥验 → 失败 → **永久拒绝更新**。
 这比"没有签名"严重得多——用户会被卡死在旧版本，只能手动重装。
 
-### 6.2 两版
+### 6.2 三个阶段
 
 | 版本 | 代码 | 发布侧 |
 | --- | --- | --- |
-| **v0.6.38（本版）** | 密钥环/签名脚本/文案均沿用 v0.6.37（本版只修 macOS CI 测试判据） | **仍然不发布 `.sig`**（CI 开关关闭） |
-| **v0.6.39（下一版）** | 不需再改代码（密钥环已能认新钥） | 用新私钥签 `.sig` → 发布到 GitHub Release **与** 站点 `/updates/<文件名>.sig`；CI 开关打开 |
+| **v0.6.38** | 密钥环/签名脚本/文案均沿用 v0.6.37（本版只修 macOS CI 测试判据） | **仍然不发布 `.sig`**（CI 开关关闭） |
+| **v0.6.39（阶段一，已上线）** | 无需改代码（密钥环已能认新钥） | 用新私钥签 `.sig`，**只上传 GitHub Release**；站点 `/updates/` **绝不放 `.sig`** |
+| **阶段二（0.6.40+，未上线）** | 无需改代码 | 把 Release 里的 `.sig` **复制到站点 `/updates/`**（客户端真正读取的位置） |
+
+> **阶段一为什么不放站点**：存量客户端（≤0.6.35）只内置旧公钥，拿到用新私钥签的 `.sig` 会
+> "有签名但验不过"→ `decideUpdatePolicy` 判 **reject** → **永久拒绝更新**，只能手动重装。
+> 阶段一先把 `.sig` 关在 Release 里（可审计、客户端不读），等 0.6.36+（含密钥环）覆盖绝大多数
+> 活跃用户后再进入阶段二。
+>
+> **阶段二切换条件与回滚**：0.6.36+ 覆盖绝大多数活跃用户后，把 `.sig` 复制到 `/updates/` 即可；
+> 切换前必须实测 0.6.35 / 0.6.37 / 0.6.38 客户端能从新版正常更新。若旧版拒绝，**立即删除
+> `/updates/*.sig`**（回滚只需删文件，不动代码）。
 
 ### 6.3 开关与密钥
 
 - 私钥**不入库**：`~/.mingdao/update-signing-key.pem`（0600），CI 里放 `secrets.UPDATE_SIGNING_KEY`（PEM 全文）；
-- CI 开关：仓库变量 `UPDATE_SIGNING_ENABLED=true` 才执行签名与上传（默认关闭）；
+- CI 开关：**`secrets.UPDATE_SIGNING_KEY` 存在**即执行签名与上传（v0.6.39 起；此前文档写的是仓库变量
+  `UPDATE_SIGNING_ENABLED`，实际未接线）。`secrets` **不能**直接用在 step 级 `if`（整份 workflow 会判无效），
+  所以在 job 级 `env` 折算成 `HAS_UPDATE_SIGNING_KEY` 再判；
 - 生成/轮换：`node desktop/update-verify.js --keygen`（沿用既有实现，私钥不打印、拒绝入库），
   然后把新公钥追加到 `UPDATE_PUBLIC_KEYS`（**旧钥必须保留至少一个大版本**，否则又会断掉存量客户端）。
 
 ### 6.4 发布时 `.sig` 放哪里
 
 客户端按 **`https://harness.mingdao.ai/updates/<安装包文件名>.sig`** 取（`collectUpdateSignature` 的第三来源）。
-所以发版脚本要把 `scripts/sign-release-assets.mjs --out <sig 目录>` 的产物同时：
-1. 传到 GitHub Release（便于审计与镜像）；
-2. **复制到站点 `updates/` 目录**（客户端真正读取的位置）。
+`scripts/sign-release-assets.mjs artifacts` 会**递归**扫描（CI 的产物在 `artifacts/<name>/` 子目录）
+并**保留相对目录**产出 `.sig`（不同平台的 `latest.yml` 不会互相覆盖）。发布侧：
+
+1. **阶段一（v0.6.39）**：只传到 GitHub Release（便于审计与镜像）；**站点 `updates/` 不放**。
+2. **阶段二（未上线）**：再把同样的 `.sig` **复制到站点 `updates/` 目录**（客户端真正读取的位置）。
 
 ### 6.5 验收
 
-- `node test/update-signing.js`（10 项）：密钥环多钥、篡改必拒、签名脚本产物可验、缺钥 CLI 非零退出、文案分层；
-- `batch77`（8 条变异）必须全中；
-- 启用后的首个版本，必须实测"旧版客户端（0.6.35 或 0.6.37/0.6.38）能从 0.6.39 正常更新"——
-  若旧版拒绝，说明 `.sig` 已发布但旧版不在密钥环内，**立即撤下 `/updates/*.sig`**（回滚只要删文件，不动代码）。
+- `node test/update-signing.js`（**11 项**）：密钥环多钥、篡改必拒、签名脚本产物可验（含子目录递归/相对路径/
+  扁平化重名告警）、缺钥 CLI 非零退出、文案分层；
+- `batch77`（**9 条变异**）必须全中；
+- **阶段二启用后**的首个版本，必须实测"旧版客户端（0.6.35 或 0.6.37/0.6.38）能从新版正常更新"——
+  若旧版拒绝，说明 `.sig` 已发布但旧版不在密钥环内，**立即撤下 `/updates/*.sig`**。

package/package.json

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

package/src/agent.js

@@ -46,6 +46,8 @@ import { appendEvent, eventFileFor, eventLogEnabled, missingToolCallIds, setEven
 // ② 工具结果怎么回填（序列化 / 复用前缀 / 约束拒绝文案 / 按窗口截断）；
 // ③ 工具参数怎么解析（v0.6.17 第四刀：JSON + 容错 + 归一化 + 错误文案）。
 import { READONLY_TIER_SET, visibleToolsFor, serializeToolResult, toolResultMessage, parseToolArgs } from './tools-flow.js';
+// v0.6.40：插话"有→继续、无→收尾"的判据与前端共用同一份纯函数（viewmodel 不读 DOM/全局）。
+import { shouldContinueAfterModel } from './web/viewmodel.js';
 
 const MAX_STEPS = 24;
 // 子代理步数上限：审计/精读类只读子任务需要读多个文件 + 交叉引用，12 步易在「读不全」时被截断
@@ -138,14 +140,55 @@ function resolveAgentEventFile(sessionRef, cfg) {
   return null;
 }
 
+/**
+ * v0.6.40：把插话缓冲里的**全部**条目注入当前回合的消息数组。
+ *
+ * 车道语义（与 next-turn 排队严格区分）：
+ *   · 每个 step 边界调用一次，`drain()` 必须**全量取走**（不是一条一步）；
+ *   · 每条插话以 `{role:'user', content:text}` 追加在末尾——模型下一步请求就能看到；
+ *   · 通过既有 io 事件通道推 `{type:'steer', text}`（Web 端渲染"↳ 已插入本轮"）。
+ *
+ * 纯判据（"有插话→继续"）在 web/viewmodel.js 的 shouldContinueAfterModel；这里只做副作用。
+ * drain 抛异常的边界：视为本轮没有插话（插话是旁路，绝不能让一个坏 buffer 打断回合）。
+ *
+ * @param {{ drain?: () => any } | undefined} steering
+ * @param {any[]} messages
+ * @param {any} io
+ * @returns {any[]} 本次实际注入的条目（供收尾分支判断是否继续）
+ */
+function drainSteeringInto(steering, messages, io) {
+  /** @type {any} */
+  let raw;
+  try {
+    raw = steering?.drain?.() || [];
+  } catch {
+    return [];
+  }
+  const list = Array.isArray(raw) ? raw : Array.isArray(raw?.taken) ? raw.taken : [];
+  /** @type {any[]} */
+  const injected = [];
+  for (const it of list) {
+    const text = String(it && typeof it === 'object' ? it.text ?? '' : it ?? '');
+    if (!text.trim()) continue;
+    messages.push({ role: 'user', content: text });
+    injected.push(it);
+    try {
+      if (typeof io?.steer === 'function') io.steer(text);
+      else if (typeof io?.push === 'function') io.push({ type: 'steer', text });
+    } catch {}
+  }
+  return injected;
+}
+
 /**
  * 创建 Agent 循环（调用方只需传 provider/permission/io/modelName/workingDir，其余可选）
  * @param {{ provider: any, permission: any, io: any, modelName: any, workingDir: any,
  *   cfg?: any, undoStore?: any, maxSteps?: number, mcp?: any, onCompact?: any, sessionRef?: any,
  *   onUsage?: (modelName: string, usage: any) => void,
- *   constraints?: any[] }} params
+ *   constraints?: any[],
+ *   steering?: { drain?: () => any } }} params
  */
-export function createAgent({ provider, permission, io, modelName, workingDir, cfg = {}, undoStore, maxSteps, mcp, onCompact, sessionRef, onUsage, constraints: rawConstraints }) {
+export function createAgent({ provider, permission, io, modelName, workingDir, cfg = {}, undoStore, maxSteps, mcp, onCompact, sessionRef, onUsage, constraints: rawConstraints, steering }) {
   const preset = modelPreset(modelName) || {};
   // v0.3.2 模型自适应：预算按模型上下文窗口推导（留输出余量 + 75% 舒适区），
   // 自定义/本地小模型不再套 128000 默认撑爆窗口；prompt 永不逼近窗口边缘（prefill 不爆炸）。
@@ -1039,6 +1082,8 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
           durationMs: Date.now() - startedAt, perf: perf(),
         };
       }
+      // 接线点①（v0.6.40）：每个 step 边界全量取走插话；放在中止检查之后 = 停止优先。
+      drainSteeringInto(steering, messages, io);
       // 本轮的 AbortController 提到压缩之前创建（审计 BUG-037）：压缩是一次**大开销的真实请求**
       // （30K 输入 × executor 模型），此前它在 `ac` 创建之前发生、拿不到任何 signal，
       // 于是压缩期间 Ctrl+C 只能等它返回（远程 600s / 本地 1800s，且还有一次重试）。
@@ -2063,6 +2108,9 @@ export function createAgent({ provider, permission, io, modelName, workingDir, c
           });
           continue;
         }
+        // 接线点②（v0.6.40）：没有工具调用、本要收尾——刚插话就继续下一步（本轮不结束）。
+        const steeredNow = drainSteeringInto(steering, messages, io);
+        if (shouldContinueAfterModel({ steer: steeredNow, aborted, stalled: noProgressFired })) continue;
         markOutcome(finish === 'length' ? 'capped' : 'done', { capHit: false, truncated: finish === 'length' });
         return {
           text: finalText,

package/src/session-events.js

@@ -42,7 +42,27 @@ export const EVENT_TYPES = Object.freeze([
   'checkpoint',
 ]);
 
-const EVENT_TYPE_SET = new Set(EVENT_TYPES);
+/**
+ * 审批事件（v0.6.40 悬空闭合切片）：`approval.asked` / `approval.decided` 由审批轨道写入。
+ *
+ * 为什么不并进 `EVENT_TYPES`：那份清单是**对外公开**的 12 类事件，条数被既有回归套件
+ * （`test/session-events.js` ①）逐字钉死；本切片不允许改那套断言。但读取与追加又必须认它们——
+ * 否则修补器看不见「永远在等审批」的悬空 ask，也没法把合成的 decided 追加进日志。
+ * 因此：`EVENT_TYPES` 仍是 12 类；内部可读写集合 = 12 类 + 审批 2 类。
+ */
+export const APPROVAL_EVENT_TYPES = Object.freeze(['approval.asked', 'approval.decided']);
+
+/** 内部接受的事件类型：公共 12 类 + 审批 2 类（变量名保持 `EVENT_TYPE_SET`，既有变异锚点不变）。 */
+const EVENT_TYPE_SET = new Set([...EVENT_TYPES, ...APPROVAL_EVENT_TYPES]);
+
+/** 审批/工具的关联键字段（按优先级；没有键时按「最近一条」兜底配对）。 */
+const APPROVAL_ID_FIELDS = Object.freeze(['requestId', 'approvalId', 'approvalRequestId', 'id', 'callId']);
+const TOOL_ID_FIELDS = Object.freeze(['callId', 'toolCallId', 'id']);
+
+/** 合成闭合事件的固定文案：工具结果未知（不是失败，是进程中断后无从得知）。 */
+export const SYNTHETIC_TOOL_ERROR = '进程中断，工具结果未知';
+/** 合成闭合事件的默认原因（`repairEventLog` 调用方也可覆盖）。 */
+export const SYNTHETIC_REASON = '进程中断（启动时合成闭合事件）';
 
 /** 回滚开关：`MINGDAO_EVENT_LOG=0`（或 false/off/no）时全局关闭双写。 */
 export const EVENT_LOG_ENV = 'MINGDAO_EVENT_LOG';
@@ -383,6 +403,166 @@ export function readEvents(eventFile) {
   }
 }
 
+/**
+ * v0.6.40：中断 / 崩溃 / 等审批时关应用会留下**没有配对**的事件。这里把它们找出来。
+ *
+ * 纯函数：不读写文件、不改入参。配对规则（全部按 `seq` 升序处理）：
+ *   · `approval.asked` ↔ `approval.decided`：按 requestId/approvalId/id/callId 配对；
+ *     没有 id 时 decided 关闭最近一条无 id 的 ask（审批不嵌套）；
+ *   · `tool.start` ↔ `tool.end`：按 callId/toolCallId/id 配对；没有 id 时同样关闭最近一条；
+ *   · `turn.start` ↔ `turn.end`：turn 没有 id，用栈配对（end 关闭最近一次 start）；
+ *   · **同 id 多次出现以最后一次为准**：后一次 start/asked 覆盖前一次，不会把已覆盖的旧事件报成悬空。
+ *
+ * @param {any[]} events
+ * @returns {{asks: SessionEvent[], tools: SessionEvent[], turns: SessionEvent[]}}
+ */
+export function findDangling(events) {
+  /** @type {Map<string, any>} */
+  const asks = new Map();
+  /** @type {Map<string, any>} */
+  const tools = new Map();
+  /** @type {any[]} */
+  const turns = [];
+  /** @param {any} ev @param {readonly string[]} fields @returns {string} */
+  const idOf = (ev, fields) => {
+    for (const f of fields) {
+      const v = ev?.data?.[f];
+      if (v !== null && v !== undefined && String(v) !== '') return String(v);
+    }
+    return '';
+  };
+  /**
+   * 关闭 map 里最近一条（无 id 的 end/decided 兜底）。
+   * @param {Map<string, any>} map
+   */
+  const closeLatest = (map) => {
+    const keys = [...map.keys()];
+    const last = keys.length ? keys[keys.length - 1] : '';
+    if (last) map.delete(last);
+  };
+  for (const ev of ordered(events)) {
+    if (ev.type === 'approval.asked') {
+      const key = idOf(ev, APPROVAL_ID_FIELDS) || `#${ev.seq}`;
+      asks.delete(key); // 先删再插：Map 的插入顺序也要反映「最后一次出现」
+      asks.set(key, ev);
+    } else if (ev.type === 'approval.decided') {
+      const key = idOf(ev, APPROVAL_ID_FIELDS);
+      if (key) asks.delete(key);
+      else closeLatest(asks);
+    } else if (ev.type === 'tool.start') {
+      const key = idOf(ev, TOOL_ID_FIELDS) || `#${ev.seq}`;
+      tools.delete(key); // 同上：覆盖时刷新插入顺序
+      tools.set(key, ev);
+    } else if (ev.type === 'tool.end') {
+      const key = idOf(ev, TOOL_ID_FIELDS);
+      if (key) tools.delete(key);
+      else closeLatest(tools);
+    } else if (ev.type === 'turn.start') {
+      turns.push(ev);
+    } else if (ev.type === 'turn.end') {
+      turns.pop();
+    }
+  }
+  /** @param {any} a @param {any} b @returns {number} */
+  const bySeq = (a, b) => (Number(a?.seq) || 0) - (Number(b?.seq) || 0);
+  return {
+    asks: [...asks.values()].sort(bySeq).map(cloneSessionEvent),
+    tools: [...tools.values()].sort(bySeq).map(cloneSessionEvent),
+    turns: turns.sort(bySeq).map(cloneSessionEvent),
+  };
+}
+
+/**
+ * v0.6.40：为悬空事件合成**要追加**的闭合事件（纯函数，不写文件）。
+ *
+ * 顺序是嵌套的自然顺序：先 `approval.decided`（内层）→ 再 `tool.end` → 最后 `turn.end`。
+ * 每条都带 `data.synthetic=true` 与 `data.reason`——重放/审计能一眼看出这是修补出来的事实，
+ * 而不是真实发生过的结束。合成事件不带 `seq`：由 `appendEvent` 在锁内分配，保证接在尾部不重号。
+ *
+ * @param {{asks?: any[], tools?: any[], turns?: any[]}} dangling
+ * @param {{at?: number|Date|null, reason?: string}} [opts]
+ * @returns {{type: string, time: number, data: any}[]}
+ */
+export function synthClosers(dangling, { at = null, reason = '' } = {}) {
+  const rawTime = Number(at instanceof Date ? at.getTime() : at);
+  const time = Number.isFinite(rawTime) && rawTime > 0 ? rawTime : Date.now();
+  const why = String(reason || SYNTHETIC_REASON);
+  /** @type {{type: string, time: number, data: any}[]} */
+  const closers = [];
+  const asks = Array.isArray(dangling?.asks) ? dangling.asks : [];
+  const tools = Array.isArray(dangling?.tools) ? dangling.tools : [];
+  const turns = Array.isArray(dangling?.turns) ? dangling.turns : [];
+  /** @param {any} ev @param {readonly string[]} fields @returns {{field: string, value: any}|null} */
+  const keyOf = (ev, fields) => {
+    for (const f of fields) {
+      const v = ev?.data?.[f];
+      if (v !== null && v !== undefined && String(v) !== '') return { field: f, value: v };
+    }
+    return null;
+  };
+  for (const ask of asks) {
+    /** @type {any} */
+    const data = { decision: 'aborted', synthetic: true, reason: why };
+    const key = keyOf(ask, APPROVAL_ID_FIELDS);
+    if (key) data[key.field] = key.value; // 带上原 ask 的关联键，否则第二次 findDangling 仍配不上
+    closers.push({ type: 'approval.decided', time, data });
+  }
+  for (const tool of tools) {
+    /** @type {any} */
+    const data = { ok: false, error: SYNTHETIC_TOOL_ERROR, synthetic: true, reason: why };
+    if (tool?.data?.name !== undefined) data.name = String(tool.data.name);
+    const key = keyOf(tool, TOOL_ID_FIELDS);
+    if (key) data[key.field] = key.value;
+    closers.push({ type: 'tool.end', time, data });
+  }
+  for (let i = 0; i < turns.length; i += 1) {
+    // 每条悬空 turn 各补一条；事件形状不需要 turn 的任何字段。
+    closers.push({ type: 'turn.end', time, data: { status: 'aborted', synthetic: true, reason: why } });
+  }
+  return closers;
+}
+
+/**
+ * v0.6.40：闭合一个事件日志里的悬空事件。**只追加，不删除/不改写既有行**。
+ *
+ * 流程：读全量事件 → `findDangling` → 有悬空才 `synthClosers` → 逐条走 `appendEvent`
+ * （从而拿到锁内分配的连续 seq）。没有悬空时**连文件都不碰**（返回 repaired:0）。
+ *
+ * 损坏日志：`readEvents` 会把半截 JSON / 未知 type / 缺 seq 的行计入 `skipped`。只要
+ * `skipped > 0` 就视为日志损坏，返回 `{ok:false}` 且**一个字节都不写**——修补器的前提是
+ * 「日志是完整的、只是缺收尾」，在坏日志上追加只会把损坏固化进事实源。
+ *
+ * @param {string} eventFile 事件文件（`.events.ndjson`，不是会话 `.jsonl`）
+ * @param {{reason?: string}} [opts]
+ * @returns {{ok: boolean, error: string|null, repaired: number, dangling: {asks:any[],tools:any[],turns:any[]}, disabled?: boolean}}
+ */
+export function repairEventLog(eventFile, { reason = '' } = {}) {
+  /** @type {{asks:any[],tools:any[],turns:any[]}} */
+  const empty = { asks: [], tools: [], turns: [] };
+  try {
+    const file = path.resolve(String(eventFile || ''));
+    if (!String(eventFile || '')) return { ok: false, error: '事件文件路径为空', repaired: 0, dangling: empty };
+    if (!eventLogEnabled()) return { ok: true, error: null, repaired: 0, dangling: empty, disabled: true };
+    const read = readEvents(file);
+    if (!read.ok) return { ok: false, error: read.error ?? '读取事件日志失败', repaired: 0, dangling: empty };
+    if (read.skipped > 0) {
+      return { ok: false, error: `事件日志损坏（跳过 ${read.skipped} 行），拒绝修补`, repaired: 0, dangling: empty };
+    }
+    const dangling = findDangling(read.events);
+    const closers = synthClosers(dangling, { reason });
+    if (!closers.length) return { ok: true, error: null, repaired: 0, dangling };
+    let repaired = 0;
+    for (const closer of closers) {
+      const r = appendEvent(file, { type: closer.type, data: closer.data, at: closer.time });
+      if (!r.ok) return { ok: false, error: r.error ?? '追加闭合事件失败', repaired, dangling };
+      repaired += 1;
+    }
+    return { ok: true, error: null, repaired, dangling };
+  } catch (err) {
+    return { ok: false, error: String(/** @type {any} */ (err)?.message ?? err), repaired: 0, dangling: empty };
+  }
+}
+
 /** @param {any} value @returns {any} 深拷贝（事件里只会有 JSON 值）。 */
 function cloneJson(value) {
   try {
@@ -392,6 +572,21 @@ function cloneJson(value) {
   }
 }
 
+/**
+ * 悬空事件的对外快照：只保留 `seq/time/type/data`，data 深拷贝。
+ * 找悬空是纯函数，调用方拿到的对象不能反过来改到入参上。
+ * @param {any} ev
+ * @returns {SessionEvent}
+ */
+function cloneSessionEvent(ev) {
+  return {
+    seq: Number.isInteger(Number(ev?.seq)) ? Number(ev.seq) : 0,
+    time: Number.isFinite(Number(ev?.time)) ? Number(ev.time) : 0,
+    type: String(ev?.type || ''),
+    data: cloneJson(ev?.data && typeof ev.data === 'object' ? ev.data : {}),
+  };
+}
+
 /**
  * 事件按 seq 升序（seq 是唯一关联键）；缺 seq 的保持原序在后。
  * @param {any[]} events

package/src/session.js

@@ -3,7 +3,7 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
-import { appendEvent, eventFileFor, eventLogEnabled, isEventLogName, warnEventFailure } from './session-events.js';
+import { appendEvent, eventFileFor, eventLogEnabled, isEventLogName, repairEventLog, warnEventFailure } from './session-events.js';
 
 // —— 冲突备份名（单一事实来源，v0.4.6）——
 // 同步冲突时写入的备份：<会话名>.server-<时间戳>[-<随机后缀>].jsonl（远端版本）与 .remote-（远端拉取版本）。
@@ -168,8 +168,48 @@ export function rewriteSession(file, messages) {
   atomicWriteFileSync(file, lines + (lines ? '\n' : ''), { mode: 0o600 }); // 质检 H4：会话文件原子写
 }
 
-/** @param {any} file */
-export function loadSession(file) {
+/** 每个会话文件每进程只尝试修补一次；失败也不重试（避免每次读取都整份读事件日志）。 */
+const repairAttempted = new Set();
+
+/**
+ * v0.6.40：首次读取会话时闭合「悬空事件」——`approval.asked` 没有 decided、`tool.start`
+ * 没有 tool.end、`turn.start` 没有 turn.end（进程被 kill / 崩溃 / 用户等审批时关应用）。
+ *
+ * 纪律：
+ *   · **只追加**闭合事件，不改写/删除既有行；修补失败只 warn，绝不影响会话读取；
+ *   · 同一会话文件在进程内只跑一次（`repairAttempted`），后续读取直接跳过；
+ *   · `cfg.eventLog === false`（或环境变量关闭）时完全不碰事件文件。
+ * @param {any} file 会话文件（不是事件文件；内部换算成 `<session>.events.ndjson`）
+ * @param {any} [cfg] 传入时尊重 `cfg.eventLog === false`
+ * @returns {{ok:boolean,error:string|null,repaired:number,dangling:{asks:any[],tools:any[],turns:any[]},skipped?:boolean,deduped?:boolean}}
+ */
+export function repairSessionEvents(file, cfg = null) {
+  /** @type {{asks:any[],tools:any[],turns:any[]}} */
+  const empty = { asks: [], tools: [], turns: [] };
+  try {
+    if (cfg && cfg.eventLog === false) return { ok: true, error: null, repaired: 0, dangling: empty, skipped: true };
+    if (!eventLogEnabled(cfg)) return { ok: true, error: null, repaired: 0, dangling: empty, skipped: true };
+    const sessionFile = String(file || '');
+    if (!sessionFile) return { ok: false, error: '会话文件路径为空', repaired: 0, dangling: empty };
+    const key = path.resolve(sessionFile);
+    if (repairAttempted.has(key)) return { ok: true, error: null, repaired: 0, dangling: empty, deduped: true };
+    // 先登记再修补：即使修补失败也不再重试（同一会话每进程只跑一次是硬约束）。
+    repairAttempted.add(key);
+    const eventFile = eventFileFor(key);
+    const result = repairEventLog(eventFile, { reason: '进程中断：启动/首次读取会话时合成闭合事件' });
+    if (!result.ok) warnEventFailure(eventFile, result.error ?? null);
+    return result;
+  } catch (err) {
+    const error = String(/** @type {any} */ (err)?.message ?? err);
+    try {
+      warnEventFailure(eventFileFor(String(file || '')), error);
+    } catch {}
+    return { ok: false, error, repaired: 0, dangling: empty };
+  }
+}
+
+/** @param {any} file @param {any} [cfg] */
+export function loadSession(file, cfg = null) {
   const raw = fs.readFileSync(file, 'utf8');
   const messages = [];
   for (const line of raw.split('\n')) {
@@ -181,6 +221,9 @@ export function loadSession(file) {
       }
     } catch {}
   }
+  // v0.6.40：消息读完后顺带闭合悬空事件。失败只 warn（repairSessionEvents 内部吞掉），
+  // 返回值与消息数组一字不动——事件侧车坏了/修不了，会话照样可读。
+  repairSessionEvents(file, cfg);
   return { file, messages };
 }
 

package/src/web/app.js

@@ -1,6 +1,7 @@
 import { $, esc, highlight, renderMarkdown, scrollBottom, expandableBody, resultText, truncText, textBody, fmtDur, fmtTok, fmtT } from './util.js';
 import { MAX_ATTACHMENTS, MAX_IMAGE_BYTES, MAX_TEXT_BYTES } from './constants.js';
 import { sideNavBreakpoint, sideNavLayout, errCardParts, runStripView, permissionSourceLabel, toolStepView, toolTimelineSummary, toolTimelineVisibility, traceRoundView } from './viewmodel.js';
+import { enqueueMessage, dequeueMessage, shouldDrainQueue, queueView, QUEUE_MAX, enqueueSteer, steerView, STEER_MAX } from './viewmodel.js';
 
 // 访问令牌（P1-3）：地址带 ?token= 时记入 sessionStorage 并从地址栏移除（防截图/历史外泄），
 // 之后所有同源请求统一附加 X-MingDao-Token 头；无令牌时行为与旧版一致。
@@ -718,16 +719,161 @@ function renderAttachments(){
   }
 }
 
+// —— 输入队列（v0.6.39）——
+// 语义：生成中按 Enter 不再"被吞掉/只弹一句提示"，而是**排队**；本轮结束后自动依次发出。
+// 用户中止（■ 停止）时**不排空**——中止的意思是"停下"，此时接着发下一条会违背用户意图。
+// 队列本身只有一份（内存），页面刷新即丢：它是"这一刻的输入意图"，不是持久任务。
+let queued=[];        // [{id,text}]
+let queueSeq=0;
+
+function renderQueue(){
+  const strip=$('#queueStrip'); if(!strip) return;
+  const items=queueView(queued);
+  if(!items.length){ strip.style.display='none'; strip.innerHTML=''; return; }
+  strip.style.display='flex';
+  strip.innerHTML='';
+  const cap=document.createElement('span'); cap.className='qcap';
+  cap.textContent='排队中 '+items.length+' 条（本轮结束后自动发送）';
+  strip.appendChild(cap);
+  for(const it of items){
+    const chip=document.createElement('span'); chip.className='qchip';
+    const idx=document.createElement('span'); idx.className='qi'; idx.textContent=it.index+'.';
+    const txt=document.createElement('span'); txt.className='qt'; txt.textContent=it.label; txt.title=it.text;
+    // 点文本 → 放回输入框编辑（从队列移除，避免"编辑完发两次"）
+    txt.onclick=()=>{ const r=dequeueMessage(queued,it.id); queued=r.queue; renderQueue(); input.value=r.removed?r.removed.text:input.value; input.focus(); autosize(); };
+    const x=document.createElement('span'); x.className='qx'; x.textContent='✕'; x.title='从队列移除';
+    x.onclick=()=>{ queued=dequeueMessage(queued,it.id).queue; renderQueue(); };
+    chip.appendChild(idx); chip.appendChild(txt); chip.appendChild(x);
+    strip.appendChild(chip);
+  }
+}
+
+/** 生成中把输入放进队列；返回是否入队成功（空文本/满员时给可读提示）。 */
+function enqueueInput(text){
+  queueSeq+=1;
+  const r=enqueueMessage(queued,text,'q'+queueSeq);
+  queued=r.queue;
+  if(r.ok){ renderQueue(); return true; }
+  if(r.reason==='full'){
+    const d=document.createElement('div'); d.className='msg-sys';
+    d.innerHTML='⚠ 队列已满（'+QUEUE_MAX+' 条），先发送或删掉几条再添加。';
+    chatEl.appendChild(d); scroll();
+  }
+  return false;
+}
+
+/** 本轮结束后排空队列（用 override 文本直接发下一条）。 */
+function drainQueue(){
+  if(!shouldDrainQueue({queue:queued,generating,aborted:runState.aborted})) return;
+  const next=queued[0];
+  queued=queued.slice(1);
+  renderQueue();
+  input.value=next.text; autosize();
+  // 让 finally 里的收尾（按钮/状态栏/渲染）先跑完，再开下一轮
+  setTimeout(()=>{ try{ send(); }catch(e){ console.error('[MingDao] 队列续发失败',e); } },120);
+}
+
+// —— 插话队列（v0.6.40，next-step 车道）——
+// 语义：生成中 **Cmd/Ctrl+Enter** → POST /api/steer，服务端在每个 step 边界全量取走，
+// 作为新的 user 消息插进**当前轮**——当前任务不会因此结束；与 Enter 的"排队到下一轮"是两条车道。
+// 失败（网络/404 已结束/429 满/413 超长）一律回落到排队并明确提示，输入不丢。
+let steering=[];      // [{id,text,at}]
+let steerSeq=0;
+
+/** 插话 chips：橙色 + ⚡，与蓝色排队 chips 视觉区分。 */
+function renderSteer(){
+  const strip=$('#steerStrip'); if(!strip) return;
+  const items=steerView(steering);
+  if(!items.length){ strip.style.display='none'; strip.innerHTML=''; return; }
+  strip.style.display='flex';
+  strip.innerHTML='';
+  const cap=document.createElement('span'); cap.className='scap';
+  cap.textContent='⚡ 插话中 '+items.length+' 条（下一步注入本轮，不结束当前任务；上限 '+STEER_MAX+' 条）';
+  strip.appendChild(cap);
+  for(const it of items){
+    const chip=document.createElement('span'); chip.className='schip';
+    const ico=document.createElement('span'); ico.className='si'; ico.textContent=it.icon;
+    const txt=document.createElement('span'); txt.className='st'; txt.textContent=it.label; txt.title=it.text;
+    // 点文本 → 放回输入框编辑（从插话队列移除，避免"编辑完插两次"）
+    txt.onclick=()=>{ const r=dequeueMessage(steering,it.id); steering=r.queue; renderSteer(); input.value=r.removed?r.removed.text:input.value; input.focus(); input.style.height='44px'; input.style.height=Math.min(input.scrollHeight,200)+'px'; };
+    const x=document.createElement('span'); x.className='sx'; x.textContent='✕'; x.title='撤销这条插话';
+    x.onclick=()=>{ steering=dequeueMessage(steering,it.id).queue; renderSteer(); };
+    chip.appendChild(ico); chip.appendChild(txt); chip.appendChild(x);
+    strip.appendChild(chip);
+  }
+}
+
+/** 注入成功后按文本移除本地 chip（服务端 id 与前端 id 不同源，按文本配对最稳）。 */
+function dropSteerByText(text){
+  const t=String(text||'');
+  const idx=steering.findIndex(s=>s.text===t);
+  if(idx<0) return false;
+  steering=[...steering.slice(0,idx),...steering.slice(idx+1)];
+  renderSteer();
+  return true;
+}
+
+/** 插话失败 → 回落到 next-turn 队列（绝不静默吞掉用户输入）。 */
+function fallbackSteer(text,why){
+  if(!enqueueInput(text)) return;
+  input.value=''; input.style.height='44px';
+  const d=document.createElement('div'); d.className='msg-sys';
+  d.textContent='⚠ 插话失败（'+why+'），已改为排队：本轮结束后自动发送。';
+  chatEl.appendChild(d); scroll();
+}
+
+/** 生成中 Cmd/Ctrl+Enter：插话（POST /api/steer）；失败回落排队。 */
+async function steerInput(){
+  const text=input.value.trim();
+  if(!text) return;
+  if(!generating||!curTaskId){ fallbackSteer(text,'当前回合尚未建立任务'); return; }
+  try{
+    const r=await fetch('/api/steer',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({taskId:curTaskId,message:text})});
+    const j=await r.json().catch(()=>({}));
+    if(!r.ok||!j.ok) throw new Error(j.error||('HTTP '+r.status));
+    steerSeq+=1;
+    const en=enqueueSteer(steering,text,'s'+steerSeq,Date.now());
+    steering=en.steer;
+    if(en.ok) renderSteer();
+    input.value=''; input.style.height='44px';
+    const ht=$('#hintText');
+    if(ht) ht.textContent='⚡ 插话已入队（共 '+(j.queued||steering.length)+' 条）：模型下一步会收到，当前任务不会因此结束 · 普通 Enter 仍为「排队到下一轮」';
+  }catch(err){
+    fallbackSteer(text,(err&&err.message)||'网络错误');
+  }
+}
+
+/** 本轮收尾：服务端没来得及注入的插话转回排队（不能因为回合结束就丢掉用户已经写下的内容）。 */
+function settleSteering(){
+  if(!steering.length) return;
+  const left=steering; steering=[]; renderSteer();
+  let moved=0;
+  for(const s of left){
+    const r=enqueueMessage(queued,s.text,'q'+(queueSeq+=1));
+    if(!r.ok) break;
+    queued=r.queue; moved+=1;
+  }
+  const dropped=left.length-moved;
+  if(moved) renderQueue();
+  const d=document.createElement('div'); d.className='msg-sys';
+  d.textContent=moved
+    ? '⚠ 本轮结束前插话未及注入，已转为排队：'+moved+' 条'+(dropped?'（另有 '+dropped+' 条因排队已满未保留）':'')
+    : '⚠ 插话未能注入，且排队已满：'+dropped+' 条未保留。';
+  chatEl.appendChild(d); scroll();
+}
+
 async function send(){
   const text=input.value.trim();
   console.log('[MingDao] send 点击：generating=' + generating + ' text=' + text.length + ' attachments=' + attachments.length);
   if(generating){
-    // 审计（长任务静默硬伤）：任务执行中追问「是否完成」→ 界面立即如实应答当前进度，
-    // 不再静默吞掉输入；停止职责由「■ 停止」按钮承担（输入框内容保留不丢）。
-    const secs=curWorkT0?Math.round((Date.now()-curWorkT0)/1000):0;
-    const d=document.createElement('div'); d.className='msg-sys';
-    d.innerHTML='⏳ 上一个任务仍在执行（第 '+curSteps+' 步 · 已 '+Math.floor(secs/60)+' 分 '+Math.round(secs%60)+' 秒），<b>尚未完成</b>。完成后总结与交付物会自动出现在本轮消息底部；如需立即中断请点「■ 停止」。';
-    chatEl.appendChild(d); scroll();
+    // v0.6.39：生成中继续输入 → **入队**（本轮结束后自动发送），不再只弹一句"仍在执行"。
+    // 队列条在输入框上方：点文本回填编辑、点 ✕ 删除；用户中止时不排空（见 drainQueue/aborted）。
+    if(enqueueInput(text)){
+      input.value=''; input.style.height='44px';
+      const secs=curWorkT0?Math.round((Date.now()-curWorkT0)/1000):0;
+      const ht=$('#hintText');
+      if(ht) ht.textContent='已加入队列（共 '+queued.length+' 条），本轮结束后自动发送 · 当前第 '+curSteps+' 步 · 已 '+Math.floor(secs/60)+' 分 '+Math.round(secs%60)+' 秒 · 要立即中断请点「■ 停止」';
+    }
     return;
   }
   if(!text && !attachments.length) return;
@@ -859,6 +1005,13 @@ async function send(){
       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==='steer'){
+        // v0.6.40：queued 是 POST 即时应答（同页 steerInput 已反馈，不重复插行）；
+        // injected 才是 agent 真正把它作为 user 消息喂进当前回合——在对话流里留痕。
+        if(ev.queued!==true){ const st=String(ev.text||''); dropSteerByText(st);
+          const d=document.createElement('div'); d.className='msg-sys'; d.textContent='↳ 已插入本轮：'+st.slice(0,60);
+          chatEl.appendChild(d); scroll(); }
+      }
       else if(ev.type==='ask'){ runState.rawPhase='等待权限确认'; runState.phase='执行工具'; update(); renderWorkStatus(); handleAskEvent(ev); }
       else if(ev.type==='usage'){ onActivity(); runState.cost=String(ev.cost||'');
         // P1-4：本**轮**实际用到的模型（服务端 usage.modelName）——不是"当前选择"的猜测。
@@ -905,7 +1058,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; 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(); }
+  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(); settleSteering(); drainQueue(); }
 }
 
 let curTaskId=null; // 本轮 SSE 任务 id（质检 L1：主停止按钮只断本任务，不再误伤其他 tab）
@@ -2985,7 +3138,14 @@ async function loadSession(file){ if(currentSession && currentSession!==file) fi
 
 // §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('keydown',e=>{
+  if(e.isComposing) return;
+  if(e.key!=='Enter'||e.shiftKey) return;
+  e.preventDefault();
+  // v0.6.40：生成中 Cmd/Ctrl+Enter = 插话（注入当前轮）；Enter = 排队（本轮结束后发送）。
+  if((e.metaKey||e.ctrlKey)&&generating){ steerInput(); return; }
+  send();
+});
 input.addEventListener('input',()=>{ input.style.height='44px'; input.style.height=Math.min(input.scrollHeight,200)+'px'; });
 $('#newChat').onclick=()=>{ finalizeCurrentSession(); currentSession=null; chatEl.innerHTML=''; resetTraceState(); renderEmptyState(); renderCrumb(); refreshSessions(); };
 $('#sessMgrBtn').onclick=openSessModal;

package/src/web/index.html

@@ -218,6 +218,21 @@ main{flex:1;overflow-y:auto;padding:18px 0 12px;min-width:0}
 #composer{display:flex;gap:8px;align-items:flex-end}
 #attachBtn{padding:10px 12px;background:var(--bg3);border:1px solid var(--border);border-radius:10px;cursor:pointer;font-size:15px}
 #attachList{display:flex;gap:6px;flex-wrap:wrap;margin-bottom:6px}
+#queueStrip{max-width:860px;margin:0 auto 6px;display:flex;gap:6px;flex-wrap:wrap;align-items:center}
+#queueStrip .qcap{font-size:12px;color:var(--dim)}
+#queueStrip .qchip{display:inline-flex;align-items:center;gap:6px;max-width:360px;background:rgba(90,160,255,.12);border:1px solid rgba(90,160,255,.38);border-radius:14px;padding:3px 10px;font-size:12.5px;color:var(--fg)}
+#queueStrip .qchip .qi{color:var(--dim)}
+#queueStrip .qchip .qt{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;cursor:text}
+#queueStrip .qchip .qx{cursor:pointer;color:var(--dim)}
+#queueStrip .qchip .qx:hover{color:#ff6b6b}
+/* v0.6.40 插话（next-step）chips：橙色 + ⚡，与蓝色排队 chips 区分（两条车道不混淆） */
+#steerStrip{max-width:860px;margin:0 auto 6px;display:flex;gap:6px;flex-wrap:wrap;align-items:center}
+#steerStrip .scap{font-size:12px;color:var(--warn)}
+#steerStrip .schip{display:inline-flex;align-items:center;gap:6px;max-width:360px;background:rgba(245,158,11,.14);border:1px solid rgba(245,158,11,.48);border-radius:14px;padding:3px 10px;font-size:12.5px;color:var(--fg)}
+#steerStrip .schip .si{color:var(--warn)}
+#steerStrip .schip .st{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;cursor:text}
+#steerStrip .schip .sx{cursor:pointer;color:var(--dim)}
+#steerStrip .schip .sx:hover{color:#ff6b6b}
 .deliver{border:1px solid var(--border);border-left:3px solid var(--accent);border-radius:10px;background:var(--bg2);padding:8px 12px;margin:4px 0;font-size:12.5px}
 .deliver .t{color:var(--accent2);font-weight:600;margin-bottom:2px}
 .deliver .i{color:var(--dim);padding:1px 0;font-family:ui-monospace,Consolas,monospace}
@@ -861,9 +876,13 @@ body.side-collapsed #sideNavSessions .sn-item.on,body.side-mid #sideNavSessions
   </div>
   <input type="file" id="fileInput" accept="image/png,image/jpeg,image/gif,image/webp,.txt,.md,.json,.js,.py,.log,.csv,.html,.css" multiple style="display:none">
   <div id="attachList" style="display:none"></div>
+  <!-- v0.6.40 插话（next-step）：生成中 Cmd/Ctrl+Enter 会插进当前轮，不结束当前任务 -->
+  <div id="steerStrip" style="display:none"></div>
+  <!-- v0.6.39 输入队列（next-turn）：生成中 Enter 排队，本轮结束后自动依次发出（不打断当前任务） -->
+  <div id="queueStrip" style="display:none"></div>
   <div id="composer">
     <button id="attachBtn" title="上传图片或文本文件（图片需支持视觉的模型）">📎</button>
-    <textarea id="input" rows="1" placeholder="输入任务…（Enter 发送，Shift+Enter 换行）"></textarea>
+    <textarea id="input" rows="1" placeholder="输入任务…（Enter 发送；生成中 Enter=排队、⌘/Ctrl+Enter=插话）"></textarea>
     <!-- P1-5 会话设置弹层（v0.6.19 §3.70）：模型 / 预设 / 权限三件套收进同一个 popover，
          按钮上直接印当前生效的模型与权限（用户一眼知道"东西没丢"）。原三个 select 保留在弹层内
          （send()/init() 仍按既有 id 读取），不再占输入区。 -->
@@ -1047,9 +1066,9 @@ body.side-collapsed #sideNavSessions .sn-item.on,body.side-mid #sideNavSessions
       <div class="shortcut-row" data-shortcut="⌘K"><span class="kbd">⌘K / Ctrl+K</span><span class="grow">命令面板（搜索 / 切换 / 执行）</span></div>
       <div class="shortcut-row" data-shortcut="⌘/"><span class="kbd">⌘/ / Ctrl+/</span><span class="grow">打开本表</span></div>
       <div class="shortcut-row" data-shortcut="Esc"><span class="kbd">Esc</span><span class="grow">分层关闭：浮层 › 确认卡 › 停止本轮</span></div>
-      <div class="shortcut-row" data-shortcut="Enter"><span class="kbd">Enter</span><span class="grow">发送</span></div>
+      <div class="shortcut-row" data-shortcut="Enter"><span class="kbd">Enter</span><span class="grow">发送；生成中 = 排队到本轮结束后发送</span></div>
       <div class="shortcut-row" data-shortcut="Shift+Enter"><span class="kbd">Shift+Enter</span><span class="grow">换行</span></div>
-      <div class="shortcut-row" data-shortcut="⌘Enter"><span class="kbd">⌘Enter / Ctrl+Enter</span><span class="grow">发送（与 Enter 等价）</span></div>
+      <div class="shortcut-row" data-shortcut="⌘Enter"><span class="kbd">⌘Enter / Ctrl+Enter</span><span class="grow">发送；生成中 = ⚡ 插话（立即注入当前轮，不结束任务）</span></div>
       <div class="shortcut-row" data-shortcut="y/n"><span class="kbd">y / n</span><span class="grow">权限确认：本次放行 / 拒绝（输入框内不触发）</span></div>
       <div class="shortcut-note">输入法组合（isComposing）期间不触发上述快捷键；⌘ 在 Windows/Linux 上为 Ctrl。</div>
     </div>

package/src/web/routes/domains/misc.js

@@ -109,6 +109,12 @@ export async function handle({ req, res, method, p, url }, deps, shared) {
     return true;
   }
 
+  // v0.6.40：插话（next-step 车道）。鉴权/CSRF 已由 routes/api.js 统一完成，这里只做域分发；
+  // 缓冲/上限/SSE 应答的唯一实现在 server.js 的 createSteering（路由层不另写一套判定）。
+  if (method === 'POST' && p === '/api/steer') {
+    return deps.handleSteer(req, res);
+  }
+
   if (method === 'POST' && p === '/api/abort') {
     const body = await readBody(req, MAX_API_BODY);
     /**

package/src/web/server.js

@@ -9,7 +9,8 @@
 //   POST /api/chat         {message, file?} → 运行一轮，SSE 事件流
 //   POST /api/permission   {id, answer} → 应答权限确认
 //   POST /api/abort        中断当前生成
-// SSE 事件：banner/text/reasoning/code/tool/toolDenied/todo/usage/ask/error/done
+//   POST /api/steer        {taskId, message} → 插话（下一步边界注入当前轮）
+// SSE 事件：banner/text/reasoning/code/tool/toolDenied/todo/usage/ask/steer/error/done
 
 import http from 'node:http';
 import { DEFAULT_MODEL } from '../models.js';
@@ -41,6 +42,8 @@ import { buildSystemPrompt } from '../prompts.js';
 import { loadProjectMemory, loadProjectMemoryEntries, retrieveRelevant, extractAndAppendProjectMemory } from '../memory.js';
 import { saveTaskStateMergeAsync, clearTaskState, loadTaskState, resumePrompt, checkpointHint } from '../task-state.js';
 import { createWebIO } from './web-io.js';
+// v0.6.40：插话的纯语义（上限/字节口径/全量取走）与前端共用同一份实现，避免服务端另写一套。
+import { enqueueSteer, drainSteer, STEER_MAX, STEER_TEXT_MAX } from './viewmodel.js';
 import { installPipeGuards } from '../proc.js';
 import { startMcpServers } from '../mcp.js';
 import {
@@ -298,6 +301,80 @@ function readBody(req, limit = 40 * 1024 * 1024) {
   });
 }
 
+// ---------------------------------------------------------------------------
+// 插话（v0.6.40）：生成中 Cmd/Ctrl+Enter → 插入**当前轮**（不是下一轮）。
+//
+// 每个 task 一份缓冲；agent 在**每个 step 边界**全量 drain 一次，所以此刻 POST 的三条
+// 会一起进入下一次请求，而不是一条一步。上限/字节口径复用 viewmodel.js 的纯函数
+// （前端 chip 与服务端拒绝同一套判据），本工厂只负责"按 taskId 存取 + HTTP 应答 + SSE 通知"。
+// ---------------------------------------------------------------------------
+/** 普通 JSON 接口的请求体上限（与 routes/api.js 的 MAX_API_BODY 同值）。 */
+const STEER_BODY_LIMIT = 1024 * 1024;
+
+/**
+ * 创建插话缓冲与其唯一消费者（放在 runWebServer 内，多个 server 实例互不串味）。
+ *
+ * @param {{ tasks: Map<string, any>, srvlog?: (line: string) => void }} deps
+ * @returns {{
+ *   state: {buffers: Map<string, Array<{id:string,text:string,at?:number}>>, seq: number},
+ *   handleSteer: (req: any, res: any) => Promise<boolean>,
+ *   drain: (taskId: string) => Array<{id:string,text:string,at?:number}>,
+ *   clear: (taskId: string) => void,
+ * }}
+ */
+export function createSteering({ tasks, srvlog }) {
+  const state = { buffers: new Map(), seq: 0 };
+  /** @param {string} taskId */
+  const clear = (taskId) => {
+    state.buffers.delete(taskId);
+  };
+  /** @param {string} taskId @returns {Array<{id:string,text:string,at?:number}>} */
+  const drain = (taskId) => {
+    const list = state.buffers.get(taskId) || [];
+    if (!list.length) return [];
+    const r = drainSteer(list);
+    state.buffers.set(taskId, r.steer);
+    return r.taken;
+  };
+  /** POST /api/steer 的唯一实现（鉴权/CSRF 由 routes/api.js 在域分发之前统一完成）。 */
+  const handleSteer = async (/** @type {any} */ req, /** @type {any} */ res) => {
+    let body;
+    try {
+      body = await readBody(req, STEER_BODY_LIMIT);
+    } catch (/** @type {any} */ e) {
+      return json(res, e?.status || 400, { error: e?.message || '请求体读取失败' });
+    }
+    const taskId = String(body?.taskId || '');
+    const entry = tasks.get(taskId);
+    // 只接受**运行中**的任务：已完成的任务保留在 tasks 里 10 分钟只是任务面板历史，
+    // 往它的缓冲里写东西永远没人消费（泄漏），而且对用户是"假成功"。
+    if (!entry || entry.status !== 'running') {
+      return json(res, 404, { error: '任务不存在或已结束（插话只能发给运行中的任务）' });
+    }
+    state.seq += 1;
+    const list = state.buffers.get(taskId) || [];
+    const r = enqueueSteer(list, String(body?.message == null ? '' : body.message), 's' + state.seq, Date.now());
+    if (!r.ok) {
+      if (r.reason === 'too-long') {
+        return json(res, 413, { error: `插话过长（上限 ${Math.round(STEER_TEXT_MAX / 1024)}KB，UTF-8 字节）——请拆短或改用排队（Enter）分次发送。` });
+      }
+      if (r.reason === 'full') {
+        return json(res, 429, { error: `插话队列已满（上限 ${STEER_MAX} 条）——等下一步注入后再插，或按 Enter 排队。` });
+      }
+      return json(res, 400, { error: '插话不能为空。' });
+    }
+    state.buffers.set(taskId, r.steer);
+    const text = r.steer[r.steer.length - 1].text;
+    // 入队成功 → 即时应答（queued:true）；真正注入时 agent 还会再推 injected:true。
+    try {
+      entry.send?.({ type: 'steer', text, queued: true, queuedCount: r.steer.length });
+    } catch {}
+    srvlog?.(`chat 插话入队 ${taskId} 第 ${r.steer.length} 条（${String(text).length} 字）`);
+    return json(res, 200, { ok: true, queued: r.steer.length });
+  };
+  return { state, handleSteer, drain, clear };
+}
+
 /** @param {{ host?: string, port?: number, authToken?: string|null, onBusy?: (busy: boolean) => void, [key: string]: any }} [opts] */
 export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken, onBusy } = {}) {
   // v0.6.2：常驻服务**不能**因日志管道断开而自杀——重新安装为「静默吞掉 EPIPE」策略。
@@ -391,6 +468,7 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken,
   // 任务注册表：支持多会话并行——每个任务独立的 SSE 流、权限确认、中断控制
   let inflight = 0; // 质检 S2：在途聊天请求计数（与请求生命周期绑定，防 readBody 期间并发超限）
   const tasks = new Map(); // taskId -> { res, send, abortHandler, pendingAsk, session, startedAt, status, message, durationMs }
+  const steering = createSteering({ tasks, srvlog }); // v0.6.40：每任务一份插话缓冲（结束后 clear）
   // v0.4.7（T10）：正在跑回合的会话文件集合——同一会话同一时刻只允许一个回合。
   // 此前 /api/chat 各自 loadSession → 各自推理 → 按完成顺序追加：会话记录会交错
   // （A/B 互相看不到对方的 user 消息、回答归属错乱）；若其中一路触发自动压缩，
@@ -568,8 +646,9 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken,
       try {
         res.end();
       } catch {}
-      // ⑦ prune + 释放闭包
+      // ⑦ prune + 释放闭包（插话缓冲随任务结束清掉，避免 Map 随会话数无限增长）
       entry.send = null;
+      steering.clear(taskId);
       try {
         pruneTasks();
       } catch {}
@@ -1010,7 +1089,7 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken,
     const agent = createAgent({
       provider: providerNow,
       permission,
-      io,
+      io, steering: { drain: () => steering.drain(taskId) }, // v0.6.40：每步边界全量取走本任务插话
       modelName: runModel,
       workingDir: taskDir,
       cfg: chatCfg, // v0.4.0：预设覆盖后的配置（工具白名单 presetTools/参数/权限）
@@ -1192,7 +1271,7 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken,
   const dispatch = createApiDispatch({
     json, srvlog, readBody, cfg, home,
     providerCache, invalidateProviderCache, getProviderFor, tasks,
-    MAX_CONCURRENT, pruneTasks, handleChat,
+    MAX_CONCURRENT, pruneTasks, handleChat, handleSteer: steering.handleSteer,
     mcpFacade, provider, validateRemoteUrl, isPrivateHost,
     authEnabled, tokenMatches, requestToken, trustedHost, INDEX_HTML, draftTexts, startupCwd, sessionMemoryCache,
     state: { get modelName() { return modelName; }, set modelName(v) { modelName = v; },

package/src/web/viewmodel.js

@@ -445,3 +445,164 @@ export function traceRoundView(round) {
     summary: parts.join(' · '),
   };
 }
+
+// ---------------------------------------------------------------------------
+// 输入队列（v0.6.39）：生成中继续输入 → 排队，本轮结束后自动发出
+//
+// 为什么放在这里而不是直接写在 app.js：队列的**语义**（去重、上限、截断、何时排空）是纯逻辑，
+// 必须能被单测钉住；DOM 渲染只是把它画出来。DSH 等 harness 的做法也是"输入先入队、在回合边界消费"。
+// ---------------------------------------------------------------------------
+
+/** 队列上限：防止用户连点把内存撑爆（也避免"一次发 50 条"把模型打爆）。 */
+export const QUEUE_MAX = 20;
+/** chip 上显示的最大字符数。 */
+export const QUEUE_LABEL_MAX = 42;
+
+/**
+ * 把一条输入加入队列。
+ * 空文本直接拒绝（不要让空 chip 出现在界面上）；满员拒绝并给出可读原因。
+ * @param {Array<{id:string,text:string}>} queue
+ * @param {string} text
+ * @param {string} id
+ * @returns {{ok:boolean, queue:Array<{id:string,text:string}>, reason?:string}}
+ */
+export function enqueueMessage(queue, text, id) {
+  const list = Array.isArray(queue) ? queue : [];
+  const t = String(text == null ? '' : text);
+  if (!t.trim()) return { ok: false, queue: list, reason: 'empty' };
+  if (list.length >= QUEUE_MAX) return { ok: false, queue: list, reason: 'full' };
+  return { ok: true, queue: [...list, { id: String(id || ''), text: t }] };
+}
+
+/**
+ * 从队列里移除指定 id。
+ * @param {Array<{id:string,text:string}>} queue
+ * @param {string} id
+ * @returns {{queue:Array<{id:string,text:string}>, removed:({id:string,text:string}|null)}}
+ */
+export function dequeueMessage(queue, id) {
+  const list = Array.isArray(queue) ? queue : [];
+  const idx = list.findIndex((q) => String(q?.id) === String(id));
+  if (idx < 0) return { queue: list, removed: null };
+  return { queue: [...list.slice(0, idx), ...list.slice(idx + 1)], removed: list[idx] };
+}
+
+/**
+ * chip 上的单行显示文本（换行压成空格，超长截断加省略号）。
+ * @param {{text?:string}} item
+ * @returns {string}
+ */
+export function queueLabel(item) {
+  const t = String(item?.text ?? '').replace(/\s+/g, ' ').trim();
+  if (!t) return '';
+  return t.length > QUEUE_LABEL_MAX ? t.slice(0, QUEUE_LABEL_MAX - 1) + '…' : t;
+}
+
+/**
+ * 本轮是否可以排空队列。
+ * 关键：**用户主动中止（aborted）时不排空**——中止的语义是"停下"，此时接着发下一条会违背用户意图；
+ * 而"任务完成""出错"都应当继续把用户已经写好的下一条发出去（用户已经表达了意图）。
+ * @param {{queue?:Array<any>, generating?:boolean, aborted?:boolean}} st
+ * @returns {boolean}
+ */
+export function shouldDrainQueue(st) {
+  const q = Array.isArray(st?.queue) ? st.queue : [];
+  return q.length > 0 && !st?.generating && !st?.aborted;
+}
+
+/**
+ * 队列的渲染模型（含序号、截断文本）。
+ * @param {Array<{id:string,text:string}>} queue
+ * @returns {Array<{id:string,index:number,label:string,text:string}>}
+ */
+export function queueView(queue) {
+  const list = Array.isArray(queue) ? queue : [];
+  return list.map((q, i) => ({ id: String(q?.id || ''), index: i + 1, label: queueLabel(q), text: String(q?.text ?? '') }));
+}
+
+// ---------------------------------------------------------------------------
+// 插话（v0.6.40）：生成中 Cmd/Ctrl+Enter → **插入当前轮**，不是排到下一轮
+//
+// 与 next-turn 队列（上面的 enqueueMessage 一族）是**两条车道**：
+//   · next-turn：本轮全部结束后，才按每轮 1 条依次发出（drainQueue）；
+//   · next-step：每个 step 边界**全量取走**（drainSteer），作为新的 user 消息插进当前请求；
+//     模型本次没有工具调用、本来要收尾时，只要 next-step 非空就继续下一步（shouldContinueAfterModel）。
+// 纯逻辑仍放在这里：上限、字节口径、全量取走、是否继续，都必须被单测钉住。
+// ---------------------------------------------------------------------------
+
+/** 插话队列上限（Octop 的 STEER_DEPTH_CAP 同值）：一次最多积 8 条，多则拒绝。 */
+export const STEER_MAX = 8;
+/** 单条插话文本上限：200KB（UTF-8 字节，不是字符数——中文一字 3 字节）。 */
+export const STEER_TEXT_MAX = 200 * 1024;
+
+/**
+ * 文本的 UTF-8 字节数（浏览器与 Node 同一口径；TextEncoder 不可用时退回字符数）。
+ * @param {unknown} text
+ * @returns {number}
+ */
+export function steerBytes(text) {
+  const t = String(text == null ? '' : text);
+  try {
+    return new TextEncoder().encode(t).length;
+  } catch {
+    return t.length;
+  }
+}
+
+/**
+ * 把一条输入加入**插话**队列（下一步注入本轮）。
+ * 空文本 / 超长（>200KB）/ 满员（≥8 条）都拒绝并给出可读 reason；超长先于满员判定，
+ * 这样"又能插但太长"始终得到 413 而不是 429。
+ * @param {Array<{id:string,text:string,at?:number}>} steer
+ * @param {string} text
+ * @param {string} id
+ * @param {number} [at] 入队时刻（由调用方注入，保持本函数纯净；缺省 0）
+ * @returns {{ok:boolean, steer:Array<{id:string,text:string,at?:number}>, reason?:string}}
+ */
+export function enqueueSteer(steer, text, id, at) {
+  const list = Array.isArray(steer) ? steer : [];
+  const t = String(text == null ? '' : text);
+  if (!t.trim()) return { ok: false, steer: list, reason: 'empty' };
+  if (steerBytes(t) > STEER_TEXT_MAX) return { ok: false, steer: list, reason: 'too-long' };
+  if (list.length >= STEER_MAX) return { ok: false, steer: list, reason: 'full' };
+  return { ok: true, steer: [...list, { id: String(id || ''), text: t, at: Number(at) || 0 }] };
+}
+
+/**
+ * **全量取走**插话队列（每个 step 边界消费一次，不是每条一步）。
+ * 取走后原队列变空；对空队列再调用返回空 taken（幂等，不抛）。
+ * @param {Array<{id:string,text:string,at?:number}>} steer
+ * @returns {{steer:Array<{id:string,text:string,at?:number}>, taken:Array<{id:string,text:string,at?:number}>}}
+ */
+export function drainSteer(steer) {
+  const list = Array.isArray(steer) ? steer : [];
+  return { steer: [], taken: [...list] };
+}
+
+/**
+ * 插话 chip 的渲染模型（与 queueView 同形，另带 kind/icon 供 UI 用不同配色区分）。
+ * @param {Array<{id:string,text:string,at?:number}>} steer
+ * @returns {Array<{id:string,index:number,label:string,text:string,kind:'steer',icon:'⚡'}>}
+ */
+export function steerView(steer) {
+  const list = Array.isArray(steer) ? steer : [];
+  return list.map((s, i) => ({
+    id: String(s?.id || ''),
+    index: i + 1,
+    label: queueLabel(s),
+    text: String(s?.text ?? ''),
+    kind: /** @type {'steer'} */ ('steer'),
+    icon: /** @type {'⚡'} */ ('⚡'),
+  }));
+}
+
+/**
+ * 模型本次没有工具调用、本来要收尾时，是否应当**继续下一步**（而不是结束本轮）。
+ * 有插话就继续；用户中止 / 无进展看门狗触发时不继续（"停下"优先于插话）。
+ * @param {{steer?:Array<any>, aborted?:boolean, stalled?:boolean}} st
+ * @returns {boolean}
+ */
+export function shouldContinueAfterModel(st) {
+  const list = Array.isArray(st?.steer) ? st.steer : [];
+  return list.length > 0 && !st?.aborted && !st?.stalled;
+}

package/src/web/web-io.js

@@ -115,6 +115,14 @@ export function createWebIO({ send, askHandler, setAbortHandler }) {
     renderTodo(todos) {
       send({ type: 'todo', todos });
     },
+    /**
+     * v0.6.40：插话已真正注入当前回合——`injected:true` 与 POST /api/steer 的即时应答
+     * （`queued:true`）区分开，前端只对后者之外的事件在对话流里写「↳ 已插入本轮」。
+     * @param {any} text
+     */
+    steer(text) {
+      send({ type: 'steer', text: String(text ?? ''), injected: true });
+    },
     /** @param {{ modelName: any, usage: any, durationMs: any }} param0 */
     printUsageLine({ modelName, usage, durationMs }) {
       send({