mingdao-harness 0.6.39 → 0.6.41

package/docs/ARCHITECTURE.md

@@ -96,7 +96,7 @@ MingDao 是一个「模型循环 + 工具 + 权限」内核，纯 Node.js ≥ 18
 ### 2.4 会话 / 记忆 / 任务（11）
 
 - `session.js` —— 会话持久化：`<home>/sessions/<时间戳>-<随机>.jsonl` 每轮追加，`--continue` 载入最近一次，`--resume` 打开选择器 —— 会话文件是消息结构的唯一权威，检查点等旁挂状态另存侧车文件。
-- `session-events.js` —— 会话事件日志（v0.7.0 §1.1 切片 A）：`<session>.events.ndjson` 追加 12 类事件 `{seq,time,type,data}`（session/turn/step/tool/message/usage/compact/interrupt/checkpoint）—— **seq 是唯一关联键**：跨进程短临界区锁内「读尾行 last+1」、单次 append 后回读校验；读侧跳过 torn 行/未知 type 并返回 `skipped`；`replayToMessages()` 是纯函数（`message.append` 提供消息本体、`compact` 重置基线、`interrupt` 延迟补 tool 占位），由事件流重放的消息数组必须与原消息数组逐字节等价；事件文件是**旁路**，`loadSession`/`rewriteSession`/SSE/UI 都不读它，`cfg.eventLog=false` 或 `MINGDAO_EVENT_LOG=0` 可整体回滚。
+- `session-events.js` —— 会话事件日志（v0.7.0 §1.1 切片 A）：`<session>.events.ndjson` 追加 12 类事件 `{seq,time,type,data}`（session/turn/step/tool/message/usage/compact/interrupt/checkpoint）—— **seq 是唯一关联键**：跨进程短临界区锁内「读尾行 last+1」、单次 append 后回读校验；读侧跳过 torn 行/未知 type 并返回 `skipped`；`replayToMessages()` 是纯函数（`message.append` 提供消息本体、`compact` 重置基线、`interrupt` 延迟补 tool 占位），由事件流重放的消息数组必须与原消息数组逐字节等价；事件文件是**旁路**：`loadSession`/`rewriteSession` 不读它，`cfg.eventLog=false` 或 `MINGDAO_EVENT_LOG=0` 可整体回滚；切片 B1 起新增两个纯函数供传输层使用——`readAfter(eventFile, afterSeq)` 只读游标读取（`seq > after`，返回 `{ok,events,lastSeq,skipped}`，文件不存在按空窗口）与 `continuityOf(seqs)` 连续性自检（`{ok,gaps:[{after,before}]}`，seq 必须从 1 起逐条 +1）——仅 `GET /api/events?file=&after=` 与 `GET /api/session` 的 `lastEventSeq` 读事件文件，SSE 帧/UI 仍不读。
 - `session-index.js` —— 会话检索索引：词表倒排 + 按 mtime/size 的增量同步，分片存 `<home>/sessions-index/<2位sha1前缀>.json`（256 片）—— 未变化直接用缓存词表，>8MB 文件跳过并移除条目；中文按 bigram + 单字、查询串同口径分词后 AND 匹配。
 - `memory.js` —— 长记忆与自主进化：用户记忆 `~/.mingdao/AGENTS.md`（手动 + 会话结束自动提取用户偏好并去重追加）、会话日志 `journal.jsonl`（默认不注入系统提示，`--journal` / WebUI 勾选才取最近 3 条）—— 自动提取用 executor 模型（约几十 token），`autoMemory: false` 可关。
 - `tasks.js` —— 多会话后台任务面板：`mingdao run` 拉起独立 worker 子进程，状态落 `<home>/tasks/<id>.json`，命令族 `run` / `tasks` / `tasks watch` / `tasks kill` —— taskId 用不可枚举随机值；kill 前必须过 PID 归属校验（见 `proc.js`）。
@@ -121,12 +121,12 @@ MingDao 是一个「模型循环 + 工具 + 权限」内核，纯 Node.js ≥ 18
 
 ### 2.7 Web 层（16）
 
-- `web/server.js` —— WebUI 服务器：零依赖 `node:http` + SSE，复用 `createAgent` + `createPermission` + `createWebIO` —— 非回环绑定强制访问令牌（参数/配置/本次随机生成，`timingSafeEqual` 比对）；Host 白名单防 DNS rebinding；同一会话并发回合由进程级 `busySessions` 串行化。
+- `web/server.js` —— WebUI 服务器：零依赖 `node:http` + SSE，复用 `createAgent` + `createPermission` + `createWebIO` —— 非回环绑定强制访问令牌（参数/配置/本次随机生成，`timingSafeEqual` 比对）；Host 白名单防 DNS rebinding；同一会话并发回合由进程级 `busySessions` 串行化；SSE 每帧带**按 task 从 1 起**的单调 `streamSeq` 与 `id:` 行（心跳 progress 同样带），供客户端跳号检测/断线续订；**双游标**：`streamSeq`（每 task，漏帧检测）与事件日志 seq（每会话跨轮，`lastEventSeq` / `/api/events?after=`）互不推导；帧上既有的 `seq` 是工具卡片配对号（toolStart↔tool 同号），不属于这两套游标。
 - `web/auth.js`（v0.7.0 §1.5）—— WebUI 访问控制的**纯函数层**（从 `server.js` 逐字切出）：`resolveWebToken`（参数 > 配置 > 非回环随机生成）、`extractRequestToken`（`?token=` > `X-MingDao-Token` > `Authorization: Bearer`）、`resolveAuthDecision`（放行/拒绝 + `via` 通道）、`tokenEquals`（`timingSafeEqual`，长度不等直接 false）、`isTrustedHost`（Host 白名单防 DNS rebinding）、`authStartupNotice`（启动文案）—— **不读全局、不写 `res`**；401/403 仍由 `routes/api.js` 唯一写入。
 - `web/provider-cache.js`（v0.7.0 §1.5）—— Provider 缓存 / 预检运行时（从 `server.js` 逐字切出，依赖注入工厂）：`createProviderCache(deps)` 提供 `providerFingerprint`（代际号 + baseUrl + apiKey 的 sha256 摘要 + timeout 配置）、`getProviderFor`、`ensureProbe`（单次 15s 上限 / TTL 备忘 / 失败只降级）、`invalidateProviderCache`（实例与探测备忘**一起清**）与 `start`（缺 Key 告警 + 本地端点观察者 + 初始 provider）—— 缓存键含出网指纹，配置一变新任务绝不拿旧实例（H-04）。
 - `web/routes/api.js` —— API 编排器：访问控制（token / Host / CSRF）→ 静态壳资源 → 按域分发 —— 跨站浏览器请求按 `Sec-Fetch-Site` 一律 403。
 - `web/routes/domains/config.js` —— 配置域：`/api/state` `/api/config` `/api/models-config`，服务商 Key 管理、自定义模型增删改、API 地址覆盖、系统状态快照 —— `endpointChangeGuard` 防「改地址把 Key 送到别处」。
-- `web/routes/domains/sessions.js` —— 会话域：`/api/sessions` `/api/session` `/api/draft`，列表/搜索、载入（聚焦工作空间）、重命名/删除、按会话隔离的草稿槽。
+- `web/routes/domains/sessions.js` —— 会话域：`/api/sessions` `/api/session` `/api/events` `/api/draft`，列表/搜索、载入（聚焦工作空间，含事件日志位置 `lastEventSeq`）、重命名/删除、按**事件 seq** 游标只读事件日志（`/api/events?file=&after=`，只接受 basename，响应带 `seqKind:'event'`）、按会话隔离的草稿槽。
 - `web/routes/domains/skills.js` —— 技能域：`/api/skills` `/api/skill-library` `/api/mcp-presets`，技能列表/安装/卸载、内置库与线上注册表搜索、MCP 预设接入。
 - `web/routes/domains/schedule.js` —— 调度域：`/api/schedule` `/api/tasks`，定时任务增删暂停恢复/链式编排，聊天 SSE 任务 + 后台 worker + 调度任务合并面板。
 - `web/routes/domains/sync.js` —— 同步域：`/api/sync` `/api/sync-conflicts`，登录/登出/推拉/改密/分享与冲突处理。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mingdao-harness",
-  "version": "0.6.39",
+  "version": "0.6.41",
   "description": "MingDao Harness —— 开源智能体框架（Agent Harness）。零依赖、开箱即用，针对 DeepSeek-V4 系列优化，开放主流模型接入。",
   "type": "module",
   "bin": {
@@ -73,7 +73,10 @@
     "typecheck:strict": "node scripts/strict-ratchet.mjs",
     "preversion": "node test/smoke.js && node test/e2e-local.js && npm run bench",
     "version": "node scripts/bump-changelog.mjs",
-    "postversion": "git add package.json package-lock.json CHANGELOG.md 2>/dev/null; git commit -m \"chore: release v$npm_package_version\" --no-verify || true"
+    "postversion": "git add package.json package-lock.json CHANGELOG.md 2>/dev/null; git commit -m \"chore: release v$npm_package_version\" --no-verify || true",
+    "preflight": "node scripts/preflight.mjs",
+    "mutate:shard": "node test/mutate/shard.mjs",
+    "mutate:changed": "node test/mutate/run.mjs --changed HEAD~1"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",

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

@@ -10,7 +10,7 @@
 //     **为什么不是 .jsonl**：全仓（以及用户脚本/测试）有大量 `readdirSync(sessions).filter(f => f.endsWith('.jsonl'))`
 //     的写法，侧车若也叫 `.jsonl` 就会被当成会话——本版实测已挂掉 2 个 e2e（分享时把侧车当会话推给服务端，
 //     服务端回「你还没有这个会话」）。改成 `.ndjson`（同格式、不同扩展名）让这类碰撞在命名层就不存在。
-//   · SSE 帧、UI、账本、同步都不读事件文件。
+//   · SSE 帧、UI、账本、同步都不读事件文件（切片 B1 起仅 `GET /api/events` 用 `readAfter` 只读游标读取）。
 // 因此事件日志坏掉/写不进去，最多是「这条时间线不完整」，绝不影响会话本身。
 //
 // 可靠性约定：
@@ -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,224 @@ export function readEvents(eventFile) {
   }
 }
 
+/**
+ * 从游标处读取事件（v0.7.0 §1.1 切片 B1）：`GET /api/events?after=` 的数据源。
+ *
+ * **两套编号域（别混）**：本文件所有的 seq 都是**事件日志游标**——每个会话跨轮单调
+ * （appendEvent 从 1 开始只增）。SSE 帧上的 `streamSeq` 是**每个 task 从 1 起**的流游标
+ * （见 `web/server.js#createSseWriter`），用于客户端漏帧检测；两者互不推导，`after` 只收事件 seq。
+ *
+ * 语义（纯函数：只读文件、不改入参）：
+ *   · 只返回 `seq > afterSeq` 的事件——**严格大于**：客户端持有的 `afterSeq` 那一帧已经收到过，
+ *     重复下发会让「跳号检测」把重帧误判成跳号（DSH 的 cursor 语义同此）；
+ *   · `lastSeq` 是**整条日志**的最大 seq（不是过滤后的最后一条）：客户端拿它建基线、判断是否追平；
+ *   · `eventFile` 不存在（旧会话 / `eventLog=false`）是**正常形态**：`{ok:true, events:[], lastSeq:0}`，
+ *     不是错误（事件日志是旁路，绝不能让旧会话读不了）；
+ *   · `afterSeq` 非法（非数字 / 负数 / 非安全整数）按 0 处理，与 HTTP 层「after 缺省 = 0」同口径。
+ *   · 复用 `readEvents`：torn 行 / 未知 type / 缺 seq 的行照旧跳过并计入 `skipped`（可见，不静默丢）。
+ *
+ * @param {string} eventFile
+ * @param {number} [afterSeq]
+ * @returns {{ok: boolean, error: string|null, events: SessionEvent[], lastSeq: number, skipped: number}}
+ */
+export function readAfter(eventFile, afterSeq = 0) {
+  const read = readEvents(eventFile);
+  if (!read.ok) return { ok: false, error: read.error, events: [], lastSeq: 0, skipped: read.skipped };
+  const n = Number(afterSeq);
+  const after = Number.isSafeInteger(n) && n > 0 ? n : 0;
+  let lastSeq = 0;
+  for (const ev of read.events) if (ev.seq > lastSeq) lastSeq = ev.seq;
+  return { ok: true, error: null, events: read.events.filter((ev) => ev.seq > after), lastSeq, skipped: read.skipped };
+}
+
+/**
+ * 序号连续性自检（v0.7.0 §1.1 切片 B1）：给测试与服务端自检用，回答「这条流/这份日志有没有漏帧」。
+ *
+ * 判定：序号必须从 **1** 起、逐条 +1；`[]` 视为连续（没有事件就没有缺口）。任何不合法的序号
+ * （非整数 / ≤0）同样算作缺口——「这一帧的编号都读不出来」与丢帧在客户端是同一件事。
+ * 发现缺口后以**实际值**继续比较（`[1,3,4]` 只报一个缺口，而不是把 4 也连带报错）。
+ *
+ * @param {number[]} seqs 按到达顺序（应为升序）的 seq 列表
+ * @returns {{ok: boolean, gaps: {after: number, before: number}[]}}
+ *   `after` = 缺口前一条的 seq（首条缺 1 时为 0），`before` = 缺口后一条的 seq
+ */
+export function continuityOf(seqs) {
+  const list = Array.isArray(seqs) ? seqs : [];
+  /** @type {{after: number, before: number}[]} */
+  const gaps = [];
+  let expected = 1;
+  for (const raw of list) {
+    const seq = Number(raw);
+    if (!Number.isSafeInteger(seq) || seq < 1) {
+      gaps.push({ after: expected - 1, before: Number.isFinite(seq) && seq > 0 ? seq : 0 });
+      continue; // 坏序号不推进 expected：下一条合法序号仍按原期望判定
+    }
+    if (seq !== expected) gaps.push({ after: expected - 1, before: seq });
+    expected = seq + 1;
+  }
+  return { ok: gaps.length === 0, gaps };
+}
+
+/**
+ * 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 +630,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,7 +1,9 @@
 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 } from './viewmodel.js';
+import { enqueueMessage, dequeueMessage, shouldDrainQueue, queueView, QUEUE_MAX, enqueueSteer, steerView, STEER_MAX } from './viewmodel.js';
+// v0.6.41（§1.1 B1）：SSE 序号跳号 → 整窗重取（resync），不逐帧续接
+import { seqContinuity, resyncPlan, seqBanner } from './viewmodel.js';
 
 // 访问令牌（P1-3）：地址带 ?token= 时记入 sessionStorage 并从地址栏移除（防截图/历史外泄），
 // 之后所有同源请求统一附加 X-MingDao-Token 头；无令牌时行为与旧版一致。
@@ -773,6 +775,95 @@ function drainQueue(){
   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);
@@ -788,6 +879,12 @@ async function send(){
     return;
   }
   if(!text && !attachments.length) return;
+  // v0.6.41（§1.1 B1）：**流游标** streamSeq——每个 task（每轮 SSE 流）都从 1 重新编号，
+  // 所以每轮 send() 从 0 起算、首帧必须是 1。
+  // 注意：`/api/session.lastEventSeq` 是**会话事件日志**游标（跨轮单调），与流序号是两套编号域，
+  // 绝不能拿来初始化 streamSeq——否则同一会话第二轮首帧 seq=1 会被判成"旧帧"、整轮不渲染。
+  // 事件日志游标（eventSeq）留给 B2 的事件派生/重放，B1 不消费。
+  let streamSeq = 0;
   const turnCtrl=new AbortController();
   turnAbortCtrl=turnCtrl; // 模块级引用：停止的兜底路径要能断开本轮 SSE（服务端 res.on('close') 同样会收尾）
   // 回合看门狗（无活动超时，非总时长——审计：此前 120s 定时炸弹误杀长时间健康生成，
@@ -876,11 +973,89 @@ async function send(){
       return postAskAnswer(ev, plan.post);
     });
   };
+  // —— v0.6.41（§1.1 B1）：跳号 → 整窗重取（resync） ——
+  // 与 DSH 的 resync() 同语义：漏帧不逐帧续接，整窗重取会话快照。
+  //   ① incomingSeq > streamSeq+1 → 暂停逐帧渲染（不把缺口当连续）；
+  //   ② 有会话文件 → loadSession 整窗重渲染（本轮已丢的增量不补，最终状态以快照为准）；
+  //      没有会话文件（新会话首轮，服务端还没落盘）→ 不重建，只留可见提示；
+  //   ③ 成功后把流游标推进到"触发跳号的那一帧"（该帧与缺口由快照代表），再按 seq 去重重放暂存帧；
+  //   ④ 重取失败 / 无处可重取 → 在对话流里插可见 msg-sys，绝不静默丢弃。
+  // 事件重放（/api/events）不在 B1：它返回的是会话事件而非 SSE 帧，投影是 B2 的活。
+  let resyncing = false;
+  let resyncGiveUp = false;
+  let resyncInFlight = null;
+  let resyncAttempts = 0;
+  const pausedFrames = [];
+  /** @type {(ev:any)=>void} 每帧分派器（重取成功后要按 seq 重放暂存帧，故需同一入口） */
+  let onEvent = () => {};
+  /**
+   * @param {number} gap 缺了多少条
+   * @param {number} atSeq 触发跳号的那一帧的 streamSeq（快照代表到它为止）
+   */
+  const beginResync = (gap, atSeq) => {
+    if (resyncing || resyncGiveUp) return;
+    // 连续两次都补不回来就停手：避免与仍在到达的流互相对打，也避免每帧打一次网络。
+    if (resyncAttempts >= 2) { resyncGiveUp = true; return; }
+    resyncAttempts += 1;
+    resyncing = true;
+    resyncInFlight = (async () => {
+      const plan = resyncPlan({ gap, hasSession: !!currentSession });
+      let taken = false;
+      try {
+        if (plan.mode === 'snapshot') {
+          // 复用「加载会话」的唯一实现：既有的消息加载/工作空间/检查点提示逻辑不另写一套。
+          const j = await loadSession(currentSession);
+          if (j && j.ok !== false && Array.isArray(j.messages)) {
+            // 快照重渲染会清空 chatEl；把在途的流式消息接回窗口末尾，后续帧仍写得进来。
+            if (msg.parentNode !== chatEl) chatEl.appendChild(msg);
+            taken = true;
+          }
+          // 注：j.lastEventSeq 是事件日志游标，与 streamSeq 无关——B1 不拿它当流游标。
+        }
+      } catch { taken = false; }
+      if (!taken) {
+        resyncGiveUp = true;
+        resyncing = false;
+        pausedFrames.length = 0;
+        // 已经警告，但**不把后续帧也丢掉**：把游标推进到 atSeq，让 atSeq+1 起继续渲染，
+        // 用户至少能看到本轮剩余的进展（缺口本身无法补，错误已可见）。
+        streamSeq = Math.max(streamSeq, Number(atSeq) || streamSeq);
+        const d = document.createElement('div');
+        d.className = 'msg-sys';
+        d.textContent = '⚠ 事件流中断且重取失败，请刷新页面';
+        chatEl.appendChild(d);
+        scroll();
+        return;
+      }
+      resyncing = false;
+      resyncAttempts = 0; // 成功一次就清零：只有"连续两次补不回来"才停手
+      // 快照代表到 atSeq 为止的窗口：流游标推进到 atSeq，后续帧从 atSeq+1 继续。
+      streamSeq = Math.max(streamSeq, Number(atSeq) || streamSeq);
+      const banner = seqBanner({ gap });
+      if (banner) {
+        const d = document.createElement('div');
+        d.className = 'msg-sys';
+        d.textContent = banner;
+        chatEl.appendChild(d);
+        scroll();
+      }
+      const frames = pausedFrames.splice(0);
+      for (const ev of frames) onEvent(ev);
+    })().catch(() => { resyncing = false; });
+  };
   try{
     const resp=await fetch('/api/chat',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(payload),signal:turnCtrl.signal});
     if(!resp.ok){ const j=await resp.json().catch(()=>({})); onActivity(); msg.innerHTML='<div class="errline">'+esc(j.error||('HTTP '+resp.status))+'</div>'; updateTasksPanel(); return; }
-    await handleEvents(resp.body, ev=>{
-      if(ev.taskId){ taskId=ev.taskId; curTaskId=taskId; } // 质检 L1：主停止按钮只断本任务
+    onEvent = ev => {
+      if(ev.taskId){ taskId=ev.taskId; curTaskId=taskId; } // 质检 L1：主停止按钮只断本任务（重取计划要用它）
+      // v0.6.41（§1.1 B1）：每帧先过序号闸门，再决定是否走业务分派。
+      // 重取期间不判连续性（基线马上要换），先攒着，成功后再按 streamSeq 去重放行。
+      if (resyncing) { pausedFrames.push(ev); return; }
+      const gate = seqContinuity({ lastSeq: streamSeq, incomingSeq: ev?.streamSeq });
+      if (gate.action === 'accept') streamSeq = Number(ev.streamSeq);
+      else if (gate.action === 'resync') { beginResync(gate.gap, ev.streamSeq); return; }
+      // 重复/乱序旧帧：只跳过这一帧；**无 streamSeq 帧不在这里返回**，业务照常处理（旧服务端兼容）。
+      else if (ev?.streamSeq != null) return;
       if(ev.type==='ask') disarm(); else arm(); // 有活动→重置；权限等待→暂停计时
       if(ev.type==='progress'){ const p=ev.seconds||0; if(ev.phase) curPhase=String(ev.phase); curTools=Number(ev.steps)||0; curTasks=Number(ev.tasks)||0; showThink();
         // P0-1：同一个 runState 同时喂状态条六字段与悬浮详情（服务端 progress ≈1s 一次，无新增轮询）
@@ -916,6 +1091,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）——不是"当前选择"的猜测。
@@ -950,7 +1132,9 @@ async function send(){
         if(ev.stalled){ const d=document.createElement('div'); d.className='errline'; d.style.color='var(--warn)'; d.textContent='⏹ 本轮因长时间无进展已中止（不是步数上限 capped、也不是你点的停止 aborted）——'+(ev.note||'详情见上方告警条。'); msg.appendChild(d); }
         else if(ev.note){ const d=document.createElement('div'); d.className='errline'; d.style.color='var(--warn)'; d.textContent=ev.note; msg.appendChild(d); }
         currentSession=ev.session; update(); refreshSessions(); updateTasksPanel(); }
-    });
+    };
+    await handleEvents(resp.body, onEvent);
+    if (resyncInFlight) await resyncInFlight.catch(() => {});
   }catch(e){ onActivity(); // 诊断（v0.4.2 network error 排查）：静默中断此前无任何日志，无法区分
     if((e&&e.name==='AbortError')||killedByWatchdog) runState.aborted=true;
     // 「手点停止 / 看门狗 / fetch 流静默断裂」。v0.4.3 修：第二参改 JSON 字符串——Electron 日志
@@ -962,7 +1146,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(); drainQueue(); }
+  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）
@@ -3038,11 +3222,27 @@ 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=''; 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, m.ts); else { const el=newAiMsg(m.ts); 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(); renderCrumb(); }
+async function loadSession(file){
+  // v0.6.41（§1.1 B1）：先取快照、成功后再清窗——resync 重取失败时当前窗口必须原样保留。
+  if(currentSession && currentSession!==file) finalizeCurrentSession();
+  const r=await fetch('/api/session?file='+encodeURIComponent(file));
+  const j=await r.json().catch(()=>({}));
+  if(!r.ok) return null; // 不抛：既有调用方忽略返回值；resync 看到 null 就走"重取失败"的可见提示
+  currentSession=file; chatEl.innerHTML=''; resetTraceState();
+  for(const m of j.messages||[]){ if(typeof m.content==='string'&&m.content.startsWith('（系统提示）')) continue; if(m.role==='user') addUser(m.content, m.ts); else { const el=newAiMsg(m.ts); 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(); renderCrumb();
+  return j; // resync 用 j.messages 确认快照形状；j.lastEventSeq 属 B2（事件日志游标）
+}
 
 // §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

@@ -225,6 +225,14 @@ main{flex:1;overflow-y:auto;padding:18px 0 12px;min-width:0}
 #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}
@@ -868,11 +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.39 输入队列：生成中继续输入会排队，本轮结束后自动依次发出（不打断当前任务） -->
+  <!-- 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 读取），不再占输入区。 -->
@@ -1056,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/routes/domains/sessions.js

@@ -1,7 +1,9 @@
-// 会话域（Phase C C1）：/api/sessions /api/session /api/draft
-// 会话列表/搜索、载入（聚焦工作空间）、重命名/删除、按会话隔离的草稿槽。
+// 会话域（Phase C C1）：/api/sessions /api/session /api/events /api/draft
+// 会话列表/搜索、载入（聚焦工作空间）、重命名/删除、按会话隔离的草稿槽；
+// v0.7.0 §1.1 切片 B1：`GET /api/events?file=&after=` 按 seq 游标只读事件日志（SSE 续订 / 跳号整窗重取）。
 import fs from 'node:fs';
 import path from 'node:path';
+import { eventFileFor, readAfter } from '../../../session-events.js';
 import {
   listSessions,
   loadSession,
@@ -105,6 +107,10 @@ export async function handle({ req, res, method, p, url }, deps, shared) {
         workspace: ws?.name || null,
         // v0.3.0 P0-2：未完成检查点（供前端提示续跑）
         taskState: loadTaskState(path.basename(file)),
+        // v0.7.0 §1.1 切片 B1：**事件游标**（event seq）——该会话事件日志的最大 seq；无日志为 0。
+        // 注意：这是「每个会话跨轮单调」的事件日志编号，**不是** SSE 帧的 streamSeq（每个 task 从 1 起），
+        // 两者互不推导；前端不得拿它去校验帧号（见 server.js#createSseWriter 的双游标说明）。
+        lastEventSeq: readAfter(eventFileFor(path.join(home, 'sessions', path.basename(file))), 0).lastSeq,
       });
     } catch {
       json(res, 404, { error: '会话不存在' });
@@ -112,6 +118,41 @@ export async function handle({ req, res, method, p, url }, deps, shared) {
     return true;
   }
 
+  // v0.7.0 §1.1 切片 B1：按 **event seq** 游标读取会话事件日志（不是 SSE 帧的 streamSeq！）。
+  //
+  // 双游标（见 server.js#createSseWriter）：本端点与 `lastEventSeq` 用的是「每个会话跨轮单调」的
+  // 事件日志 seq；SSE 帧上的 `streamSeq` 是「每个 task 从 1 起」的流游标——两者互不推导，
+  // 客户端用 streamSeq 检测漏帧、用本端点的 after/event seq 整窗重取事件。
+  //
+  // 契约：
+  //   · `after` 缺省 = 0（返回全部）；非数字 / 负数 → 400（**严格**，不把垃圾解析成 0：
+  //     否则客户端一次拼错 URL 就会静默收到全量重放，跳号检测反而更难查）；
+  //   · `file` 只接受 basename：含 / \ 或就是 . / .. → 400（事件日志与会话同目录，放开即目录穿越）；
+  //   · 会话 `.jsonl` 不存在 → 404（问的是「这个会话」，会话本身没有）；
+  //   · 会话存在但事件文件不存在（旧会话 / eventLog 关闭）→ **200** + `{lastSeq:0, events:[]}`，
+  //     不是 404——事件日志是旁路，缺它不代表会话不可读。
+  if (method === 'GET' && p === '/api/events') {
+    const file = String(url.searchParams.get('file') || '');
+    if (!file) return json(res, 400, { error: '缺少 file 参数' });
+    if (/[\\/]/.test(file) || file === '.' || file === '..') {
+      return json(res, 400, { error: 'file 只接受会话文件名（不得含路径）' });
+    }
+    const afterRaw = url.searchParams.get('after');
+    let after = 0;
+    if (afterRaw !== null) {
+      if (!/^\d+$/.test(afterRaw) || !Number.isSafeInteger(Number(afterRaw))) {
+        return json(res, 400, { error: 'after 必须是非负整数' });
+      }
+      after = Number(afterRaw);
+    }
+    const full = path.join(home, 'sessions', file);
+    if (!fs.existsSync(full)) return json(res, 404, { error: '会话不存在' });
+    const read = readAfter(eventFileFor(full), after);
+    if (!read.ok) return json(res, 500, { error: `读取事件日志失败：${read.error || '未知原因'}` });
+    // `seqKind:'event'`：机器可读地声明 lastSeq/events[].seq 是**事件日志**编号（不是 streamSeq）。
+    return json(res, 200, { ok: true, file, seqKind: 'event', lastSeq: read.lastSeq, events: read.events });
+  }
+
   if (method === 'POST' && p === '/api/session') {
     const body = await readBody(req, MAX_API_BODY);
     const file = path.basename(String(body.file || ''));

package/src/web/server.js

@@ -4,12 +4,14 @@
 //   GET  /                 前端单页（src/web/index.html）
 //   GET  /api/state        模型/权限/会话列表
 //   GET  /api/sessions     会话列表（含预览与相对时间）
-//   GET  /api/session?file= 载入会话消息
+//   GET  /api/session?file= 载入会话消息（含 lastEventSeq 基线）
+//   GET  /api/events?file=&after= 按游标读会话事件日志（SSE 续订 / 跳号整窗重取）
 //   GET  /api/skills       技能列表
 //   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 +43,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 +302,111 @@ function readBody(req, limit = 40 * 1024 * 1024) {
   });
 }
 
+// ---------------------------------------------------------------------------
+// SSE 帧写入（v0.7.0 §1.1 切片 B1）：**双游标**——本函数只负责流游标，别把两套编号对齐。
+//
+//   · `streamSeq`（本函数）：**每个 task** 从 1 起的单调帧号，同时写标准 `id: <streamSeq>` 行
+//     （EventSource 断线续订的 Last-Event-ID 就是它）。客户端只用它判断「**这条流**有没有漏帧」，
+//     发现跳号 → 整窗重取。作用域必须是 task：全局/会话级计数器会让并发任务互相占号，
+//     两个都正常的流各自看到"跳号"，检测直接失效。
+//   · 事件日志的 seq（`session-events.js`）：**每个会话**跨 task 单调，供 `lastEventSeq` /
+//     `GET /api/events?after=` 的事件游标（B2 的事件派生）使用——与 streamSeq 互不推导，
+//     客户端**不得**拿 lastEventSeq 去校验帧号。
+//   · 帧上既有的 `seq` 字段（toolStart/tool/toolDenied）是**工具卡片配对号**（同一工具调用的
+//     开始/完成同号），语义早已存在且被前端消费；本函数不碰它，只新增 `streamSeq`。
+//
+// 心跳 progress 也走这一个函数——它同样是状态更新，跳号检测不能漏它。
+// ---------------------------------------------------------------------------
+/**
+ * 为一个 task 创建 SSE 写入器（计数器闭包在该 task 内，`handleChat` 每次请求新建一个）。
+ * @param {any} res
+ * @param {string} taskId
+ * @returns {(obj: any) => void}
+ */
+function createSseWriter(res, taskId) {
+  let streamSeq = 0;
+  return (obj) => {
+    try {
+      streamSeq += 1;
+      res.write(`id: ${streamSeq}\ndata: ${JSON.stringify({ ...obj, taskId, streamSeq })}\n\n`);
+    } catch {}
+  };
+}
+
+// ---------------------------------------------------------------------------
+// 插话（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 +500,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 +678,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 {}
@@ -578,12 +689,8 @@ export async function runWebServer({ host = '127.0.0.1', port = 3820, authToken,
     srvlog('chat 开始 ' + taskId + ' session=' + (body.file || '新会话') + ' 消息长度=' + String(body.message || '').length);
     tasks.set(taskId, entry);
     notifyBusy(); // 进入 running → 忙
-    /** @param {any} obj */
-    const send = (obj) => {
-      try {
-        res.write(`data: ${JSON.stringify({ ...obj, taskId })}\n\n`);
-      } catch {}
-    };
+    // 每帧带 streamSeq/id（切片 B1）：流游标随本 task 新建，两个并发请求互不占号。
+    const send = createSseWriter(res, taskId);
     entry.send = send;
     entry.finish = finishChat; // 路由层最外层 try/catch/finally 的入口（见 routes/domains/misc.js）
     // 进度心跳（审计：长时间健康生成的可感知性——模型持续输出工具参数期间可能长时间
@@ -1010,7 +1117,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 +1299,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

@@ -519,3 +519,161 @@ 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;
+}
+
+// ---------------------------------------------------------------------------
+// SSE 序号连续性（v0.6.41 §1.1 切片 B1 的客户端一半）
+//
+// 服务端每帧带 `streamSeq`（**每个 task** 从 1 单调 +1）与 `id:` 行；客户端持流游标 lastSeq。
+// 丢帧（跳号）时**不逐帧续接**，而是按 DSH 的 resync 语义整窗重取快照——
+// 否则界面会停在"少了几段正文/几个工具结果"的错误状态且无人知晓。
+// 三个函数都是纯函数：判定表、救援顺序、给用户的一行文案都必须被单测钉住。
+// ---------------------------------------------------------------------------
+
+/**
+ * SSE 帧序号连续性判定（客户端游标 lastSeq，首帧前为 0）。
+ *
+ * 判定表：
+ *   incomingSeq == null（旧服务端 / 无 streamSeq 帧） → `ignore`（**只跳过序号判定，业务照常处理**）
+ *   lastSeq === 0 且 incomingSeq === 1          → `accept`（首帧基线）
+ *   lastSeq === 0 且 incomingSeq !== 1          → `resync`（连开头都缺了，gap = incomingSeq-1）
+ *   incomingSeq === lastSeq + 1                 → `accept`
+ *   incomingSeq <= lastSeq                      → `ignore`（重复/乱序旧帧，不重复渲染）
+ *   incomingSeq > lastSeq + 1                   → `resync`（gap = incomingSeq - lastSeq - 1）
+ *
+ * `ok` 只表示"连续性没坏"：`accept`/`ignore` 都是 true，只有 `resync` 是 false。
+ * @param {{lastSeq?:number, incomingSeq?:number|null}} [frame]
+ * @returns {{ok:boolean, gap:number, action:'accept'|'resync'|'ignore'}}
+ */
+export function seqContinuity({ lastSeq, incomingSeq } = {}) {
+  const incoming = incomingSeq == null ? null : Number(incomingSeq);
+  if (incoming === null || !Number.isInteger(incoming)) {
+    // 旧服务端兼容：没有 streamSeq（或它不是整数）→ 不参与连续性判断，业务照常。
+    return { ok: true, gap: 0, action: 'ignore' };
+  }
+  const rawLast = Number(lastSeq);
+  const last = Number.isInteger(rawLast) && rawLast > 0 ? rawLast : 0;
+  if (last === 0) {
+    // 首帧必须是 1：否则说明客户端错过的不是"中间几帧"，而是流开头。
+    return incoming === 1
+      ? { ok: true, gap: 0, action: 'accept' }
+      : { ok: false, gap: Math.max(0, incoming - 1), action: 'resync' };
+  }
+  if (incoming === last + 1) return { ok: true, gap: 0, action: 'accept' };
+  if (incoming <= last) return { ok: true, gap: 0, action: 'ignore' };
+  return { ok: false, gap: incoming - last - 1, action: 'resync' };
+}
+
+/**
+ * 跳号后怎么救（v0.6.41 B1 只有两态）：
+ *   · 有会话文件 → `snapshot`：复用「加载会话」整窗重取/重渲染（DSH `resync()` 语义）；
+ *   · 没有会话文件（新会话首轮，服务端还没落盘）→ `none`：不重建空窗口，调用方插可见提示。
+ *
+ * 为什么没有 `events`：`GET /api/events` 返回的是**会话事件**（`message.append` / `tool.start`），
+ * 不是 SSE 帧（`text` / `toolStart`），塞进现有 SSE 分派器渲染不出来——事件→UI 的投影留到 B2。
+ * `hasTask` 只为调用方/B2 预留，B1 的判断不依赖它（没有会话快照就没有可重取的窗口）。
+ * @param {{gap?:number, hasSession?:boolean, hasTask?:boolean}} [ctx]
+ * @returns {{mode:'snapshot'|'none', reason:string}}
+ */
+export function resyncPlan({ gap, hasSession } = {}) {
+  const g = Math.max(0, Math.floor(Number(gap) || 0));
+  if (hasSession) return { mode: 'snapshot', reason: `会话文件可用：整窗重取快照（跳过 ${g} 条事件）` };
+  return { mode: 'none', reason: `没有可重取的会话快照（新会话尚未落盘）：只提示、不重建窗口（跳过 ${g} 条事件）` };
+}
+
+/**
+ * 重取成功后插进对话流的一行**低调**提示（不是 errline，不吓人）。
+ * @param {{gap?:number}} [ctx]
+ * @returns {string} gap<=0 / 非法值 → 空串（不插提示）
+ */
+export function seqBanner({ gap } = {}) {
+  const g = Math.floor(Number(gap));
+  if (!Number.isFinite(g) || g <= 0) return '';
+  return `已跳过 ${g} 条事件，正在重新同步…`;
+}

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({