@coralai/sps-cli 0.65.33 → 0.65.34

package/dist/console/routes/chat.js

@@ -17,23 +17,19 @@ import { uniqueTmpPath } from '../../infra/filesystem.js';
 import { basename, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spsMcpStdioConfig } from '../../providers/mcp/spsMcpStdioConfig.js';
-import { Agent, run } from '@openai/agents';
 import { Hono } from 'hono';
 import { ensureDaemon } from '../../commands/agentDaemon.js';
 import { jsonlExists, readSessionModel, recoverTrailingText, sanitizeToolInput } from '../../core/claudeJsonl.js';
-import { readAgentsMd } from '../../core/agents/agentsMd.js';
+import { appendFrame, dropSessionLog, framesSince } from '../chatEventLog.js';
+import { expandChoicesSpec, expandFormSpec, } from '../../core/interactions/formSpec.js';
+import { INTERACTION_TOOL_NAMES } from '../../providers/mcp/interactionTools.js';
 import { readProjectAgentConfig } from '../../core/agents/projectAgentConfig.js';
 import { resolveWorkerModelEnv } from '../../core/agents/workerModelEnv.js';
 import { readModelSettingsFile, writeModelSettingsFile } from '../../core/agents/modelSettingsFile.js';
 import { loadAgentsConfig } from '../../core/intel/agentsConfig.js';
-import { RuntimeSession } from '../../core/intel/RuntimeSession.js';
 import { DaemonClient } from '../../daemon/daemonClient.js';
 import { resolveEligibleSkillNames, SkillsManager } from '../../core/skills/index.js';
-import { chatTools } from '../../providers/llm/chatTools.js';
-import { skillTools } from '../../providers/llm/skillTools.js';
-import { createReviewerModel } from '../../providers/llm/modelFactory.js';
 import { resolveAgentProvider } from '../../providers/llm/providers.js';
-import { workerTools } from '../../providers/llm/workerTools.js';
 import { toHttpStatus, toProblemJson } from '../../shared/errors.js';
 import { chatAttachmentsDirFor, chatSessionsDir, chatWorkspacesRoot } from '../../shared/runtimePaths.js';
 import { workspacesRoot } from '../../core/workspacePaths.js';
@@ -106,6 +102,22 @@ function resolveChatModel(agentKind, cwd) {
  */
 const chatBus = new EventEmitter();
 chatBus.setMaxListeners(0);
+/**
+ * 发布一条 chat 事件:**先记进会话事件日志拿到帧号,再广播**。
+ *
+ * 帧号是 SSE 的 `id:`,浏览器重连会自动带 `Last-Event-ID` 回来,服务端据此逐事件补发
+ * (见 `console/chatEventLog`)。所有对外事件都必须走这里 —— 绕过它的事件不会被记录,
+ * 重连时就是一个静默的洞。
+ */
+function publish(event, data) {
+    const sessionId = typeof data.sessionId === 'string' ? data.sessionId : '';
+    if (!sessionId) {
+        chatBus.emit(event, data);
+        return;
+    }
+    const frameId = appendFrame(sessionId, event, data);
+    chatBus.emit(event, { ...data, frameId });
+}
 const activeStreams = new Map();
 /**
  * startRun 失败 → 用户可读文案。daemon 总闸拒绝(code='CAPACITY')带排队深度 + 建议重试秒数
@@ -183,7 +195,7 @@ function startTurn(sessionId, assistantId) {
         const t = activeStreams.get(sessionId);
         if (!t)
             return;
-        chatBus.emit('chat.message.heartbeat', { sessionId, assistantId, turnId: assistantId, seq: t.seq, ts: new Date().toISOString() });
+        publish('chat.message.heartbeat', { sessionId, assistantId, turnId: assistantId, seq: t.seq, ts: new Date().toISOString() });
     }, HEARTBEAT_MS);
     if (typeof heartbeat.unref === 'function')
         heartbeat.unref();
@@ -209,11 +221,12 @@ function appendInteractionBlock(sessionId, assistantId, blocks, event) {
         kind: event.kind,
         title: event.title,
         schema: event.schema,
+        respond: event.respond ?? 'endpoint',
         revision: event.revision ?? 1,
         status: 'pending',
     };
     blocks.push(block);
-    chatBus.emit('chat.message.chunk.interaction', {
+    publish('chat.message.chunk.interaction', {
         sessionId,
         assistantId,
         turnId: assistantId,
@@ -222,6 +235,85 @@ function appendInteractionBlock(sessionId, assistantId, blocks, event) {
     });
     return block;
 }
+/**
+ * 交互工具的**工具块抑制器**。
+ *
+ * 🔴 为什么要抑制:`present_form` / `present_choices` 的 UI **就是交互块本身**,再画一条
+ * 工具调用小条是多余的,而且有两个真实的误导:
+ *  - openai 路上这次工具调用会**真的挂起**(run.waiting_for_input),挂起期间工具块是非终态,
+ *    前端按非终态渲染成转圈 —— 用户填表那几十秒里它一直在转,看着像 agent 还在想;
+ *  - 恢复后该块落成 `interrupted`,前端显示【已中断】,而这其实是**正常**的挂起-恢复。
+ *
+ * 两条后端路径的接管方式不同:
+ *  - claude(MCP):工具立即返回、回合不挂起 → 这里把 tool_use **转成**交互块,
+ *    答案走 `respond:'message'`(作为新的用户消息发回);
+ *  - openai(broker):worker 自己会发权威的 `interaction` 事件 → 这里只**丢掉**工具块,
+ *    不重复造一个(此前两个块都发,就是截图里"一条转圈的工具条 + 一张面板")。
+ */
+function createInteractionToolSink(sessionId, assistantId, blocks, backend) {
+    /** toolCallId → 工具名;首帧参数常为空,要等 tool_update 才凑得出 spec。 */
+    const tracked = new Map();
+    const emitted = new Set();
+    const tryEmit = (id, title, input) => {
+        if (backend !== 'claude' || emitted.has(id))
+            return;
+        const spec = toInteractionSpec(title, input);
+        if (!spec)
+            return; // 参数还没到齐,等下一帧
+        emitted.add(id);
+        appendInteractionBlock(sessionId, assistantId, blocks, {
+            interactionId: id,
+            kind: baseToolName(title) === 'present_choices' ? 'choices' : 'form',
+            title: spec.title,
+            schema: spec,
+            respond: 'message',
+            revision: 1,
+        });
+    };
+    return {
+        onToolUse: (id, title, input) => {
+            if (!isInteractionTool(title))
+                return false;
+            tracked.set(id, title);
+            tryEmit(id, title, input);
+            return true;
+        },
+        onToolUpdate: (id, input) => {
+            const title = tracked.get(id);
+            if (!title)
+                return false;
+            tryEmit(id, title, input);
+            return true;
+        },
+    };
+}
+/** 工具名去掉 MCP 前缀(claude 侧是 `mcp__sps__present_form`,openai broker 侧是裸名)。 */
+function baseToolName(title) {
+    return title.startsWith('mcp__sps__') ? title.slice('mcp__sps__'.length) : title;
+}
+/** 这个工具是不是"要往返 chat UI"的交互工具(present_form / present_choices)。 */
+function isInteractionTool(title) {
+    return INTERACTION_TOOL_NAMES.has(baseToolName(title));
+}
+/**
+ * 把交互工具的原始入参归一成规范 `FormSpec`(见 `core/interactions/formSpec`)。
+ *
+ * 🔴 此前 `template:'image'` 是客户端展开的 —— console 一份、openai broker 一份,注释互相
+ * 提醒"要手工同步";coral 与 gameforge 接生图表单就是第三、第四份。展开挪到这里之后,
+ * 发出去的事件永远携带完整字段表,产品端零模板知识。省 token 的初衷不变:模板名只在
+ * 模型 ↔ 工具之间传,展开发生在工具调用被透传给前端的那一刻。
+ *
+ * 选择器也走同一套 schema(只有 radio 的表单),让产品只维护一个渲染器。
+ * 展不开(参数还没到 / 无效)→ null,调用方等 tool_update 的完整参数。
+ */
+function toInteractionSpec(toolTitle, input) {
+    const base = baseToolName(toolTitle);
+    if (base === 'present_form')
+        return expandFormSpec(input);
+    if (base === 'present_choices')
+        return expandChoicesSpec(input);
+    return null;
+}
 function findInteractionBlock(session, interactionId) {
     for (let index = session.messages.length - 1; index >= 0; index--) {
         const message = session.messages[index];
@@ -306,13 +398,6 @@ function reconcileStaleTurns(log) {
 }
 async function streamAssistantResponse(sessionId, assistantId, userContent, log, attachments, dependencies = {}) {
     const selected = readSession(sessionId);
-    // 旧 OpenAI 会话没有 agentMode，继续走历史 SDK 会话文件；只有显式 daemon 的
-    // 新会话才迁入统一宿主，避免升级后丢掉既有上下文。
-    if (selected?.agentKind === 'openai' &&
-        (selected.agentMode ?? 'sdk') === 'sdk') {
-        await streamOpenaiChat(sessionId, assistantId, userContent, log);
-        return;
-    }
     const backend = selected?.agentKind === 'openai' ? 'openai' : 'claude';
     if (!(await (dependencies.ensureDaemon ?? ensureDaemon)())) {
         persistAndEmitComplete(sessionId, {
@@ -571,6 +656,7 @@ async function streamAssistantResponse(sessionId, assistantId, userContent, log,
     const subscription = client.subscribeRunResilient(slot);
     // 复用 POST 时 startTurn 预登记的进行中回合(blocks 引用,后续就地追加);未预登记则退化自建(防御)。
     const blocks = activeStreams.get(sessionId)?.blocks ?? startTurn(sessionId, assistantId);
+    const interactionSink = createInteractionToolSink(sessionId, assistantId, blocks, backend);
     let accumulatedText = '';
     let truncated = false;
     const consume = (async () => {
@@ -614,7 +700,7 @@ async function streamAssistantResponse(sessionId, assistantId, userContent, log,
                     last.text += piece;
                 else
                     blocks.push({ type: 'text', text: piece });
-                chatBus.emit('chat.message.chunk.text', {
+                publish('chat.message.chunk.text', {
                     sessionId,
                     assistantId,
                     turnId: assistantId,
@@ -628,6 +714,9 @@ async function streamAssistantResponse(sessionId, assistantId, userContent, log,
             }
             else if (evt.event === 'tool_use') {
                 const input = sanitizeToolInput(evt.input);
+                // 交互工具由 sink 接管(转成交互块 / 丢弃),不再画工具小条。
+                if (interactionSink.onToolUse(evt.id, evt.title, input))
+                    continue;
                 blocks.push({
                     type: 'tool_use',
                     id: evt.id,
@@ -637,7 +726,7 @@ async function streamAssistantResponse(sessionId, assistantId, userContent, log,
                     input,
                     locations: evt.locations,
                 });
-                chatBus.emit('chat.message.chunk.tool_use', {
+                publish('chat.message.chunk.tool_use', {
                     sessionId,
                     assistantId,
                     turnId: assistantId,
@@ -651,8 +740,11 @@ async function streamAssistantResponse(sessionId, assistantId, userContent, log,
                 });
             }
             else if (evt.event === 'tool_update') {
-                const tool = blocks.find((b) => b.type === 'tool_use' && b.id === evt.id);
                 const lateInput = evt.input != null ? sanitizeToolInput(evt.input) : undefined;
+                // 交互工具的完整参数常常**迟到**(流式首帧 rawInput 为 {}),交互块可能要到这一帧才发得出。
+                if (interactionSink.onToolUpdate(evt.id, lateInput))
+                    continue;
+                const tool = blocks.find((b) => b.type === 'tool_use' && b.id === evt.id);
                 if (tool && tool.type === 'tool_use') {
                     tool.status = evt.status;
                     // 完整参数迟到时补上:空对象 `{}` 也算"待补"(流式首帧 rawInput 为 {},完整值在 update 里)。
@@ -661,7 +753,7 @@ async function streamAssistantResponse(sessionId, assistantId, userContent, log,
                     if (evt.locations != null && tool.locations == null)
                         tool.locations = evt.locations;
                 }
-                chatBus.emit('chat.message.chunk.tool_update', {
+                publish('chat.message.chunk.tool_update', {
                     sessionId,
                     assistantId,
                     turnId: assistantId,
@@ -829,6 +921,8 @@ function openaiResumeEnsureArgs(sessionId, session) {
 async function streamInteractionResponse(sessionId, assistantId, client, slot, afterSequence, log) {
     const blocks = activeStreams.get(sessionId)?.blocks ??
         startTurn(sessionId, assistantId);
+    // 交互恢复路只发生在 openai(durable interactions),sink 在这里只负责丢弃工具块。
+    const interactionSink = createInteractionToolSink(sessionId, assistantId, blocks, 'openai');
     const subscription = client.subscribeRunResilient(slot, afterSequence);
     let accumulatedText = '';
     let truncated = false;
@@ -854,7 +948,7 @@ async function streamInteractionResponse(sessionId, assistantId, client, slot, a
                     last.text += piece;
                 else
                     blocks.push({ type: 'text', text: piece });
-                chatBus.emit('chat.message.chunk.text', {
+                publish('chat.message.chunk.text', {
                     sessionId,
                     assistantId,
                     turnId: assistantId,
@@ -866,6 +960,9 @@ async function streamInteractionResponse(sessionId, assistantId, client, slot, a
             }
             else if (evt.event === 'tool_use') {
                 const input = sanitizeToolInput(evt.input);
+                // 交互工具由 sink 接管(本函数是 openai 的恢复路,sink 只做丢弃)。
+                if (interactionSink.onToolUse(evt.id, evt.title, input))
+                    continue;
                 blocks.push({
                     type: 'tool_use',
                     id: evt.id,
@@ -875,7 +972,7 @@ async function streamInteractionResponse(sessionId, assistantId, client, slot, a
                     input,
                     locations: evt.locations,
                 });
-                chatBus.emit('chat.message.chunk.tool_use', {
+                publish('chat.message.chunk.tool_use', {
                     sessionId,
                     assistantId,
                     turnId: assistantId,
@@ -889,8 +986,10 @@ async function streamInteractionResponse(sessionId, assistantId, client, slot, a
                 });
             }
             else if (evt.event === 'tool_update') {
-                const tool = blocks.find((block) => block.type === 'tool_use' && block.id === evt.id);
                 const input = evt.input == null ? undefined : sanitizeToolInput(evt.input);
+                if (interactionSink.onToolUpdate(evt.id, input))
+                    continue;
+                const tool = blocks.find((block) => block.type === 'tool_use' && block.id === evt.id);
                 if (tool?.type === 'tool_use') {
                     tool.status = evt.status;
                     if (input !== undefined &&
@@ -902,7 +1001,7 @@ async function streamInteractionResponse(sessionId, assistantId, client, slot, a
                         tool.locations = evt.locations;
                     }
                 }
-                chatBus.emit('chat.message.chunk.tool_update', {
+                publish('chat.message.chunk.tool_update', {
                     sessionId,
                     assistantId,
                     turnId: assistantId,
@@ -1051,77 +1150,6 @@ function loadBaseSkill(baseSkill, cwd, log) {
     log?.warn(`baseSkill "${chosen}" 加载失败 —— 本会话不注入基座 skill(检查 HQ/项目 skills 里是否存在)`);
     return '';
 }
-async function streamOpenaiChat(sessionId, assistantId, userContent, log) {
-    // 复用 POST 时 startTurn 预登记的进行中回合(blocks 引用);未预登记则退化自建(防御)。
-    const blocks = activeStreams.get(sessionId)?.blocks ?? startTurn(sessionId, assistantId);
-    let acc = '';
-    try {
-        const model = createReviewerModel(loadAgentsConfig().reviewer);
-        // 设了工作目录 → 额外挂工作区文件工具(读/写/列/bash),让它能在已有项目里直接干活。
-        const sess = readSession(sessionId);
-        const cwd = sess?.cwd ?? undefined;
-        // per-session 注入角色:有工作目录就读它的 AGENTS.md 当 instructions(项目定义角色),否则用通用兜底。
-        // pinnedSkills:开局强制预载的 skill 正文(确定性,不赌模型自觉),prepend 在角色指令前。
-        const instructions = loadPinnedSkills(sess?.pinnedSkills, cwd) + (readAgentsMd(cwd) ?? loadBaseSkill(sess?.baseSkill, cwd, log));
-        // skill 发现/加载(list/search/load,经 SkillsManager 读 HQ)始终在;有 cwd 再加工作区文件/bash。
-        const tools = [...chatTools(), ...skillTools(cwd), ...(cwd ? workerTools(cwd) : [])];
-        const agent = new Agent({ name: 'chat', instructions, model, tools });
-        // 会话历史持久化(跨消息记忆),后端 = chat-sessions/<id>.openai-session.json。
-        const session = new RuntimeSession(resolve(chatSessionsDir(), `${sessionId}.openai-session.json`), `chat-${sessionId}`);
-        const r = await run(agent, userContent, { stream: true, session });
-        // 迭代完整事件流:raw 文本 delta → 流式文本块;run_item(tool_called/tool_output)→ tool_use 块。
-        for await (const ev of r) {
-            if (ev.type === 'raw_model_stream_event') {
-                const data = ev.data;
-                if (typeof data?.delta === 'string' && data.delta && (data.type ?? '').includes('output_text')) {
-                    const piece = data.delta;
-                    acc += piece;
-                    const last = blocks[blocks.length - 1];
-                    if (last?.type === 'text')
-                        last.text += piece;
-                    else
-                        blocks.push({ type: 'text', text: piece });
-                    chatBus.emit('chat.message.chunk.text', { sessionId, assistantId, turnId: assistantId, seq: bumpSeq(sessionId), text: piece });
-                }
-            }
-            else if (ev.type === 'run_item_stream_event') {
-                const evName = ev.name;
-                const raw = ev.item?.rawItem;
-                if (evName === 'tool_called' && raw?.type === 'function_call') {
-                    const id = raw.callId ?? `tool-${blocks.length}`;
-                    let parsedArgs;
-                    try {
-                        parsedArgs = raw.arguments ? JSON.parse(raw.arguments) : undefined;
-                    }
-                    catch {
-                        parsedArgs = raw.arguments;
-                    }
-                    const input = sanitizeToolInput(parsedArgs);
-                    blocks.push({ type: 'tool_use', id, title: raw.name ?? 'tool', kind: 'function', status: 'in_progress', input });
-                    chatBus.emit('chat.message.chunk.tool_use', { sessionId, assistantId, turnId: assistantId, seq: bumpSeq(sessionId), id, title: raw.name ?? 'tool', kind: 'function', status: 'in_progress', input });
-                }
-                else if (evName === 'tool_output') {
-                    const id = raw?.callId;
-                    const b = blocks.find((x) => x.type === 'tool_use' && (id ? x.id === id : x.status === 'in_progress'));
-                    if (b && b.type === 'tool_use') {
-                        b.status = 'completed';
-                        chatBus.emit('chat.message.chunk.tool_update', { sessionId, assistantId, turnId: assistantId, seq: bumpSeq(sessionId), id: b.id, status: 'completed' });
-                    }
-                }
-            }
-        }
-        await r.completed;
-        if (!acc.trim())
-            acc = String(r.finalOutput ?? ''); // 兜底:无 raw 文本 delta 时
-        persistAndEmitComplete(sessionId, { id: assistantId, role: 'assistant', content: acc.trim(), blocks: blocks.length ? blocks : undefined, ts: new Date().toISOString(), status: 'complete' }, log);
-    }
-    catch (err) {
-        persistAndEmitComplete(sessionId, { id: assistantId, role: 'error', content: `openai chat failed: ${err instanceof Error ? err.message : String(err)}`, ts: new Date().toISOString(), status: 'error' }, log);
-    }
-    finally {
-        endTurn(sessionId); // 安全网:complete/error path 已 endTurn;此处兜底停心跳/撤快照
-    }
-}
 /**
  * v0.51.8：在 user 消息末尾追加附件清单。Worker（Claude Code）能用 Read 工具
  * 自己拉文件内容；图片 / PDF / 文本 / 等都原生支持。
@@ -1179,7 +1207,7 @@ function persistAndEmitComplete(sessionId, msg, log) {
         writeSession(session);
     }
     // 明确的终止事件(渐进增强:老客户端仍靠 complete 落定;新字段 turnId/final/seq/text 供补偿与判序)。
-    chatBus.emit('chat.message.complete', {
+    publish('chat.message.complete', {
         sessionId,
         assistantId: turnId,
         turnId,
@@ -1190,7 +1218,7 @@ function persistAndEmitComplete(sessionId, msg, log) {
     });
     // 回合异常:再发一个明确的 error 事件(带 turnId),不静默中断。
     if (msg.role === 'error') {
-        chatBus.emit('chat.message.error', { sessionId, assistantId: turnId, turnId, final: true, seq, message: msg });
+        publish('chat.message.error', { sessionId, assistantId: turnId, turnId, final: true, seq, message: msg });
         log.warn(`chat[${sessionId}]: ${msg.content}`);
     }
     else {
@@ -1237,7 +1265,8 @@ export function createChatRoute(log, chat, dependencies = {}) {
         const agentKind = body.agentKind === 'openai' ? 'openai' : 'claude';
         const configuredWorker = loadAgentsConfig().worker;
         // 新建会话默认 daemon:openai 走真正的独立进程 agent(sps openai-agent,带 sandbox + 工具 + 技能)。
-        // 旧会话(已持久 agentMode='sdk')不受影响,dispatch 侧仍按各自持久值走。
+        // 注:chat 侧已不按 agentMode 分流(阶段 3 收敛,openai 只剩统一宿主一条路);
+        // 该字段仅作为会话元数据保留,dispatch 侧仍按各自持久值走。
         const agentMode = body.agentMode ??
             (configuredWorker.agent === agentKind ? configuredWorker.mode : 'daemon');
         const r = await chat.create({
@@ -1256,7 +1285,7 @@ export function createChatRoute(log, chat, dependencies = {}) {
         });
         if (!r.ok)
             return c.json(toProblemJson(r.error), toHttpStatus(r.error));
-        chatBus.emit('chat.session.created', { sessionId: r.value.id });
+        publish('chat.session.created', { sessionId: r.value.id });
         return c.json(r.value, 201);
     });
     app.get('/sessions/:id', async (c) => {
@@ -1297,7 +1326,8 @@ export function createChatRoute(log, chat, dependencies = {}) {
         catch {
             /* non-fatal */
         }
-        chatBus.emit('chat.session.deleted', { sessionId: id });
+        publish('chat.session.deleted', { sessionId: id });
+        dropSessionLog(id); // 事件日志跟着会话走,别留孤儿
         return c.body(null, 204);
     });
     app.post('/sessions/:id/interactions/:interactionId', async (c) => {
@@ -1307,8 +1337,9 @@ export function createChatRoute(log, chat, dependencies = {}) {
         if (!session) {
             return c.json({ type: 'not-found', title: 'Session not found', status: 404 }, 404);
         }
-        if (session.agentKind !== 'openai' ||
-            (session.agentMode ?? 'sdk') !== 'daemon') {
+        // 阶段 3 之后 openai chat 只有一条路(统一宿主),`agentMode` 不再选择代码路径,
+        // 因此这里只看后端 —— 否则历史上 agentMode='sdk' 的会话会被挡在交互之外。
+        if (session.agentKind !== 'openai') {
             return c.json({
                 type: 'validation',
                 title: 'Session does not support durable interactions',
@@ -1385,7 +1416,7 @@ export function createChatRoute(log, chat, dependencies = {}) {
                     latestFound.block.status = settled;
                     latestFound.block.revision += 1;
                     writeSession(latest);
-                    chatBus.emit('chat.message.interaction.updated', {
+                    publish('chat.message.interaction.updated', {
                         sessionId: id,
                         interactionId,
                         status: settled,
@@ -1412,7 +1443,7 @@ export function createChatRoute(log, chat, dependencies = {}) {
             latestFound.block.revision += 1;
             writeSession(latest);
         }
-        chatBus.emit('chat.message.interaction.updated', {
+        publish('chat.message.interaction.updated', {
             sessionId: id,
             interactionId,
             status: 'answered',
@@ -1422,7 +1453,7 @@ export function createChatRoute(log, chat, dependencies = {}) {
         const assistantId = randomUUID();
         activeSessions.add(slot);
         startTurn(id, assistantId);
-        chatBus.emit('chat.message.pending', {
+        publish('chat.message.pending', {
             sessionId: id,
             assistantId,
             turnId: assistantId,
@@ -1480,7 +1511,7 @@ export function createChatRoute(log, chat, dependencies = {}) {
                     latestFound.block.status = 'answered';
                     latestFound.block.revision += 1;
                     writeSession(latest);
-                    chatBus.emit('chat.message.interaction.updated', {
+                    publish('chat.message.interaction.updated', {
                         sessionId: id,
                         interactionId,
                         status: 'answered',
@@ -1506,7 +1537,7 @@ export function createChatRoute(log, chat, dependencies = {}) {
             latestFound.block.revision += 1;
             writeSession(latest);
         }
-        chatBus.emit('chat.message.interaction.updated', {
+        publish('chat.message.interaction.updated', {
             sessionId: id,
             interactionId,
             status: 'cancelled',
@@ -1582,7 +1613,7 @@ export function createChatRoute(log, chat, dependencies = {}) {
         //  · form/choices → "以对话作答":这里把 UI 块落定为 cancelled(worker 侧会同步取消
         //    store 记录并把用户原话喂回 run,见 broker.resolveWithChatReply),表单按钮不再假活;
         //  · approval(危险操作审批/账本对账)→ 安全门槛不许绕,409 让用户先作答。
-        if (session.agentKind === 'openai' && (session.agentMode ?? 'sdk') === 'daemon') {
+        if (session.agentKind === 'openai') {
             for (const msg of session.messages) {
                 for (const block of msg.blocks ?? []) {
                     if (block.type !== 'interaction' || block.status !== 'pending')
@@ -1602,7 +1633,7 @@ export function createChatRoute(log, chat, dependencies = {}) {
                     }
                     block.status = 'cancelled';
                     block.revision += 1;
-                    chatBus.emit('chat.message.interaction.updated', {
+                    publish('chat.message.interaction.updated', {
                         sessionId: id,
                         interactionId: block.id,
                         status: 'cancelled',
@@ -1625,12 +1656,12 @@ export function createChatRoute(log, chat, dependencies = {}) {
         if (session.messages.length === 1)
             session.title = formatTitle(body.content);
         writeSession(session);
-        chatBus.emit('chat.message', { sessionId: id, message: userMsg });
+        publish('chat.message', { sessionId: id, message: userMsg });
         const assistantId = randomUUID();
         // v0.57:接受即预登记回合(activeStreams + 心跳 + 持久 lastTurn=running),消除
         // "lastTurn=running 但无 activeStreams"的竞态,让断线补偿/轮询从此刻起就确定。
         startTurn(id, assistantId);
-        chatBus.emit('chat.message.pending', {
+        publish('chat.message.pending', {
             sessionId: id,
             assistantId,
             turnId: assistantId,
@@ -1656,11 +1687,17 @@ export function createChatStreamRoute() {
             start(controller) {
                 const enc = new TextEncoder();
                 let closed = false;
+                /**
+                 * 写一帧。带 `frameId` 的写 `id:` —— 浏览器会记住它,重连时自动带
+                 * `Last-Event-ID` 回来,服务端据此逐事件补发(见下方的续传段)。
+                 * 补偿类帧(snapshot/resume 等)不带帧号,不参与游标。
+                 */
                 const send = (event, data) => {
                     if (closed)
                         return;
+                    const frameId = data && typeof data === 'object' ? data.frameId : undefined;
                     try {
-                        controller.enqueue(enc.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`));
+                        controller.enqueue(enc.encode(`${typeof frameId === 'number' ? `id: ${frameId}\n` : ''}event: ${event}\ndata: ${JSON.stringify(data)}\n\n`));
                     }
                     catch {
                         closed = true;
@@ -1676,6 +1713,7 @@ export function createChatStreamRoute() {
                     'chat.message.interaction.updated',
                     'chat.message.complete',
                     'chat.message.error', // v0.57:明确的回合异常终止(带 turnId)
+                    'chat.resync.required', // 阶段 2:游标失效,客户端须靠快照/补拉重建
                     'chat.message.heartbeat', // v0.57:流式进行中心跳(带 turnId),区分"还在生成"vs"卡死"
                 ];
                 const handlers = [];
@@ -1690,18 +1728,39 @@ export function createChatStreamRoute() {
                     chatBus.on(event, fn);
                     handlers.push({ event, fn });
                 }
+                // ── 逐事件续传(阶段 2)──
+                // 浏览器重连自动带 Last-Event-ID;断点还在窗口内就精确补发,滚出窗口才退回快照重建。
+                // 放在订阅之后:JS 单线程,这中间不会有事件被 emit,既不漏也不重。
+                const lastEventHeader = c.req.header('Last-Event-ID') ?? c.req.query('lastEventId') ?? '';
+                const lastEventId = Number.parseInt(lastEventHeader, 10);
+                let resumed = false;
+                if (Number.isFinite(lastEventId) && lastEventId > 0) {
+                    const replay = framesSince(sessionId, lastEventId);
+                    if (replay.kind === 'frames') {
+                        // 🔴 补发时必须带上帧号:日志里存的是**发布前**的 data(没有 frameId),
+                        // 直接发会让 `id:` 缺失、客户端游标停在断点不前进,下次重连又从头补一遍。
+                        for (const frame of replay.frames) {
+                            send(frame.event, { ...frame.data, frameId: frame.id });
+                        }
+                        resumed = true;
+                    }
+                    else {
+                        // 🔴 有洞的序列比没有更危险(客户端会以为自己是完整的)——明确要求重建。
+                        send('chat.resync.required', { sessionId, reason: 'cursor-out-of-window' });
+                    }
+                }
                 // ── 断线补偿(v0.57 核心)──
                 // 新连接(刷新/切会话/重连)时,后端据"进行中快照 + 持久 lastTurn"主动补偿,
                 // 让"回合已结束/仍在进行"成为确定事实,客户端无需超时猜测。同步执行(JS 单线程):
                 // 订阅 chatBus 与本段之间不会有事件被 emit → 既不漏也不重。
-                const active = activeStreams.get(sessionId);
+                const active = resumed ? null : activeStreams.get(sessionId);
                 if (active) {
                     // 回合仍进行中(本进程)→ pending + 旧 snapshot(兼容老客户端)+ 新 resume(带 turnId/seq/status)。
                     send('chat.message.pending', { sessionId, assistantId: active.assistantId, turnId: active.turnId, seq: active.seq, ts: active.ts });
                     send('chat.message.snapshot', { sessionId, assistantId: active.assistantId, ts: active.ts, blocks: active.blocks });
                     send('chat.message.resume', { sessionId, assistantId: active.assistantId, turnId: active.turnId, ts: active.ts, blocks: active.blocks, status: 'running', seq: active.seq });
                 }
-                else {
+                else if (!resumed) {
                     // 无在途回合 → 查持久 lastTurn(轮询/补偿权威),确定性补发终止信号。
                     const s = readSession(sessionId);
                     const lt = s ? deriveLastTurn(s) : null;