@bolloon/bolloon-agent 0.6.0 → 0.6.1

package/dist/web/server.js

@@ -88,7 +88,8 @@ import { createHyperswarmCommunicator, createTopic, KeyManager, AgentAuthManager
 import { initMinimax } from '../constraints/index.js';
 import { createAgentSession } from '../agents/pi-sdk.js';
 // **K5 步骤④ (入口投递)**: 把一次入口执行投进会话 Actor 的 mailbox ⇒ 同一会话身份的输入排队执行
-import { deliverThroughActor } from '../kernel/channel-actor.js';
+import { deliverThroughActor, getChannelQueue, abortActorsOfChannel } from '../kernel/channel-actor.js';
+import { requireRunExecution } from '../agents/execution-entry.js'; // K8 唯一执行入口的取用助手 (脱挂坑见该文件头)   // K8: 待办执行经内核邮箱串行
 import { irohTransport } from '../network/iroh-transport.js';
 import { createAgentDelegateApp } from './agent-delegate-server.js';
 import { createIrohDelegateTransport } from './iroh-delegate-transport.js';
@@ -96,6 +97,14 @@ import { verifyMessage, isAddress, getAddress } from 'viem';
 // 2026-07-05: peer 目录管理 + manifest 协议
 import * as peerFs from '../network/peer-fs.js';
 import { loadLocalResources, writeRemoteResources } from '../network/peer-resource-bridge.js';
+/**
+ * 2026-10-02 (K8): 通道拿**唯一执行入口**的统一姿势 —— `runExecution` 在 `AgentSession` 上是**可选**的
+ * (接口允许实现自定义), 所以直接调会报 possibly-undefined。这里**响亮失败**而不是 `!` 断言:
+ * 拿不到入口就说明"通道又要直呼 prompt 了", 必须当场炸掉, 不许静默回落 (否则收口只剩纸面)。
+ */
+// 2026-10-02: 实现搬到 `src/agents/execution-entry.ts` (为了能被行为门测到 —— 那个"脱挂"坑源码看不出)。
+//   ⚠️ 曾经这里写的是 `return agent.runExecution;` (等于脱挂方法) ⇒ 调用时 this===undefined
+//   ⇒ 实例里 supervisor / 心跳 / 任务三条路径都报 `... reading 'applyExecutionRequest'`。
 // 前端资源路径: 兼容 src 运行 + dist 运行 + npm 全局安装
 // - src 跑 (tsx):   __dirname = .../src/web  →  .../dist/web
 // - dist 跑 (npm):  __dirname = .../dist/web → 自身就是 web 根
@@ -587,7 +596,8 @@ async function triggerRemoteFollowup(channelId, remoteReply, fromPublicKey, roun
                 broadcast({ type: 'followup-step', ...event, channelId }, channelId);
             }
         };
-        const fullResponse = await deliverThroughActor(agent, () => agent.promptStream(markedPrompt, streamCallback, undefined, channelId));
+        // 2026-10-02 (K8): 经唯一入口 `runExecution` —— 参数与派发**完全一致** ⇒ 按构造零行为改变
+        const fullResponse = await deliverThroughActor(agent, () => requireRunExecution(agent)({ input: markedPrompt, onStream: streamCallback, channelId }));
         if (!fullResponse.trim())
             return;
         // 广播续看结果给 UI
@@ -915,7 +925,8 @@ async function handleV3P2PMessage(parsed, conn, comm) {
                 }
             };
             const agent = await getAgentForChannel(channelId, ch.did || '', ch.name, ch.didDocRef);
-            fullResponse = await deliverThroughActor(agent, () => agent.promptStream(fullPrompt, streamCallback, undefined, channelId));
+            // 2026-10-02 (K8): 同上 (零差量)
+            fullResponse = await deliverThroughActor(agent, () => requireRunExecution(agent)({ input: fullPrompt, onStream: streamCallback, channelId }));
             // 2026-07-06: 防御性兜底
             if (!fullResponse.trim()) {
                 fullResponse = '⚠️ AI 未返回内容, 请重试';
@@ -1067,7 +1078,8 @@ async function handleV3P2PMessage(parsed, conn, comm) {
             // 临时用 channelId = "__collab__" 拿个一次性 agent
             const collabChannelId = `__collab_${senderKey.substring(0, 8)}__`;
             const agent = await getAgentForChannel(collabChannelId, '', `collab-${senderKey.substring(0, 8)}`, undefined);
-            const resultText = await deliverThroughActor(agent, () => agent.prompt(fullPrompt));
+            // 2026-10-02 (K8): 经唯一入口 (零差量: channelId 就是取这个 agent 用的 collabChannelId)
+            const resultText = await deliverThroughActor(agent, () => requireRunExecution(agent)({ input: fullPrompt, channelId: collabChannelId }));
             const reply = JSON.stringify({
                 v: 3,
                 op: 'agent.collab.reply',
@@ -1681,7 +1693,8 @@ export async function createWebServer(port = 3000, options = {}) {
                     // 跨预算继续: 新 Run 必须挂在同一个 Goal 下 (setGoalId), 并带上上一个 Run 的非幂等守卫
                     agent.setGoalId?.(goal.goalId);
                     agent.setContinuationGuards?.(r.guards || []);
-                    const reply = await deliverThroughActor(agent, () => agent.prompt(r.instruction));
+                    // 2026-10-02 (K8): 经唯一入口 (零差量: agent 本来就是按 goal.channelId 解析的)
+                    const reply = await deliverThroughActor(agent, () => requireRunExecution(agent)({ input: r.instruction, channelId: goal.channelId }));
                     // 注意: prompt 收尾会清空 currentRunId → 必须读 lastRunId (否则会拿上一条 run 做决策)
                     const runId = agent.getLastRunId?.() || agent.getRunId?.();
                     return { runId, status: 'done', reply: typeof reply === 'string' ? reply.slice(0, 500) : undefined };
@@ -1793,6 +1806,9 @@ export async function createWebServer(port = 3000, options = {}) {
             console.warn('[mcp] 初始化失败 (非致命):', e?.message?.slice(0, 120));
         }
     })();
+    // 2026-07-28: 用户 DID 身份端点 — 静默生成/加载, 持久化到 ~/.bolloon/identity/user.json
+    let userIdentityCache = null;
+    const IDENTITY_DIR = `${process.env.HOME || '/tmp'}/.bolloon/identity`;
     // 2026-08-08: DID 目录启动接入 — 回填既有磁盘数据 + 启动 OrbitDB 自动复制.
     //   fire-and-forget: 不阻塞启动; 失败静默 (catalog 是增强层, 原磁盘路径永远可用).
     (async () => {
@@ -2491,7 +2507,8 @@ export async function createWebServer(port = 3000, options = {}) {
                                     new Promise((res) => setTimeout(() => res(null), 8000)),
                                 ]);
                                 if (agent && typeof agent.promptStream === 'function') {
-                                    llm = (p) => deliverThroughActor(agent, () => agent.promptStream(p, () => { }, undefined, local.id));
+                                    // 2026-10-02 (K8): 经唯一入口 (零差量: channelId=local.id 与旧调用同一个)
+                                    llm = (p) => deliverThroughActor(agent, () => requireRunExecution(agent)({ input: p, onStream: () => { }, channelId: local.id }));
                                 }
                             }
                         }
@@ -2543,7 +2560,8 @@ export async function createWebServer(port = 3000, options = {}) {
                             throw new Error('无可用 agent, 跳过定时任务');
                         }
                         // 前缀 [cron] 标记后台执行来源 (供审计/日志区分人类消息与定时任务)
-                        await deliverThroughActor(agent, () => agent.promptStream(`[cron] ${job.name}: ${job.prompt}`, () => { }, undefined, target.id));
+                        // 2026-10-02 (K8): 经唯一入口 (零差量: channelId=target.id)
+                        await deliverThroughActor(agent, () => requireRunExecution(agent)({ input: `[cron] ${job.name}: ${job.prompt}`, onStream: () => { }, channelId: target.id }));
                     },
                 });
                 global.cronScheduler = cronHandle;
@@ -2595,7 +2613,8 @@ ${goalDesc}
 现在是否要主动联系其中某个智能体? 只输出一个 JSON 对象, 不要任何其他文字:
 {"initiate": true 或 false, "goalAchieved": true 或 false, "targetPeerPublicKey": "对方 pk", "targetChannelId": "对方渠道 id", "message": "你要说的话"}
 若不想发起, 输出 {"initiate": false}。`;
-                    const raw = await deliverThroughActor(agent, () => agent.promptStream(prompt, () => { }, undefined, local.id));
+                    // 2026-10-02 (K8): 经唯一入口 (零差量: channelId=local.id)
+                    const raw = await deliverThroughActor(agent, () => requireRunExecution(agent)({ input: prompt, onStream: () => { }, channelId: local.id }));
                     const m = raw.match(/\{[\s\S]*\}/);
                     if (!m)
                         return { initiate: false };
@@ -3941,7 +3960,8 @@ fetchState();
                 req.docContent ? `\n资料内容:\n${req.docContent}` : '',
                 `\n(来自 agent ${req.fromAgentId || 'unknown'})，请直接给出可交付结果。`,
             ].join('');
-            const out = await deliverThroughActor(agent, () => agent.prompt(task));
+            // 2026-10-02 (K8): 经唯一入口 (零差量: agent 就是按 ch.id 取的)
+            const out = await deliverThroughActor(agent, () => requireRunExecution(agent)({ input: task, channelId: ch.id }));
             const text = String(out || '').trim();
             if (!text || text.startsWith('❌') || text.startsWith('[AI 服务调用失败]')) {
                 return { ok: false, summary: text.slice(0, 800) || '(空结果)', error: 'execution-failed' };
@@ -4312,8 +4332,11 @@ fetchState();
         res.json([]); // tool-manifest 已废弃, 工具列表由 pi-sdk.ts this.tools 维护
     });
     // 2026-07-28: 用户 DID 身份端点 — 静默生成/加载, 持久化到 ~/.bolloon/identity/user.json
-    let userIdentityCache = null;
-    const IDENTITY_DIR = `${process.env.HOME || '/tmp'}/.bolloon/identity`;
+    // 2026-10-02: **声明位置有硬约束** —— 必须早于下面 did-catalog 的启动 IIFE。
+    //   踩过一次: `loadOrCreateUserIdentity()` 在 did-catalog 的 IIFE (1876 附近) 里被 `await` 调用,
+    //   而 `let` 声明在 4200+ 行之外 ⇒ 微任务先跑到那次调用 ⇒ **TDZ** ("Cannot access 'userIdentityCache'
+    //   before initialization") ⇒ 开机时 **OrbitDB 复制根本没起来**, 只在日志里留了一条"非致命"。
+    //   修法: 把声明挪到**首次使用之前** (同作用域, 语义不变); 位置由下面的门锁住。
     async function loadOrCreateUserIdentity() {
         if (userIdentityCache)
             return userIdentityCache;
@@ -4902,935 +4925,844 @@ fetchState();
             : channel?.autoInvokeTools !== false;
         // 捕获外层 channel 到独立变量, 避免被 try 块内 (line 740+) 的 const channel 遮蔽
         const channelForJudgment = channel;
-        // per-channel queue 检查: 已在跑就入队, 等当前跑完自动接上
+        // K8 正刀 (2026-10-02): **每条消息都投内核邮箱** —— 取代原来的 check-then-set + 通道自带的 queue。
+        //   为什么 (三条, 按重要性):
+        //     (a) 同通道串行交给内核邮箱 (与 K5 同一条语义), 通道不再兼任调度器;
+        //     (b) 消灭 `finishChannelRun` **同步**置 `running = false` 后**异步** handoff 造成的**静默丢消息**窗口
+        //         (先行门 `src/test/k8-mailbox-scheduling.test.ts` ③ 已把该机制等价复刻并判红);
+        //     (c) 过去排队消息只能走 `runMessageFromQueue` 的**简化版** (无 judgment hint / persona / slash / 附件上下文),
+        //         现在每条消息都走**同一条**完整路径 —— 这是行为改善, **不是零差量** (已在 log 如实记)。
         const runState = getOrCreateRunState(channelId);
-        if (runState.running) {
-            // 2026-07-15 修 Bug 8: 入队时保留 attachments + channelDid, 否则下一轮执行时会丢附件
-            runState.queue.push({
-                channelId,
-                text,
-                boundWalletAddress,
-                autoToolsEnabled,
-                attachments: parsedAttachments,
-                channelDid,
-            });
+        const runChannelMessage = async () => {
+            runState.running = true; // 观测口径 (串行权威已归邮箱)
+            // K8 收尾 (2026-10-02): **中止位归内核 actor** —— `beginCancellation()` 每次执行开一个新 controller
+            //   (与邮箱串行一致), web 不再自己持 abortController。取到 agent 后立刻开户 (见下面 getAgentForChannel 之后)。
+            let abortSignal;
+            // 2026-07-04: pivot loop safety net — 防止 LLM hang (minimax M3
+            //   偶尔反复 think 不输出 <final gen>, pivot 连 5 次无进展时会 hang 在
+            //   quality 评估). setTimeout 让 LLM 客户端收 signal 主动 break.
+            // 2026-07-06: 30s 太短 — minimax M3 单次 LLM 约 10s, pivot 默认 moderate profile 30 iter
+            //   留 ~300s. 之前 30s 自动 abort 时, 一次"你好"调用就被截断, 用户看到 ❌ 循环异常 + 空内容.
+            //   改为 5 分钟 = 5x 实际耗时上限.
+            const PIVOT_FORCE_TIMEOUT_MS = 5 * 60 * 1000;
+            const forceTimeout = setTimeout(() => {
+                console.warn(`[server] /message pivot 强制 timeout (${PIVOT_FORCE_TIMEOUT_MS}ms), aborting`);
+                // K8 收尾: 中止经 actor; 拿不到 actor 就**如实记**"没能中止" (不静默)
+                const act = agent?.actor;
+                if (act?.abort)
+                    act.abort('pivot 强制 timeout');
+                else
+                    console.warn('[K8] 强制 timeout 时没有 actor ⇒ 本次没能中止 (如实记)');
+            }, PIVOT_FORCE_TIMEOUT_MS);
             broadcastQueueUpdate(channelId);
-            console.log(`[queue] /message 入队 channel=${channelId}, queue len=${runState.queue.length}, attach=${parsedAttachments.length}`);
-            return;
-        }
-        runState.running = true;
-        runState.abortController = new AbortController();
-        // 2026-07-04: pivot loop safety net — 防止 LLM hang (minimax M3
-        //   偶尔反复 think 不输出 <final gen>, pivot 连 5 次无进展时会 hang 在
-        //   quality 评估). setTimeout 让 LLM 客户端收 signal 主动 break.
-        // 2026-07-06: 30s 太短 — minimax M3 单次 LLM 约 10s, pivot 默认 moderate profile 30 iter
-        //   留 ~300s. 之前 30s 自动 abort 时, 一次"你好"调用就被截断, 用户看到 ❌ 循环异常 + 空内容.
-        //   改为 5 分钟 = 5x 实际耗时上限.
-        const PIVOT_FORCE_TIMEOUT_MS = 5 * 60 * 1000;
-        const forceTimeout = setTimeout(() => {
-            console.warn(`[server] /message pivot 强制 timeout (${PIVOT_FORCE_TIMEOUT_MS}ms), aborting`);
-            runState.abortController?.abort();
-        }, PIVOT_FORCE_TIMEOUT_MS);
-        broadcastQueueUpdate(channelId);
-        // 2026-07-01 (v0.2.5): hoist sessionKey 到 try 外, 让 finally 块的 saveCurrentSession 能用
-        const sessionKey = `${channelId}:${currentSessionId}`;
-        let agent = null;
-        try {
-            agent = await getAgentForChannel(channelId, realChannelDid, realChannelName, realChannelDidDoc);
-            let fullResponse = '';
-            // P0.5: 注入门回传的 usedIds, 落 session message metadata, UI 可查
-            let usedJudgmentIds = [];
-            const streamCallback = (event) => {
-                // P0.5: 捕获注入门回传
-                if (event.type === 'used_judgments' && Array.isArray(event.usedIds)) {
-                    usedJudgmentIds = event.usedIds;
-                    // 同步推给前端 (用于 finalizeTimelineAsMessage 时给 addMessage 传 usedIds)
-                    broadcast({ type: 'used_judgments', usedIds: usedJudgmentIds }, channelId);
-                    return;
-                }
-                // 阶段事件 (注入门 / D 触发)
-                if (event.type === 'phase') {
-                    broadcast({
-                        type: 'phase',
-                        phase: event.phase,
-                        detail: event.detail,
-                        usedCount: event.usedCount,
-                    }, channelId);
-                    return;
-                }
-                // 同时发送给流式显示和工作流显示
-                if (event.type === 'token' || event.type === 'thinking') {
-                    broadcast({ type: 'stream', streamType: event.type, content: event.content }, channelId);
-                    // 同时作为 workflow_step 显示（用于动态 loop 循环）
-                    if (event.content) {
-                        broadcast({ type: 'workflow_step', step: 'AI 思考', content: event.content.substring(0, 100) }, channelId);
+            // 2026-07-01 (v0.2.5): hoist sessionKey 到 try 外, 让 finally 块的 saveCurrentSession 能用
+            const sessionKey = `${channelId}:${currentSessionId}`;
+            let agent = null;
+            try {
+                agent = await getAgentForChannel(channelId, realChannelDid, realChannelName, realChannelDidDoc);
+                // K8 收尾: 这一次执行的取消位由 actor 开 (web 只持有它返回的 signal)
+                abortSignal = agent.actor ? agent.actor.beginCancellation() : undefined;
+                let fullResponse = '';
+                // P0.5: 注入门回传的 usedIds, 落 session message metadata, UI 可查
+                let usedJudgmentIds = [];
+                const streamCallback = (event) => {
+                    // P0.5: 捕获注入门回传
+                    if (event.type === 'used_judgments' && Array.isArray(event.usedIds)) {
+                        usedJudgmentIds = event.usedIds;
+                        // 同步推给前端 (用于 finalizeTimelineAsMessage 时给 addMessage 传 usedIds)
+                        broadcast({ type: 'used_judgments', usedIds: usedJudgmentIds }, channelId);
+                        return;
                     }
-                }
-                else if (event.type === 'reply-preview') {
-                    // 2026-07-06: pivot 每 iter 把完整 reply 推给前端 — 前端可以更新临时气泡
-                    //   等 loop 退完 type=ai 终文事件覆盖. 不依赖整个 promptWithPivotLoop 返回.
-                    //   这样 pivot 中途网络慢 / 5min-long 任务, 用户看到中间内容不是空白 + '任务处理超时'.
-                    broadcast({
-                        type: 'reply-preview',
-                        content: event.content,
-                        iteration: event.iteration,
-                    }, channelId);
-                }
-                else if (event.type === 'status' || event.type === 'tool') {
-                    broadcast({ type: 'status', tool: event.tool, content: event.content }, channelId);
-                    broadcast({ type: 'workflow_step', step: event.tool || '系统', content: event.content }, channelId);
-                    console.log(`[SSE 广播] workflow_step: step=${event.tool}, content="${event.content?.substring(0, 80)}..."`);
-                    // 2026-08-02: 本地 @ 远端时, 工作流步骤也推给 P2P 对话框 (rcm-log)
-                    //   — 用户报告"进程看不到": 本地智能体执行过程 (即使没调工具, 只有 status/tool 事件)
-                    //   也要在 P2P 对话框显示, 让用户看到"进程"
-                    try {
-                        const rs = channelRunState.get(channelId);
-                        if (rs?.remoteFollowup?.remoteChannelId) {
-                            broadcast({
-                                type: 'remote-chat-step',
-                                channelId: rs.remoteFollowup.remoteChannelId,
-                                stepType: 'step_start',
-                                tool: event.tool || '工作流',
-                                content: event.content,
-                                localStep: true,
-                            });
+                    // 阶段事件 (注入门 / D 触发)
+                    if (event.type === 'phase') {
+                        broadcast({
+                            type: 'phase',
+                            phase: event.phase,
+                            detail: event.detail,
+                            usedCount: event.usedCount,
+                        }, channelId);
+                        return;
+                    }
+                    // 同时发送给流式显示和工作流显示
+                    if (event.type === 'token' || event.type === 'thinking') {
+                        broadcast({ type: 'stream', streamType: event.type, content: event.content }, channelId);
+                        // 同时作为 workflow_step 显示（用于动态 loop 循环）
+                        if (event.content) {
+                            broadcast({ type: 'workflow_step', step: 'AI 思考', content: event.content.substring(0, 100) }, channelId);
                         }
                     }
-                    catch { /* 非致命 */ }
-                }
-                else if (event.type === 'step_start' || event.type === 'step_done' || event.type === 'step_error') {
-                    // 2026-06-15: 步骤状态机事件 — 原样转发 (前端 step-timeline 组件订阅)
-                    broadcast({
-                        type: event.type,
-                        tool: event.tool,
-                        content: event.content,
-                        success: event.success,
-                        output: event.output,
-                        error: event.error,
-                        args: event.args,
-                    }, channelId);
-                    // 2026-08-02: 对称显示 — 本地智能体 @ 远端时, 本地工具调用过程也推给 P2P 对话框
-                    //   (rcm-log): remote-chat-step 事件带 remoteChannelId, 前端按对话框匹配显示
-                    try {
-                        const rs = channelRunState.get(channelId);
-                        if (rs?.remoteFollowup?.remoteChannelId) {
-                            broadcast({
-                                type: 'remote-chat-step',
-                                channelId: rs.remoteFollowup.remoteChannelId,
-                                stepType: event.type,
-                                tool: event.tool,
-                                content: event.content,
-                                success: event.success,
-                                output: event.output,
-                                error: event.error,
-                                args: event.args,
-                                localStep: true, // 标记: 这是本地智能体的工具过程 (区别于对方转发的)
-                            });
+                    else if (event.type === 'reply-preview') {
+                        // 2026-07-06: pivot 每 iter 把完整 reply 推给前端 — 前端可以更新临时气泡
+                        //   等 loop 退完 type=ai 终文事件覆盖. 不依赖整个 promptWithPivotLoop 返回.
+                        //   这样 pivot 中途网络慢 / 5min-long 任务, 用户看到中间内容不是空白 + '任务处理超时'.
+                        broadcast({
+                            type: 'reply-preview',
+                            content: event.content,
+                            iteration: event.iteration,
+                        }, channelId);
+                    }
+                    else if (event.type === 'status' || event.type === 'tool') {
+                        broadcast({ type: 'status', tool: event.tool, content: event.content }, channelId);
+                        broadcast({ type: 'workflow_step', step: event.tool || '系统', content: event.content }, channelId);
+                        console.log(`[SSE 广播] workflow_step: step=${event.tool}, content="${event.content?.substring(0, 80)}..."`);
+                        // 2026-08-02: 本地 @ 远端时, 工作流步骤也推给 P2P 对话框 (rcm-log)
+                        //   — 用户报告"进程看不到": 本地智能体执行过程 (即使没调工具, 只有 status/tool 事件)
+                        //   也要在 P2P 对话框显示, 让用户看到"进程"
+                        try {
+                            const rs = channelRunState.get(channelId);
+                            if (rs?.remoteFollowup?.remoteChannelId) {
+                                broadcast({
+                                    type: 'remote-chat-step',
+                                    channelId: rs.remoteFollowup.remoteChannelId,
+                                    stepType: 'step_start',
+                                    tool: event.tool || '工作流',
+                                    content: event.content,
+                                    localStep: true,
+                                });
+                            }
                         }
+                        catch { /* 非致命 */ }
                     }
-                    catch { /* 非致命 */ }
-                    // 2026-06-16: 累积 step 到 runState, 供 /api/loop/inspect 读取
-                    try {
-                        if (event.type === 'step_done' || event.type === 'step_error') {
+                    else if (event.type === 'step_start' || event.type === 'step_done' || event.type === 'step_error') {
+                        // 2026-06-15: 步骤状态机事件 — 原样转发 (前端 step-timeline 组件订阅)
+                        broadcast({
+                            type: event.type,
+                            tool: event.tool,
+                            content: event.content,
+                            success: event.success,
+                            output: event.output,
+                            error: event.error,
+                            args: event.args,
+                        }, channelId);
+                        // 2026-08-02: 对称显示 — 本地智能体 @ 远端时, 本地工具调用过程也推给 P2P 对话框
+                        //   (rcm-log): remote-chat-step 事件带 remoteChannelId, 前端按对话框匹配显示
+                        try {
                             const rs = channelRunState.get(channelId);
-                            if (rs) {
-                                if (!rs.lastSteps)
-                                    rs.lastSteps = [];
-                                rs.lastSteps.push({
-                                    name: String(event.tool || event.content || 'step').slice(0, 60),
-                                    status: event.type === 'step_error' ? 'failed' : (event.success === false ? 'failed' : 'ok'),
-                                    durationMs: typeof event.durationMs === 'number' ? event.durationMs : undefined,
-                                    output: event.output ? String(event.output).slice(0, 800) : (event.error ? String(event.error).slice(0, 800) : undefined),
+                            if (rs?.remoteFollowup?.remoteChannelId) {
+                                broadcast({
+                                    type: 'remote-chat-step',
+                                    channelId: rs.remoteFollowup.remoteChannelId,
+                                    stepType: event.type,
+                                    tool: event.tool,
+                                    content: event.content,
+                                    success: event.success,
+                                    output: event.output,
+                                    error: event.error,
+                                    args: event.args,
+                                    localStep: true, // 标记: 这是本地智能体的工具过程 (区别于对方转发的)
                                 });
                             }
                         }
+                        catch { /* 非致命 */ }
+                        // 2026-06-16: 累积 step 到 runState, 供 /api/loop/inspect 读取
+                        try {
+                            if (event.type === 'step_done' || event.type === 'step_error') {
+                                const rs = channelRunState.get(channelId);
+                                if (rs) {
+                                    if (!rs.lastSteps)
+                                        rs.lastSteps = [];
+                                    rs.lastSteps.push({
+                                        name: String(event.tool || event.content || 'step').slice(0, 60),
+                                        status: event.type === 'step_error' ? 'failed' : (event.success === false ? 'failed' : 'ok'),
+                                        durationMs: typeof event.durationMs === 'number' ? event.durationMs : undefined,
+                                        output: event.output ? String(event.output).slice(0, 800) : (event.error ? String(event.error).slice(0, 800) : undefined),
+                                    });
+                                }
+                            }
+                        }
+                        catch { /* non-fatal */ }
+                    }
+                    else if (event.type === 'error') {
+                        broadcast({ type: 'error', content: event.content }, channelId);
+                    }
+                };
+                console.log(`[消息处理] 开始处理用户消息, channelId: ${channelId}, sessionId: ${currentSessionId}`);
+                // 2026-08-02 fix: 预激活远端协作续看 — 用户消息含 @远端 时立即激活 remoteFollowup.
+                //   之前只在 routeMentionsInReply (AI 回复后) 激活 → 首次 @ 时本地智能体的工具调用
+                //   (step 事件) 发生在激活前, P2P 对话框看不到本地工具过程 (用户报告"进程看不到").
+                //   现在收到消息即激活 → promptStream 期间的工具 step 也能 broadcast remote-chat-step.
+                try {
+                    const mentionMatch = /@([一-龥A-Za-z0-9_\-]{1,30})/.exec(text);
+                    if (mentionMatch && remoteChannelCache.size > 0) {
+                        const targetName = mentionMatch[1];
+                        let hitRemoteId = null;
+                        for (const list of remoteChannelCache.values()) {
+                            const rc = list.find((c) => c.name === targetName);
+                            if (rc) {
+                                hitRemoteId = String(rc.id);
+                                break;
+                            }
+                        }
+                        if (hitRemoteId) {
+                            const rs = channelRunState.get(channelId);
+                            if (rs && !rs.remoteFollowup) {
+                                rs.remoteFollowup = { rounds: 0, maxRounds: 3, remoteChannelId: hitRemoteId };
+                                console.log(`[v3-followup] ${channelId} 预激活远端协作续看 → ${hitRemoteId} (消息含 @${targetName})`);
+                            }
+                        }
                     }
-                    catch { /* non-fatal */ }
                 }
-                else if (event.type === 'error') {
-                    broadcast({ type: 'error', content: event.content }, channelId);
+                catch { /* 预激活失败不阻塞 */ }
+                // 将真实 DID 作为上下文前缀，让 AI 使用真实的 DID 而不是自己编造的
+                let contextHint = '';
+                // 2026-08-14: 本地消息带 gateway 链接 → 自动加入, 结果注入 agent 上下文 (5s 上限, 不阻塞 LLM)
+                try {
+                    const { maybeAutoJoinGateway } = await import('../agents/gateway-network.js');
+                    const gwNote = await Promise.race([
+                        maybeAutoJoinGateway(text),
+                        new Promise((resolve) => setTimeout(() => resolve(null), 5000)),
+                    ]);
+                    if (gwNote)
+                        contextHint += `[系统上下文] ${gwNote}\n`;
+                }
+                catch { /* 自动加入失败不阻塞 */ }
+                // 2026-08-02: slash 命令提示 (在 /message 开头解析, 这里注入)
+                if (slashCommandHint)
+                    contextHint += slashCommandHint;
+                if (realChannelDid)
+                    contextHint += `[系统上下文] 当前频道名称: ${realChannelName}, 你的真实 DID: ${realChannelDid}\n`;
+                // v3 新增: 标识发送方 — 让 AI 分清内部 owner vs 远端访客
+                contextHint += `[系统上下文] 消息来源: 本地 (channel 内部 owner / 此机器上的用户). 称呼对方时用 "你" 或 "用户" 即可.\n`;
+                if (boundWalletAddress) {
+                    contextHint += `[系统上下文] 已绑定的加密钱包地址: ${boundWalletAddress}。当用户授权或启用自动工具调用时, 可使用该地址发起链上操作。\n`;
+                }
+                if (autoToolsEnabled) {
+                    contextHint += `[系统上下文] 自动工具调用已开启: 你可以使用受信任的本地工具 (shell / 文件 / skill) 而无需逐次询问用户。\n`;
                 }
-            };
-            console.log(`[消息处理] 开始处理用户消息, channelId: ${channelId}, sessionId: ${currentSessionId}`);
-            // 2026-08-02 fix: 预激活远端协作续看 — 用户消息含 @远端 时立即激活 remoteFollowup.
-            //   之前只在 routeMentionsInReply (AI 回复后) 激活 → 首次 @ 时本地智能体的工具调用
-            //   (step 事件) 发生在激活前, P2P 对话框看不到本地工具过程 (用户报告"进程看不到").
-            //   现在收到消息即激活 → promptStream 期间的工具 step 也能 broadcast remote-chat-step.
-            try {
-                const mentionMatch = /@([一-龥A-Za-z0-9_\-]{1,30})/.exec(text);
-                if (mentionMatch && remoteChannelCache.size > 0) {
-                    const targetName = mentionMatch[1];
-                    let hitRemoteId = null;
-                    for (const list of remoteChannelCache.values()) {
-                        const rc = list.find((c) => c.name === targetName);
-                        if (rc) {
-                            hitRemoteId = String(rc.id);
-                            break;
+                else {
+                    contextHint += `[系统上下文] 自动工具调用已关闭: 每次执行工具前必须先与用户确认。\n`;
+                }
+                // 2026-08-02 fix: 本地路径注入远端 channel 目录 (dirHint) — 之前只有远端路径 (agent.chat.send)
+                //   有 dirHint, 本地智能体对话时看不到远端 channel 列表 → 无法 @ 远程智能体交流.
+                //   现在注入: 可用渠道列表 (本地 + 远端), 让 LLM 知道 @ 谁、发什么.
+                try {
+                    const localChs = await loadChannels();
+                    const remoteForDir = [];
+                    for (const [peerPk, list] of remoteChannelCache.entries()) {
+                        for (const ch of list) {
+                            remoteForDir.push({ ...ch, _ownerPublicKey: peerPk });
                         }
                     }
-                    if (hitRemoteId) {
-                        const rs = channelRunState.get(channelId);
-                        if (rs && !rs.remoteFollowup) {
-                            rs.remoteFollowup = { rounds: 0, maxRounds: 3, remoteChannelId: hitRemoteId };
-                            console.log(`[v3-followup] ${channelId} 预激活远端协作续看 → ${hitRemoteId} (消息含 @${targetName})`);
+                    if (localChs.length > 0 || remoteForDir.length > 0) {
+                        contextHint += '[系统上下文] 可用渠道 (你可以在回复中写 "@渠道名 消息内容" 给它们发消息, 消息会持久化到目标 channel 的 session):\n';
+                        for (const c of localChs) {
+                            if (c.id === channelId)
+                                continue; // 跳过自己
+                            contextHint += `  - [本地] @${c.name} (id=${c.id})\n`;
+                        }
+                        for (const c of remoteForDir) {
+                            contextHint += `  - [远端, owner=${(c._ownerPublicKey || '').substring(0, 8)}…] @${c.name} (id=${c.id})\n`;
                         }
+                        contextHint += '语法: 在回复中写 "@渠道名 我要说的话" 即可, 系统会自动转发。\n\n';
                     }
                 }
-            }
-            catch { /* 预激活失败不阻塞 */ }
-            // 将真实 DID 作为上下文前缀，让 AI 使用真实的 DID 而不是自己编造的
-            let contextHint = '';
-            // 2026-08-14: 本地消息带 gateway 链接 → 自动加入, 结果注入 agent 上下文 (5s 上限, 不阻塞 LLM)
-            try {
-                const { maybeAutoJoinGateway } = await import('../agents/gateway-network.js');
-                const gwNote = await Promise.race([
-                    maybeAutoJoinGateway(text),
-                    new Promise((resolve) => setTimeout(() => resolve(null), 5000)),
-                ]);
-                if (gwNote)
-                    contextHint += `[系统上下文] ${gwNote}\n`;
-            }
-            catch { /* 自动加入失败不阻塞 */ }
-            // 2026-08-02: slash 命令提示 (在 /message 开头解析, 这里注入)
-            if (slashCommandHint)
-                contextHint += slashCommandHint;
-            if (realChannelDid)
-                contextHint += `[系统上下文] 当前频道名称: ${realChannelName}, 你的真实 DID: ${realChannelDid}\n`;
-            // v3 新增: 标识发送方 — 让 AI 分清内部 owner vs 远端访客
-            contextHint += `[系统上下文] 消息来源: 本地 (channel 内部 owner / 此机器上的用户). 称呼对方时用 "你" 或 "用户" 即可.\n`;
-            if (boundWalletAddress) {
-                contextHint += `[系统上下文] 已绑定的加密钱包地址: ${boundWalletAddress}。当用户授权或启用自动工具调用时, 可使用该地址发起链上操作。\n`;
-            }
-            if (autoToolsEnabled) {
-                contextHint += `[系统上下文] 自动工具调用已开启: 你可以使用受信任的本地工具 (shell / 文件 / skill) 而无需逐次询问用户。\n`;
-            }
-            else {
-                contextHint += `[系统上下文] 自动工具调用已关闭: 每次执行工具前必须先与用户确认。\n`;
-            }
-            // 2026-08-02 fix: 本地路径注入远端 channel 目录 (dirHint) — 之前只有远端路径 (agent.chat.send)
-            //   有 dirHint, 本地智能体对话时看不到远端 channel 列表 → 无法 @ 远程智能体交流.
-            //   现在注入: 可用渠道列表 (本地 + 远端), 让 LLM 知道 @ 谁、发什么.
-            try {
-                const localChs = await loadChannels();
-                const remoteForDir = [];
-                for (const [peerPk, list] of remoteChannelCache.entries()) {
-                    for (const ch of list) {
-                        remoteForDir.push({ ...ch, _ownerPublicKey: peerPk });
-                    }
+                catch (dirErr) {
+                    // 静默 — dirHint 不是核心
                 }
-                if (localChs.length > 0 || remoteForDir.length > 0) {
-                    contextHint += '[系统上下文] 可用渠道 (你可以在回复中写 "@渠道名 消息内容" 给它们发消息, 消息会持久化到目标 channel 的 session):\n';
-                    for (const c of localChs) {
-                        if (c.id === channelId)
-                            continue; // 跳过自己
-                        contextHint += `  - [本地] @${c.name} (id=${c.id})\n`;
-                    }
-                    for (const c of remoteForDir) {
-                        contextHint += `  - [远端, owner=${(c._ownerPublicKey || '').substring(0, 8)}…] @${c.name} (id=${c.id})\n`;
+                // v3: 注入 channel 绑定的判断力 (judgment_ids)
+                // 这是 v3 的核心 — channel 跑 LLM 时, 它的判断力 = 绑定的 judgment 列表
+                const judgmentHint = await buildJudgmentHint(channelForJudgment, channelId);
+                if (judgmentHint)
+                    contextHint += judgmentHint;
+                // 2026-06-10: 注入 skills 列表 (本机 ~/.bolloon/skills/ 下所有 skills)
+                // 让 LLM 知道有哪些 skill 可用, 在回复中提示用户
+                try {
+                    const { loadSkillsFromPaths, defaultSkillPaths, describeSkill } = await import('../agents/skill-loader.js');
+                    const paths = defaultSkillPaths();
+                    const skills = await loadSkillsFromPaths(paths);
+                    if (skills.length > 0) {
+                        contextHint += `[系统上下文] 本机已加载的 skills (${skills.length} 个, 你可以提示用户主动调用):\n`;
+                        for (const s of skills.slice(0, 20)) { // 上限 20 避免 prompt 过长
+                            const desc = (s.description || '').slice(0, 80);
+                            contextHint += `  - /${s.name}${desc ? ' — ' + desc : ''}\n`;
+                        }
+                        contextHint += '调用语法: 用户说 "/技能名 ..." 或 你回复时建议 "/技能名 ..." 让用户主动触发.\n\n';
                     }
-                    contextHint += '语法: 在回复中写 "@渠道名 我要说的话" 即可, 系统会自动转发。\n\n';
                 }
-            }
-            catch (dirErr) {
-                // 静默 — dirHint 不是核心
-            }
-            // v3: 注入 channel 绑定的判断力 (judgment_ids)
-            // 这是 v3 的核心 — channel 跑 LLM 时, 它的判断力 = 绑定的 judgment 列表
-            const judgmentHint = await buildJudgmentHint(channelForJudgment, channelId);
-            if (judgmentHint)
-                contextHint += judgmentHint;
-            // 2026-06-10: 注入 skills 列表 (本机 ~/.bolloon/skills/ 下所有 skills)
-            // 让 LLM 知道有哪些 skill 可用, 在回复中提示用户
-            try {
-                const { loadSkillsFromPaths, defaultSkillPaths, describeSkill } = await import('../agents/skill-loader.js');
-                const paths = defaultSkillPaths();
-                const skills = await loadSkillsFromPaths(paths);
-                if (skills.length > 0) {
-                    contextHint += `[系统上下文] 本机已加载的 skills (${skills.length} 个, 你可以提示用户主动调用):\n`;
-                    for (const s of skills.slice(0, 20)) { // 上限 20 避免 prompt 过长
-                        const desc = (s.description || '').slice(0, 80);
-                        contextHint += `  - /${s.name}${desc ? ' — ' + desc : ''}\n`;
-                    }
-                    contextHint += '调用语法: 用户说 "/技能名 ..." 或 你回复时建议 "/技能名 ..." 让用户主动触发.\n\n';
+                catch (err) {
+                    // 静默失败 — skills 不是核心, 加载失败不阻塞
                 }
-            }
-            catch (err) {
-                // 静默失败 — skills 不是核心, 加载失败不阻塞
-            }
-            // 2026-06-10: 注入 human values 摘要 (最常用的 judgment / 价值偏好)
-            // 与 judgment 不同: values 是更宏观的"用户偏好", judgment 是针对具体决策的约束
-            try {
-                const { loadAllJudgments } = await import('../pi-ecosystem-judgment/human-value-store.js');
-                const allJudgments = await loadAllJudgments().catch(() => []);
-                // 把所有 judgment 视作软参考 (跟 buildJudgmentHint 的 candidates 同理)
-                if (Array.isArray(allJudgments) && allJudgments.length > 0) {
-                    contextHint += `[系统上下文] 用户的核心价值倾向 (来自 ${allJudgments.length} 条历史 judgment, 软参考, 体现而非复述):\n`;
-                    for (const j of allJudgments.slice(0, 8)) {
-                        const decision = (j.decision || '').slice(0, 80);
-                        contextHint += `  - ${decision}\n`;
+                // 2026-06-10: 注入 human values 摘要 (最常用的 judgment / 价值偏好)
+                // 与 judgment 不同: values 是更宏观的"用户偏好", judgment 是针对具体决策的约束
+                try {
+                    const { loadAllJudgments } = await import('../pi-ecosystem-judgment/human-value-store.js');
+                    const allJudgments = await loadAllJudgments().catch(() => []);
+                    // 把所有 judgment 视作软参考 (跟 buildJudgmentHint 的 candidates 同理)
+                    if (Array.isArray(allJudgments) && allJudgments.length > 0) {
+                        contextHint += `[系统上下文] 用户的核心价值倾向 (来自 ${allJudgments.length} 条历史 judgment, 软参考, 体现而非复述):\n`;
+                        for (const j of allJudgments.slice(0, 8)) {
+                            const decision = (j.decision || '').slice(0, 80);
+                            contextHint += `  - ${decision}\n`;
+                        }
+                        contextHint += '\n';
                     }
-                    contextHint += '\n';
                 }
-            }
-            catch (err) {
-                // 静默失败
-            }
-            // 2026-06-10: 注入 documents 列表 (本机 documents/ 目录的文档元数据)
-            // 让 LLM 知道有文档存在, 用户可主动要求读
-            try {
-                const { documentStore } = await import('../documents/store.js');
-                const docs = await documentStore.getReceivedDocuments(50).catch(() => []);
-                if (Array.isArray(docs) && docs.length > 0) {
-                    contextHint += `[系统上下文] 本机 documents (${docs.length} 篇, 用户可让你读):\n`;
-                    for (const d of docs.slice(0, 10)) {
-                        const name = d.fileName || d.id || '(未命名)';
-                        const size = d.fileSize ? ` (${Math.round(d.fileSize / 1024)}KB)` : '';
-                        const sender = d.fromNodeId ? ` [来自 ${d.fromNodeIdShort || d.fromNodeId.substring(0, 8)}…]` : '';
-                        contextHint += `  - ${name}${size}${sender}\n`;
+                catch (err) {
+                    // 静默失败
+                }
+                // 2026-06-10: 注入 documents 列表 (本机 documents/ 目录的文档元数据)
+                // 让 LLM 知道有文档存在, 用户可主动要求读
+                try {
+                    const { documentStore } = await import('../documents/store.js');
+                    const docs = await documentStore.getReceivedDocuments(50).catch(() => []);
+                    if (Array.isArray(docs) && docs.length > 0) {
+                        contextHint += `[系统上下文] 本机 documents (${docs.length} 篇, 用户可让你读):\n`;
+                        for (const d of docs.slice(0, 10)) {
+                            const name = d.fileName || d.id || '(未命名)';
+                            const size = d.fileSize ? ` (${Math.round(d.fileSize / 1024)}KB)` : '';
+                            const sender = d.fromNodeId ? ` [来自 ${d.fromNodeIdShort || d.fromNodeId.substring(0, 8)}…]` : '';
+                            contextHint += `  - ${name}${size}${sender}\n`;
+                        }
+                        contextHint += '用户提到某文档时, 你可以调用读文档工具读取并总结.\n\n';
                     }
-                    contextHint += '用户提到某文档时, 你可以调用读文档工具读取并总结.\n\n';
                 }
-            }
-            catch (err) {
-                // 静默失败
-            }
-            // 2026-06-11: 注入此 channel 专属的 persona + 关联文档 (从 channel 字段读, LLM 长期记忆)
-            const chPersona = channelForJudgment?.persona;
-            if (chPersona && typeof chPersona === 'object') {
-                contextHint += '[系统上下文] 此 channel 的人设 (你是这个角色):\n';
-                if (chPersona.name)
-                    contextHint += `  名字: ${chPersona.name}\n`;
-                if (chPersona.description)
-                    contextHint += `  描述: ${chPersona.description}\n`;
-                if (chPersona.personality)
-                    contextHint += `  性格: ${chPersona.personality}\n`;
-                if (chPersona.greeting)
-                    contextHint += `  问候: ${chPersona.greeting}\n`;
-                if (Array.isArray(chPersona.capabilities) && chPersona.capabilities.length > 0) {
-                    contextHint += `  能力: ${chPersona.capabilities.join('、')}\n`;
-                }
-                if (Array.isArray(chPersona.interests) && chPersona.interests.length > 0) {
-                    contextHint += `  兴趣: ${chPersona.interests.join('、')}\n`;
-                }
-                contextHint += '回复时应自然体现这个角色 (不要硬搬原文, 像这个角色说话即可).\n\n';
-            }
-            // 2026-08-02: memory 回读 — 把本 channel 的历史记忆摘要注入 contextHint.
-            //   memory-compressor 每次 /message 后把增量摘要 append 到
-            //   ~/.bolloon/memory/<agentId>/sessions/<safe-channel>__<safe-session>.summary.md,
-            //   但之前只写不读, 对话完全无记忆. 这里取尾部最近 3 段增量摘要回灌给 LLM.
-            try {
-                const { getSessionSummaryPath, getMemoryDir, sanitizeAgentId } = await import('../bootstrap/memory-compressor.js');
-                const { readFile, readdir } = await import('fs/promises');
-                const { join } = await import('path');
-                const agentId = channelForJudgment?.agentId;
-                if (agentId) {
-                    // 优先读当前 channel 的 summary (如果有)
-                    const currentSummary = getSessionSummaryPath(agentId, channelId, currentSessionId);
-                    const summariesToRead = [];
-                    try {
-                        const raw = await readFile(currentSummary, 'utf-8');
-                        if (raw.trim())
-                            summariesToRead.push(raw);
+                catch (err) {
+                    // 静默失败
+                }
+                // 2026-06-11: 注入此 channel 专属的 persona + 关联文档 (从 channel 字段读, LLM 长期记忆)
+                const chPersona = channelForJudgment?.persona;
+                if (chPersona && typeof chPersona === 'object') {
+                    contextHint += '[系统上下文] 此 channel 的人设 (你是这个角色):\n';
+                    if (chPersona.name)
+                        contextHint += `  名字: ${chPersona.name}\n`;
+                    if (chPersona.description)
+                        contextHint += `  描述: ${chPersona.description}\n`;
+                    if (chPersona.personality)
+                        contextHint += `  性格: ${chPersona.personality}\n`;
+                    if (chPersona.greeting)
+                        contextHint += `  问候: ${chPersona.greeting}\n`;
+                    if (Array.isArray(chPersona.capabilities) && chPersona.capabilities.length > 0) {
+                        contextHint += `  能力: ${chPersona.capabilities.join('、')}\n`;
+                    }
+                    if (Array.isArray(chPersona.interests) && chPersona.interests.length > 0) {
+                        contextHint += `  兴趣: ${chPersona.interests.join('、')}\n`;
                     }
-                    catch { /* 当前 channel 还没有摘要 */ }
-                    // 再兜底读同 agent 其他 channel 的最近摘要 (跨 channel 记忆)
-                    if (summariesToRead.length === 0) {
+                    contextHint += '回复时应自然体现这个角色 (不要硬搬原文, 像这个角色说话即可).\n\n';
+                }
+                // 2026-08-02: memory 回读 — 把本 channel 的历史记忆摘要注入 contextHint.
+                //   memory-compressor 每次 /message 后把增量摘要 append 到
+                //   ~/.bolloon/memory/<agentId>/sessions/<safe-channel>__<safe-session>.summary.md,
+                //   但之前只写不读, 对话完全无记忆. 这里取尾部最近 3 段增量摘要回灌给 LLM.
+                try {
+                    const { getSessionSummaryPath, getMemoryDir, sanitizeAgentId } = await import('../bootstrap/memory-compressor.js');
+                    const { readFile, readdir } = await import('fs/promises');
+                    const { join } = await import('path');
+                    const agentId = channelForJudgment?.agentId;
+                    if (agentId) {
+                        // 优先读当前 channel 的 summary (如果有)
+                        const currentSummary = getSessionSummaryPath(agentId, channelId, currentSessionId);
+                        const summariesToRead = [];
                         try {
-                            const sessionsDir = join(getMemoryDir(agentId), 'sessions');
-                            const files = (await readdir(sessionsDir)).filter(f => f.endsWith('.summary.md'));
-                            // 按文件名排序取最近 2 个 (文件名含时间戳, 近似排序)
-                            const recent = files.sort().slice(-2);
-                            for (const f of recent) {
-                                if (f.includes(sanitizeAgentId(channelId)))
-                                    continue; // 跳过已读的当前 channel
-                                try {
-                                    const raw = await readFile(join(sessionsDir, f), 'utf-8');
-                                    if (raw.trim())
-                                        summariesToRead.push(raw);
+                            const raw = await readFile(currentSummary, 'utf-8');
+                            if (raw.trim())
+                                summariesToRead.push(raw);
+                        }
+                        catch { /* 当前 channel 还没有摘要 */ }
+                        // 再兜底读同 agent 其他 channel 的最近摘要 (跨 channel 记忆)
+                        if (summariesToRead.length === 0) {
+                            try {
+                                const sessionsDir = join(getMemoryDir(agentId), 'sessions');
+                                const files = (await readdir(sessionsDir)).filter(f => f.endsWith('.summary.md'));
+                                // 按文件名排序取最近 2 个 (文件名含时间戳, 近似排序)
+                                const recent = files.sort().slice(-2);
+                                for (const f of recent) {
+                                    if (f.includes(sanitizeAgentId(channelId)))
+                                        continue; // 跳过已读的当前 channel
+                                    try {
+                                        const raw = await readFile(join(sessionsDir, f), 'utf-8');
+                                        if (raw.trim())
+                                            summariesToRead.push(raw);
+                                    }
+                                    catch { /* 单个摘要读失败跳过 */ }
                                 }
-                                catch { /* 单个摘要读失败跳过 */ }
                             }
+                            catch { /* 无 sessions 目录 */ }
                         }
-                        catch { /* 无 sessions 目录 */ }
-                    }
-                    if (summariesToRead.length > 0) {
-                        const memBlock = summariesToRead.map(s => s.trim().slice(-1500)).join('\n\n---\n\n');
-                        contextHint += `[系统上下文] 动态状态层 · chat-worksite (上次做到哪 — 本 channel 历史记忆, 来自 memory-compressor 摘要, 引用而非复述):\n${memBlock.slice(-2500)}\n\n`;
-                    }
-                    else {
-                        // 2026-08-08 (DID 目录读侧): 磁盘无摘要时, 回退读 DID 目录 memory 表 (跨设备同步来的记忆)
-                        try {
-                            const { openUserCatalog, catalogMemoryRows } = await import('../storage/did-catalog-bridge.js');
-                            const cat = await openUserCatalog();
-                            if (cat) {
-                                const rows = catalogMemoryRows(cat, agentId);
-                                if (rows.length > 0) {
-                                    const memBlock = rows.slice(0, 2)
-                                        .map(({ row }) => String(row.data.summary || '').slice(-1500))
-                                        .filter(Boolean)
-                                        .join('\n\n---\n\n');
-                                    if (memBlock) {
-                                        contextHint += `[系统上下文] 动态状态层 · chat-worksite (DID 目录同步记忆, 引用而非复述):\n${memBlock.slice(-2500)}\n\n`;
+                        if (summariesToRead.length > 0) {
+                            const memBlock = summariesToRead.map(s => s.trim().slice(-1500)).join('\n\n---\n\n');
+                            contextHint += `[系统上下文] 动态状态层 · chat-worksite (上次做到哪 — 本 channel 历史记忆, 来自 memory-compressor 摘要, 引用而非复述):\n${memBlock.slice(-2500)}\n\n`;
+                        }
+                        else {
+                            // 2026-08-08 (DID 目录读侧): 磁盘无摘要时, 回退读 DID 目录 memory 表 (跨设备同步来的记忆)
+                            try {
+                                const { openUserCatalog, catalogMemoryRows } = await import('../storage/did-catalog-bridge.js');
+                                const cat = await openUserCatalog();
+                                if (cat) {
+                                    const rows = catalogMemoryRows(cat, agentId);
+                                    if (rows.length > 0) {
+                                        const memBlock = rows.slice(0, 2)
+                                            .map(({ row }) => String(row.data.summary || '').slice(-1500))
+                                            .filter(Boolean)
+                                            .join('\n\n---\n\n');
+                                        if (memBlock) {
+                                            contextHint += `[系统上下文] 动态状态层 · chat-worksite (DID 目录同步记忆, 引用而非复述):\n${memBlock.slice(-2500)}\n\n`;
+                                        }
                                     }
                                 }
                             }
+                            catch { /* 目录读失败静默 */ }
                         }
-                        catch { /* 目录读失败静默 */ }
                     }
                 }
-            }
-            catch (memErr) {
-                // 静默失败 — memory 回读不是核心, 失败不阻塞
-            }
-            // 2026-08-02: plan 回读 — 把进行中的计划注入 contextHint (在 memory 之后)
-            //   配合 create_plan / update_plan / review_plan 工具, 让 LLM 每次对话都能看到
-            //   未完成的计划并继续推进.
-            try {
-                const { listActivePlans, planToContext } = await import('../agents/plan-store.js');
-                const plans = await listActivePlans();
-                if (plans.length > 0) {
-                    const plansBlock = plans.slice(0, 3).map(p => planToContext(p)).join('\n\n');
-                    contextHint += `[系统上下文] 动态状态层 · focus (此刻优先级与时间边界 — 进行中的计划, 来自 plan-store, 执行中每完成一步调 update_plan 勾选):\n${plansBlock}\n\n`;
+                catch (memErr) {
+                    // 静默失败 — memory 回读不是核心, 失败不阻塞
                 }
-            }
-            catch (planErr) {
-                // 静默失败
-            }
-            // 2026-08-03 (Context OS P5): 资产层目录注入 — LLM 知道有 12+3 层资产,
-            //   需要细节时用 read_context_assets 按层路由读取, 不全仓扫描 (Context OS §4).
-            try {
-                const { readContextAssets, formatLayerListing } = await import('../bootstrap/context-os.js');
-                const listings = await readContextAssets();
-                const total = listings.reduce((s, l) => s + l.fileCount, 0);
-                if (total > 0) {
-                    contextHint += `[系统上下文] 资产层 (Context OS 12+3 层, ${total} 篇资产 — 任务需要细节时用 read_context_assets 按层读取, 不要假装知道没读过的内容):\n${formatLayerListing(listings)}`;
-                }
-            }
-            catch (ctxErr) {
-                // 静默失败
-            }
-            const linkedIds = channelForJudgment?.linkedDocumentIds;
-            if (Array.isArray(linkedIds) && linkedIds.length > 0) {
+                // 2026-08-02: plan 回读 — 把进行中的计划注入 contextHint (在 memory 之后)
+                //   配合 create_plan / update_plan / review_plan 工具, 让 LLM 每次对话都能看到
+                //   未完成的计划并继续推进.
                 try {
-                    const { documentStore } = await import('../documents/store.js');
-                    contextHint += `[系统上下文] 此 channel 关联了 ${linkedIds.length} 篇文档 (已自动加载内容, 你应基于它们回答):\n`;
-                    let loaded = 0;
-                    for (const docId of linkedIds.slice(0, 10)) {
-                        const doc = await documentStore.readDocument(docId).catch(() => null);
-                        if (!doc)
-                            continue;
-                        const name = doc.metadata?.fileName || docId;
-                        const content = (doc.content || '').slice(0, 1500); // 单篇 1.5KB 上限, 总 prompt 防爆
-                        contextHint += `\n--- 文档: ${name} ---\n${content}\n--- 文档结束 ---\n`;
-                        loaded++;
-                    }
-                    if (loaded === 0) {
-                        contextHint += `(但加载失败, 文档可能已被删除)\n\n`;
-                    }
-                    else {
-                        contextHint += '\n';
+                    const { listActivePlans, planToContext } = await import('../agents/plan-store.js');
+                    const plans = await listActivePlans();
+                    if (plans.length > 0) {
+                        const plansBlock = plans.slice(0, 3).map(p => planToContext(p)).join('\n\n');
+                        contextHint += `[系统上下文] 动态状态层 · focus (此刻优先级与时间边界 — 进行中的计划, 来自 plan-store, 执行中每完成一步调 update_plan 勾选):\n${plansBlock}\n\n`;
                     }
                 }
-                catch (err) {
-                    console.warn('[v3-persona] 加载关联文档失败 (非致命):', err.message);
+                catch (planErr) {
+                    // 静默失败
                 }
-            }
-            // v3 新增: 注入"可用渠道"目录, 让 LLM 知道可以 @-mention 哪些 channel
-            // - 本地 channels (除了自己)
-            // - 远端 channels (remoteChannelCache 缓存的)
-            const localChannels = (await loadChannels()).filter(c => c.id !== channelId);
-            const remoteChannels = [];
-            for (const [peerPk, list] of remoteChannelCache.entries()) {
-                for (const ch of list) {
-                    remoteChannels.push({ ...ch, _ownerPublicKey: peerPk });
-                }
-            }
-            if (localChannels.length > 0 || remoteChannels.length > 0) {
-                contextHint += '[系统上下文] 可用渠道 (你可以用 @渠道名 消息内容 给它们发消息):\n';
-                for (const c of localChannels) {
-                    contextHint += `  - [本地] @${c.name} (id=${c.id})\n`;
-                }
-                for (const c of remoteChannels) {
-                    contextHint += `  - [远端, owner=${(c._ownerPublicKey || '').substring(0, 8)}…] @${c.name} (id=${c.id})\n`;
-                }
-                contextHint += '语法: 当你想给其他渠道发消息, 在回复中写 "@渠道名 我要说的话" 即可. 消息会持久化到目标 channel 的 session, 你之后能看到"自己"在那里说的话.\n';
-                // 2026-06-10 强化: 当用户消息里出现 @渠道名, 默认是请你代为转发, 务必在回复里包含对应的 @ 转发
-                if (remoteChannels.length > 0) {
-                    contextHint += '重要: 上面列表里 [远端] 标记的 channel 在另一台机器上, 你可以像 @本地 channel 一样 @ 它们 — 我会通过 P2P 自动把消息送达对方智能体, 对方智能体的回复也会同步回来.\n';
-                    contextHint += '当用户在消息里 @ 了某个 (本地或远端) channel, 默认意图是希望你代为转发 — 你应该在回复中写出对应的 "@渠道名 转发内容", 否则用户的请求不会被路由出去.\n\n';
+                // 2026-08-03 (Context OS P5): 资产层目录注入 — LLM 知道有 12+3 层资产,
+                //   需要细节时用 read_context_assets 按层路由读取, 不全仓扫描 (Context OS §4).
+                try {
+                    const { readContextAssets, formatLayerListing } = await import('../bootstrap/context-os.js');
+                    const listings = await readContextAssets();
+                    const total = listings.reduce((s, l) => s + l.fileCount, 0);
+                    if (total > 0) {
+                        contextHint += `[系统上下文] 资产层 (Context OS 12+3 层, ${total} 篇资产 — 任务需要细节时用 read_context_assets 按层读取, 不要假装知道没读过的内容):\n${formatLayerListing(listings)}`;
+                    }
                 }
-                else {
-                    contextHint += '\n';
+                catch (ctxErr) {
+                    // 静默失败
                 }
-            }
-            if (contextHint)
-                contextHint += '\n';
-            // 2026-07-06: 全局 contextHint 硬裁 — MiniMax-M3 context window 8K token ≈ 32K 字符
-            //   如果 contextHint 超过 14K 字符 (留 ~18K 给 userText + LLM 输出 + system), 主动截断
-            const CONTEXT_LIMIT = 14000;
-            let contextTruncated = false;
-            if (contextHint.length > CONTEXT_LIMIT) {
-                const originalLen = contextHint.length;
-                contextHint = contextHint.slice(0, CONTEXT_LIMIT);
-                contextHint += `\n[系统上下文] (...剩余 ${originalLen - CONTEXT_LIMIT} 字符因 context window 限制已截断, 完整内容请用 /judgments 查)\n`;
-                contextTruncated = true;
-                console.warn(`[chat] channel=${channelId} contextHint truncated: ${originalLen} -> ${contextHint.length} chars`);
-            }
-            try {
-                // 2026-06-15: 把 user text 单独 marker 包起来, LLM 不会被 8K+ 的 system context 吞掉
-                //   (之前 contextHint + text 拼成一整段当 user role, 24 字符的 user input 埋在 8K+ 里看不出)
-                //   修法: contextHint 当 "背景信息", text 当 "本轮用户请求" — 显式 marker 让 LLM 区分
-                // 2026-06-15 二次修: 把 text 放在最前 (LLM 看到 input 第一眼是 user text, 不会被 judgmentHint 末尾
-                //   的 "..." 误判为整个 input 截断)
-                // 2026-07-05: prepend nextPromptHints (manifest-loader 加载的对方能力, 仅本次生效)
-                let extraHint = '';
-                const hint = nextPromptHints.get(channelId);
-                if (hint) {
-                    extraHint = hint + '\n\n';
-                    nextPromptHints.delete(channelId);
-                }
-                // 2026-07-15 修 Bug 3: 拖拽附件 — attachmentContext 提到 contextHint 最前, LLM 第一眼看到文件清单
-                const markedPrompt = `${extraHint}【本轮用户请求】\n${text}\n【请求结束】\n\n${attachmentContext}${contextHint}`;
-                // 闭包里 TS 不再保留 null 收窄 ⇒ 先收成局部 const
-                const agentForRun = agent;
-                // **K5 步骤⑦**: 入口只交一个一次性 `ExecutionRequest` (绑定/流/取消都在请求里), Pi 侧 runExecution 统一派发
-                const request = {
-                    input: markedPrompt,
-                    channelId,
-                    signal: runState.abortController?.signal,
-                    onStream: streamCallback,
-                };
-                fullResponse = await deliverThroughActor(agentForRun, () => agentForRun.runExecution(request));
-            }
-            catch (err) {
-                // abort 抛错: 保留已输出的部分 (fullResponse 可能是空字符串)
-                if (runState.abortController?.signal.aborted || err?.name === 'AbortError') {
-                    console.log(`[chat] aborted channel=${channelId}`);
-                    // 2026-07-06: abort 时 fullResponse 可能为空 (LLM 还没输出), 必须给用户一个反馈
-                    if (!fullResponse.trim()) {
-                        fullResponse = '⚠️ 生成已中断 (用户取消)';
+                const linkedIds = channelForJudgment?.linkedDocumentIds;
+                if (Array.isArray(linkedIds) && linkedIds.length > 0) {
+                    try {
+                        const { documentStore } = await import('../documents/store.js');
+                        contextHint += `[系统上下文] 此 channel 关联了 ${linkedIds.length} 篇文档 (已自动加载内容, 你应基于它们回答):\n`;
+                        let loaded = 0;
+                        for (const docId of linkedIds.slice(0, 10)) {
+                            const doc = await documentStore.readDocument(docId).catch(() => null);
+                            if (!doc)
+                                continue;
+                            const name = doc.metadata?.fileName || docId;
+                            const content = (doc.content || '').slice(0, 1500); // 单篇 1.5KB 上限, 总 prompt 防爆
+                            contextHint += `\n--- 文档: ${name} ---\n${content}\n--- 文档结束 ---\n`;
+                            loaded++;
+                        }
+                        if (loaded === 0) {
+                            contextHint += `(但加载失败, 文档可能已被删除)\n\n`;
+                        }
+                        else {
+                            contextHint += '\n';
+                        }
                     }
-                }
-                else {
-                    // M1.2 (2026-06-17): 不再 rethrow — 把错误塞到 fullResponse 让 broadcast 出来, 后续 session 仍保存
-                    // 旧行为: 抛到外层 catch, 触发 500 + 用户消息丢失 (session 不保存)
-                    console.error(`[chat] LLM 调用失败 channel=${channelId}:`, err);
-                    fullResponse = `[错误: LLM 调用失败] ${String(err?.message || err).slice(0, 300)}`;
-                    broadcast({ type: 'error', content: fullResponse }, channelId);
-                }
-            }
-            // abort 模式: 给 partial 拼后缀 — 只在 LLM 真有输出时加中断标记,
-            //   跳过空响应 + 跳过 [AI 服务调用失败] fallback (这些本身就是错误占位, 拼
-            //   "[生成已中断]" 会误导用户)
-            const hasRealLlmOutput = fullResponse.trim().length > 0 &&
-                !fullResponse.trimStart().startsWith('[AI 服务调用失败]');
-            if (runState.abortController?.signal.aborted && hasRealLlmOutput) {
-                fullResponse = fullResponse + '\n\n_[生成已中断]_';
-            }
-            // 2026-06-18: 修 lastFinalReply 没设 → /api/loop/inspect 永远返回空
-            runState.lastFinalReply = fullResponse;
-            // 2026-07-06: 防御性兜底 — fullResponse 为空时, 前端 segmentChatReply('') 返回 [],
-            //   导致气泡不渲染, 用户只看到"思考中"占位符. 这里保证永远有内容可渲染.
-            if (!fullResponse.trim()) {
-                fullResponse = '⚠️ AI 未返回内容, 请重试';
-                console.warn(`[chat] fullResponse empty for channel=${channelId}, using fallback`);
-            }
-            // v3 新增: 解析 LLM 回复里的 @-mentions, 转发到目标 channel
-            await routeMentionsInReply(channelId, fullResponse, localChannels, remoteChannels);
-            broadcast({ type: 'ai', content: fullResponse }, channelId);
-            const existingSession = await loadSession(channelId, currentSessionId);
-            const session = existingSession || { channelId, sessionId: currentSessionId, messages: [], lastUpdated: new Date().toISOString() };
-            session.sessionId = currentSessionId;
-            // v3: 加 source 标记 (local = 内部 owner, remote = 远端访客)
-            // 2026-07-15 修 Bug 4: client.ts sendMessage 已经通过 persistLastMessageToServer PATCH /sessions/.../...
-            //   把 user msg 落盘一次 (立即落, 切走再切回不丢). 这里再 push 一次 → session.messages 出现两条相同的 user msg,
-            //   loadSession 重渲染时两条都上屏, 表现"每条 user 气泡重复两次".
-            //   修法: 持久化以 client PATCH 为准, /message 这边只 push ai 消息. 同时去重检查上次的 user 避免极端竞态 (并行 PATCH).
-            const lastMsg = session.messages[session.messages.length - 1];
-            const userAlreadyPushed = lastMsg && lastMsg.type === 'user' && lastMsg.content === text;
-            if (!userAlreadyPushed) {
-                session.messages.push({ id: crypto.randomUUID(), type: 'user', content: text, timestamp: new Date().toISOString(), source: 'local' });
-            }
-            session.messages.push({
-                id: crypto.randomUUID(),
-                type: 'ai',
-                content: fullResponse,
-                timestamp: new Date().toISOString(),
-                source: 'local',
-                // P0.5: 这条 AI 回复引用了哪些 judgment (注入门回传)
-                ...(usedJudgmentIds.length > 0 ? { metadata: { usedJudgmentIds } } : {}),
-            });
-            session.lastUpdated = new Date().toISOString();
-            await saveSession(session);
-            // 2026-07-04: 写 session 后, 调 memory-compressor 把消息历史压缩到
-            //   ~/.bolloon/memory/<channel.agentId>/sessions/<safe-channel>__<safe-session>.summary.md
-            // 失败静默, 不阻塞 /message 主路径.
-            try {
-                const channelsForMemory = await loadChannels();
-                const channelForMemory = channelsForMemory.find(c => c.id === channelId);
-                if (channelForMemory?.agentId) {
-                    const { compressSessionToMemory } = await import('../bootstrap/memory-compressor.js');
-                    const compressRes = await compressSessionToMemory({
-                        agentId: channelForMemory.agentId,
-                        channelId,
-                        sessionId: currentSessionId,
-                    });
-                    if (!compressRes.skipped && compressRes.bytesWritten > 0) {
-                        console.log(`[memory] compressed ${compressRes.messagesCount} new messages for ${channelForMemory.agentId}/${channelId} → ${compressRes.summaryPath} (${compressRes.bytesWritten}B)`);
+                    catch (err) {
+                        console.warn('[v3-persona] 加载关联文档失败 (非致命):', err.message);
                     }
                 }
-            }
-            catch (memErr) {
-                console.warn('[memory] compressSessionToMemory failed (non-fatal):', memErr?.message?.slice(0, 200));
-            }
-            // 2026-07-05: 把 session 里的 user/ai 消息按涉及到的远端 peer 归档到月度 markdown
-            //   触发条件: 消息里出现过 @远端 channel, 或者 session 历史上与该 peer 通信过
-            //   失败静默, 不阻塞主对话
-            try {
-                const { appendChatArchive } = await import('../bootstrap/chat-archiver.js');
-                // 找到这条消息涉及到的远端 peer (从 routeMentionsInReply 的结果推断 — 简单起见直接遍历 remoteChannels)
-                const localChannels2 = (await loadChannels());
-                const remoteChannels2 = [];
+                // v3 新增: 注入"可用渠道"目录, 让 LLM 知道可以 @-mention 哪些 channel
+                // - 本地 channels (除了自己)
+                // - 远端 channels (remoteChannelCache 缓存的)
+                const localChannels = (await loadChannels()).filter(c => c.id !== channelId);
+                const remoteChannels = [];
                 for (const [peerPk, list] of remoteChannelCache.entries()) {
                     for (const ch of list) {
-                        remoteChannels2.push({ ...ch, _ownerPublicKey: peerPk });
+                        remoteChannels.push({ ...ch, _ownerPublicKey: peerPk });
                     }
                 }
-                // 找出本次 text/fullResponse 里出现 @ 的 channel 对应的 owner pk
-                const peerSet = new Set();
-                const mentionRe = /@([一-龥A-Za-z0-9_\-]{1,30})/g;
-                const mentionedNames = new Set();
-                for (const m of text.matchAll(mentionRe))
-                    mentionedNames.add(m[1]);
-                for (const m of fullResponse.matchAll(mentionRe))
-                    mentionedNames.add(m[1]);
-                for (const rc of remoteChannels2) {
-                    if (mentionedNames.has(rc.name))
-                        peerSet.add(rc._ownerPublicKey);
-                }
-                // 追加到每个相关 peer 的月度归档
-                for (const pk of peerSet) {
-                    await appendChatArchive({
-                        publicKey: pk,
-                        entry: {
-                            ts: new Date().toISOString(),
-                            source: 'local',
-                            channelId, channelName: (await loadChannels()).find(c => c.id === channelId)?.name,
-                            text: `[本节点] user: ${text.slice(0, 500)}\n[本节点] ai: ${fullResponse.slice(0, 800)}`,
-                            fromPublicKey: v3P2PRef?.getPublicKey(),
-                            msgType: 'user',
-                        }
-                    });
-                }
-            }
-            catch (archiveErr) {
-                console.warn('[chat-archive] append failed (non-fatal):', archiveErr?.message?.slice(0, 200));
-            }
-            // 2026-07-05: 懒加载触发器 — 探测到 @-mention 远端 / 连续失败 / 关键词, 拉对方 manifest
-            //   把 capability-index 拼到下一次 prompt 上下文 (只生效 1 次, 不污染主循环)
-            try {
-                const { detectLoadTrigger, loadPeerManifest, clearFailure } = await import('../agents/peer-manifest-loader.js');
-                const remoteChannelsForDetect = [];
-                for (const [peerPk, list] of remoteChannelCache.entries()) {
-                    for (const ch of list) {
-                        remoteChannelsForDetect.push({ ...ch, _ownerPublicKey: peerPk });
+                if (localChannels.length > 0 || remoteChannels.length > 0) {
+                    contextHint += '[系统上下文] 可用渠道 (你可以用 @渠道名 消息内容 给它们发消息):\n';
+                    for (const c of localChannels) {
+                        contextHint += `  - [本地] @${c.name} (id=${c.id})\n`;
+                    }
+                    for (const c of remoteChannels) {
+                        contextHint += `  - [远端, owner=${(c._ownerPublicKey || '').substring(0, 8)}…] @${c.name} (id=${c.id})\n`;
+                    }
+                    contextHint += '语法: 当你想给其他渠道发消息, 在回复中写 "@渠道名 我要说的话" 即可. 消息会持久化到目标 channel 的 session, 你之后能看到"自己"在那里说的话.\n';
+                    // 2026-06-10 强化: 当用户消息里出现 @渠道名, 默认是请你代为转发, 务必在回复里包含对应的 @ 转发
+                    if (remoteChannels.length > 0) {
+                        contextHint += '重要: 上面列表里 [远端] 标记的 channel 在另一台机器上, 你可以像 @本地 channel 一样 @ 它们 — 我会通过 P2P 自动把消息送达对方智能体, 对方智能体的回复也会同步回来.\n';
+                        contextHint += '当用户在消息里 @ 了某个 (本地或远端) channel, 默认意图是希望你代为转发 — 你应该在回复中写出对应的 "@渠道名 转发内容", 否则用户的请求不会被路由出去.\n\n';
+                    }
+                    else {
+                        contextHint += '\n';
                     }
                 }
-                // 检测 + 加载
-                const detection = detectLoadTrigger({
-                    text,
-                    channelId,
-                    remoteChannels: remoteChannelsForDetect,
-                });
-                if (detection.shouldLoad && detection.remotePublicKey && v3P2PRef) {
-                    const result = await loadPeerManifest({
+                if (contextHint)
+                    contextHint += '\n';
+                // 2026-07-06: 全局 contextHint 硬裁 — MiniMax-M3 context window 8K token ≈ 32K 字符
+                //   如果 contextHint 超过 14K 字符 (留 ~18K 给 userText + LLM 输出 + system), 主动截断
+                const CONTEXT_LIMIT = 14000;
+                let contextTruncated = false;
+                if (contextHint.length > CONTEXT_LIMIT) {
+                    const originalLen = contextHint.length;
+                    contextHint = contextHint.slice(0, CONTEXT_LIMIT);
+                    contextHint += `\n[系统上下文] (...剩余 ${originalLen - CONTEXT_LIMIT} 字符因 context window 限制已截断, 完整内容请用 /judgments 查)\n`;
+                    contextTruncated = true;
+                    console.warn(`[chat] channel=${channelId} contextHint truncated: ${originalLen} -> ${contextHint.length} chars`);
+                }
+                try {
+                    // 2026-06-15: 把 user text 单独 marker 包起来, LLM 不会被 8K+ 的 system context 吞掉
+                    //   (之前 contextHint + text 拼成一整段当 user role, 24 字符的 user input 埋在 8K+ 里看不出)
+                    //   修法: contextHint 当 "背景信息", text 当 "本轮用户请求" — 显式 marker 让 LLM 区分
+                    // 2026-06-15 二次修: 把 text 放在最前 (LLM 看到 input 第一眼是 user text, 不会被 judgmentHint 末尾
+                    //   的 "..." 误判为整个 input 截断)
+                    // 2026-07-05: prepend nextPromptHints (manifest-loader 加载的对方能力, 仅本次生效)
+                    let extraHint = '';
+                    const hint = nextPromptHints.get(channelId);
+                    if (hint) {
+                        extraHint = hint + '\n\n';
+                        nextPromptHints.delete(channelId);
+                    }
+                    // 2026-07-15 修 Bug 3: 拖拽附件 — attachmentContext 提到 contextHint 最前, LLM 第一眼看到文件清单
+                    const markedPrompt = `${extraHint}【本轮用户请求】\n${text}\n【请求结束】\n\n${attachmentContext}${contextHint}`;
+                    // 闭包里 TS 不再保留 null 收窄 ⇒ 先收成局部 const
+                    const agentForRun = agent;
+                    // **K5 步骤⑦**: 入口只交一个一次性 `ExecutionRequest` (绑定/流/取消都在请求里), Pi 侧 runExecution 统一派发
+                    const request = {
+                        input: markedPrompt,
                         channelId,
-                        channelName: (await loadChannels()).find(c => c.id === channelId)?.name,
-                        reason: detection.reason,
-                        triggerValue: detection.triggerValue,
-                        remotePublicKey: detection.remotePublicKey,
-                    }, { p2p: v3P2PRef });
-                    if (result && result.promptBlock) {
-                        console.log(`[manifest-loader] ${detection.reason} → ${detection.remotePublicKey.slice(0, 12)}... (${result.durationMs}ms, rpc=${result.rpcTriggered}, agents=${result.agentDescriptions.length})`);
-                        // 把 promptBlock 推给前端 + 写入一次性的 prompt 附加 (nextPromptHint 全局变量, 在下次 agent.promptStream 前 prepend)
-                        broadcast({
-                            type: 'peer-manifest-loaded',
-                            fromPublicKey: detection.remotePublicKey,
-                            reason: detection.reason,
-                            promptBlock: result.promptBlock,
-                            capabilityIndex: result.capabilityIndex,
-                        }, channelId);
-                        // 缓存到 channel 维度的 nextPromptHint (下一次 LLM prompt 前 inject)
-                        nextPromptHints.set(channelId, (nextPromptHints.get(channelId) || '') + '\n\n' + result.promptBlock);
-                        clearFailure(channelId);
+                        signal: abortSignal,
+                        onStream: streamCallback,
+                    };
+                    fullResponse = await deliverThroughActor(agentForRun, () => agentForRun.runExecution(request));
+                }
+                catch (err) {
+                    // abort 抛错: 保留已输出的部分 (fullResponse 可能是空字符串)
+                    if (abortSignal?.aborted || err?.name === 'AbortError') {
+                        console.log(`[chat] aborted channel=${channelId}`);
+                        // 2026-07-06: abort 时 fullResponse 可能为空 (LLM 还没输出), 必须给用户一个反馈
+                        if (!fullResponse.trim()) {
+                            fullResponse = '⚠️ 生成已中断 (用户取消)';
+                        }
+                    }
+                    else {
+                        // M1.2 (2026-06-17): 不再 rethrow — 把错误塞到 fullResponse 让 broadcast 出来, 后续 session 仍保存
+                        // 旧行为: 抛到外层 catch, 触发 500 + 用户消息丢失 (session 不保存)
+                        console.error(`[chat] LLM 调用失败 channel=${channelId}:`, err);
+                        fullResponse = `[错误: LLM 调用失败] ${String(err?.message || err).slice(0, 300)}`;
+                        broadcast({ type: 'error', content: fullResponse }, channelId);
                     }
                 }
-                else {
-                    // 没触发, 也清掉连续失败计数 (用户消息说明对话还在正常进行)
-                    clearFailure(channelId);
+                // abort 模式: 给 partial 拼后缀 — 只在 LLM 真有输出时加中断标记,
+                //   跳过空响应 + 跳过 [AI 服务调用失败] fallback (这些本身就是错误占位, 拼
+                //   "[生成已中断]" 会误导用户)
+                const hasRealLlmOutput = fullResponse.trim().length > 0 &&
+                    !fullResponse.trimStart().startsWith('[AI 服务调用失败]');
+                if (abortSignal?.aborted && hasRealLlmOutput) {
+                    fullResponse = fullResponse + '\n\n_[生成已中断]_';
+                }
+                // 2026-06-18: 修 lastFinalReply 没设 → /api/loop/inspect 永远返回空
+                runState.lastFinalReply = fullResponse;
+                // 2026-07-06: 防御性兜底 — fullResponse 为空时, 前端 segmentChatReply('') 返回 [],
+                //   导致气泡不渲染, 用户只看到"思考中"占位符. 这里保证永远有内容可渲染.
+                if (!fullResponse.trim()) {
+                    fullResponse = '⚠️ AI 未返回内容, 请重试';
+                    console.warn(`[chat] fullResponse empty for channel=${channelId}, using fallback`);
+                }
+                // v3 新增: 解析 LLM 回复里的 @-mentions, 转发到目标 channel
+                await routeMentionsInReply(channelId, fullResponse, localChannels, remoteChannels);
+                broadcast({ type: 'ai', content: fullResponse }, channelId);
+                const existingSession = await loadSession(channelId, currentSessionId);
+                const session = existingSession || { channelId, sessionId: currentSessionId, messages: [], lastUpdated: new Date().toISOString() };
+                session.sessionId = currentSessionId;
+                // v3: 加 source 标记 (local = 内部 owner, remote = 远端访客)
+                // 2026-07-15 修 Bug 4: client.ts sendMessage 已经通过 persistLastMessageToServer PATCH /sessions/.../...
+                //   把 user msg 落盘一次 (立即落, 切走再切回不丢). 这里再 push 一次 → session.messages 出现两条相同的 user msg,
+                //   loadSession 重渲染时两条都上屏, 表现"每条 user 气泡重复两次".
+                //   修法: 持久化以 client PATCH 为准, /message 这边只 push ai 消息. 同时去重检查上次的 user 避免极端竞态 (并行 PATCH).
+                const lastMsg = session.messages[session.messages.length - 1];
+                const userAlreadyPushed = lastMsg && lastMsg.type === 'user' && lastMsg.content === text;
+                if (!userAlreadyPushed) {
+                    session.messages.push({ id: crypto.randomUUID(), type: 'user', content: text, timestamp: new Date().toISOString(), source: 'local' });
                 }
-            }
-            catch (loaderErr) {
-                console.warn('[manifest-loader] failed (non-fatal):', loaderErr?.message?.slice(0, 200));
-            }
-            const channels = await loadChannels();
-            const channel = channels.find(c => c.id === channelId);
-            // 2026-06-11: 移除 suggestRename 的二次 LLM 调用 — 之前每次用户发消息, 智能体 channel 都会再调一次 LLM (5-8s) 自动改名
-            // 影响: (1) /message 端点被拖慢 5-8s (2) LLM 客户端排队, 其他 channel 跟着卡
-            // 现在改名逻辑挪到 /api/agent-rename 端点, 用户主动触发才跑
-            if (channel) {
-                channel.updatedAt = new Date().toISOString();
-                // 2026-08-02 fix: 原子写入, 防并发覆盖丢 channel
-                await updateChannels((chs) => {
-                    const c = chs.find(x => x.id === channelId);
-                    if (c)
-                        c.updatedAt = channel.updatedAt;
-                    return chs;
+                session.messages.push({
+                    id: crypto.randomUUID(),
+                    type: 'ai',
+                    content: fullResponse,
+                    timestamp: new Date().toISOString(),
+                    source: 'local',
+                    // P0.5: 这条 AI 回复引用了哪些 judgment (注入门回传)
+                    ...(usedJudgmentIds.length > 0 ? { metadata: { usedJudgmentIds } } : {}),
                 });
-            }
-            broadcast({ type: 'done' }, channelId);
-            // D 触发: AI 被动捕获判断力 (后台异步, 不阻塞主对话)
-            setImmediate(() => {
+                session.lastUpdated = new Date().toISOString();
+                await saveSession(session);
+                // 2026-07-04: 写 session 后, 调 memory-compressor 把消息历史压缩到
+                //   ~/.bolloon/memory/<channel.agentId>/sessions/<safe-channel>__<safe-session>.summary.md
+                // 失败静默, 不阻塞 /message 主路径.
                 try {
-                    const lastTurns = session.messages.slice(-6).map((m) => ({
-                        role: (m.type === 'user' ? 'human' : 'agent'),
-                        content: m.content,
-                    }));
-                    if (lastTurns.length < 2)
-                        return;
-                    broadcast({ type: 'phase', phase: 'd_detect', detail: '监测对话...' }, channelId);
-                    import('../pi-ecosystem-judgment/human-value-pipeline.js')
-                        .then(async ({ detectAndDistillFromChannel, throttleDHook }) => {
-                        // channel 维度 5min 节流, 防对话卡顿时 LLM 反复触发
-                        if (!throttleDHook(channelId, 5 * 60_000)) {
-                            console.log(`[D-hook ${channelId}] throttled (within 5min)`);
-                            broadcast({ type: 'phase', phase: 'd_skip', detail: 'throttled' }, channelId);
-                            return null;
+                    const channelsForMemory = await loadChannels();
+                    const channelForMemory = channelsForMemory.find(c => c.id === channelId);
+                    if (channelForMemory?.agentId) {
+                        const { compressSessionToMemory } = await import('../bootstrap/memory-compressor.js');
+                        const compressRes = await compressSessionToMemory({
+                            agentId: channelForMemory.agentId,
+                            channelId,
+                            sessionId: currentSessionId,
+                        });
+                        if (!compressRes.skipped && compressRes.bytesWritten > 0) {
+                            console.log(`[memory] compressed ${compressRes.messagesCount} new messages for ${channelForMemory.agentId}/${channelId} → ${compressRes.summaryPath} (${compressRes.bytesWritten}B)`);
                         }
-                        broadcast({ type: 'phase', phase: 'd_distill', detail: '蒸馏判断力...' }, channelId);
-                        return detectAndDistillFromChannel(lastTurns, { channelId });
-                    })
-                        .then((result) => {
-                        if (result && result.triggered) {
-                            console.log(`[D-hook ${channelId}] stored: ${result.reason}`, result.evolved);
-                            broadcast({ type: 'phase', phase: 'd_done', detail: result.reason }, channelId);
+                    }
+                }
+                catch (memErr) {
+                    console.warn('[memory] compressSessionToMemory failed (non-fatal):', memErr?.message?.slice(0, 200));
+                }
+                // 2026-07-05: 把 session 里的 user/ai 消息按涉及到的远端 peer 归档到月度 markdown
+                //   触发条件: 消息里出现过 @远端 channel, 或者 session 历史上与该 peer 通信过
+                //   失败静默, 不阻塞主对话
+                try {
+                    const { appendChatArchive } = await import('../bootstrap/chat-archiver.js');
+                    // 找到这条消息涉及到的远端 peer (从 routeMentionsInReply 的结果推断 — 简单起见直接遍历 remoteChannels)
+                    const localChannels2 = (await loadChannels());
+                    const remoteChannels2 = [];
+                    for (const [peerPk, list] of remoteChannelCache.entries()) {
+                        for (const ch of list) {
+                            remoteChannels2.push({ ...ch, _ownerPublicKey: peerPk });
                         }
-                        else if (result && result.reason) {
-                            console.log(`[D-hook ${channelId}] skipped: ${result.reason}`);
-                            broadcast({ type: 'phase', phase: 'd_skip', detail: result.reason }, channelId);
+                    }
+                    // 找出本次 text/fullResponse 里出现 @ 的 channel 对应的 owner pk
+                    const peerSet = new Set();
+                    const mentionRe = /@([一-龥A-Za-z0-9_\-]{1,30})/g;
+                    const mentionedNames = new Set();
+                    for (const m of text.matchAll(mentionRe))
+                        mentionedNames.add(m[1]);
+                    for (const m of fullResponse.matchAll(mentionRe))
+                        mentionedNames.add(m[1]);
+                    for (const rc of remoteChannels2) {
+                        if (mentionedNames.has(rc.name))
+                            peerSet.add(rc._ownerPublicKey);
+                    }
+                    // 追加到每个相关 peer 的月度归档
+                    for (const pk of peerSet) {
+                        await appendChatArchive({
+                            publicKey: pk,
+                            entry: {
+                                ts: new Date().toISOString(),
+                                source: 'local',
+                                channelId, channelName: (await loadChannels()).find(c => c.id === channelId)?.name,
+                                text: `[本节点] user: ${text.slice(0, 500)}\n[本节点] ai: ${fullResponse.slice(0, 800)}`,
+                                fromPublicKey: v3P2PRef?.getPublicKey(),
+                                msgType: 'user',
+                            }
+                        });
+                    }
+                }
+                catch (archiveErr) {
+                    console.warn('[chat-archive] append failed (non-fatal):', archiveErr?.message?.slice(0, 200));
+                }
+                // 2026-07-05: 懒加载触发器 — 探测到 @-mention 远端 / 连续失败 / 关键词, 拉对方 manifest
+                //   把 capability-index 拼到下一次 prompt 上下文 (只生效 1 次, 不污染主循环)
+                try {
+                    const { detectLoadTrigger, loadPeerManifest, clearFailure } = await import('../agents/peer-manifest-loader.js');
+                    const remoteChannelsForDetect = [];
+                    for (const [peerPk, list] of remoteChannelCache.entries()) {
+                        for (const ch of list) {
+                            remoteChannelsForDetect.push({ ...ch, _ownerPublicKey: peerPk });
                         }
-                    })
-                        .catch((err) => {
-                        console.warn(`[D-hook ${channelId}] failed:`, err);
-                        broadcast({ type: 'phase', phase: 'd_error', detail: String(err) }, channelId);
+                    }
+                    // 检测 + 加载
+                    const detection = detectLoadTrigger({
+                        text,
+                        channelId,
+                        remoteChannels: remoteChannelsForDetect,
                     });
+                    if (detection.shouldLoad && detection.remotePublicKey && v3P2PRef) {
+                        const result = await loadPeerManifest({
+                            channelId,
+                            channelName: (await loadChannels()).find(c => c.id === channelId)?.name,
+                            reason: detection.reason,
+                            triggerValue: detection.triggerValue,
+                            remotePublicKey: detection.remotePublicKey,
+                        }, { p2p: v3P2PRef });
+                        if (result && result.promptBlock) {
+                            console.log(`[manifest-loader] ${detection.reason} → ${detection.remotePublicKey.slice(0, 12)}... (${result.durationMs}ms, rpc=${result.rpcTriggered}, agents=${result.agentDescriptions.length})`);
+                            // 把 promptBlock 推给前端 + 写入一次性的 prompt 附加 (nextPromptHint 全局变量, 在下次 agent.promptStream 前 prepend)
+                            broadcast({
+                                type: 'peer-manifest-loaded',
+                                fromPublicKey: detection.remotePublicKey,
+                                reason: detection.reason,
+                                promptBlock: result.promptBlock,
+                                capabilityIndex: result.capabilityIndex,
+                            }, channelId);
+                            // 缓存到 channel 维度的 nextPromptHint (下一次 LLM prompt 前 inject)
+                            nextPromptHints.set(channelId, (nextPromptHints.get(channelId) || '') + '\n\n' + result.promptBlock);
+                            clearFailure(channelId);
+                        }
+                    }
+                    else {
+                        // 没触发, 也清掉连续失败计数 (用户消息说明对话还在正常进行)
+                        clearFailure(channelId);
+                    }
                 }
-                catch (err) {
-                    console.warn(`[D-hook ${channelId}] sync error:`, err);
+                catch (loaderErr) {
+                    console.warn('[manifest-loader] failed (non-fatal):', loaderErr?.message?.slice(0, 200));
+                }
+                const channels = await loadChannels();
+                const channel = channels.find(c => c.id === channelId);
+                // 2026-06-11: 移除 suggestRename 的二次 LLM 调用 — 之前每次用户发消息, 智能体 channel 都会再调一次 LLM (5-8s) 自动改名
+                // 影响: (1) /message 端点被拖慢 5-8s (2) LLM 客户端排队, 其他 channel 跟着卡
+                // 现在改名逻辑挪到 /api/agent-rename 端点, 用户主动触发才跑
+                if (channel) {
+                    channel.updatedAt = new Date().toISOString();
+                    // 2026-08-02 fix: 原子写入, 防并发覆盖丢 channel
+                    await updateChannels((chs) => {
+                        const c = chs.find(x => x.id === channelId);
+                        if (c)
+                            c.updatedAt = channel.updatedAt;
+                        return chs;
+                    });
                 }
-            });
-            // 2026-06-11: 202 已发的话, 不要重复 res.json (会抛 ERR_HTTP_HEADERS_SENT)
-            if (!res.headersSent)
-                res.json({ ok: true });
-        }
-        catch (err) {
-            broadcast({ type: 'error', content: err.message }, channelId);
-            broadcast({ type: 'done' }, channelId);
-            if (!res.headersSent)
-                res.status(500).json({ error: err.message });
-        }
-        finally {
-            // 2026-07-04: 清掉 pivot 强制 timeout timer, 避免 hang 情况下 timer 在
-            //   process 里一直挂着. forceTimeout 在 try 外创建, finally 在闭包里
-            //   能直接拿到引用.
-            clearTimeout(forceTimeout);
-            // queue dequeue: 跑完或失败都要清状态
-            runState.running = false;
-            runState.abortController = null;
-            broadcastQueueUpdate(channelId);
-            // 2026-07-15 修 Bug 8: 队列自动 drain — 之前只清状态不抽下一条, 用户连续发的所有
-            //   第二轮起全卡在 queue 里出不来, 表现"第二轮没反应".
-            //   修复: finally 里查 queue, 非空就异步 fire-and-forget 起下一轮.
-            //   实现要点:
-            //     1. 用 setImmediate / Promise.resolve() 让 res.headersSent 干净
-            //     2. 不能 await (否则阻塞 finally 后面的 saveSession; 而且这就是 fire-and-forget)
-            //     3. 重新 build contextHint, 走相同 LLM 路径
-            if (runState.queue.length > 0) {
-                const next = runState.queue.shift();
-                console.log(`[queue-drain] channel=${next.channelId} text="${next.text.slice(0, 30)}" attach=${(next.attachments?.length ?? 0)}`);
-                // 异步跑下一条 (fire-and-forget)
+                broadcast({ type: 'done' }, channelId);
+                // D 触发: AI 被动捕获判断力 (后台异步, 不阻塞主对话)
                 setImmediate(() => {
-                    void runMessageFromQueue(next).catch((e) => {
-                        console.error('[queue-drain] error:', e?.message?.slice(0, 200));
-                    });
+                    try {
+                        const lastTurns = session.messages.slice(-6).map((m) => ({
+                            role: (m.type === 'user' ? 'human' : 'agent'),
+                            content: m.content,
+                        }));
+                        if (lastTurns.length < 2)
+                            return;
+                        broadcast({ type: 'phase', phase: 'd_detect', detail: '监测对话...' }, channelId);
+                        import('../pi-ecosystem-judgment/human-value-pipeline.js')
+                            .then(async ({ detectAndDistillFromChannel, throttleDHook }) => {
+                            // channel 维度 5min 节流, 防对话卡顿时 LLM 反复触发
+                            if (!throttleDHook(channelId, 5 * 60_000)) {
+                                console.log(`[D-hook ${channelId}] throttled (within 5min)`);
+                                broadcast({ type: 'phase', phase: 'd_skip', detail: 'throttled' }, channelId);
+                                return null;
+                            }
+                            broadcast({ type: 'phase', phase: 'd_distill', detail: '蒸馏判断力...' }, channelId);
+                            return detectAndDistillFromChannel(lastTurns, { channelId });
+                        })
+                            .then((result) => {
+                            if (result && result.triggered) {
+                                console.log(`[D-hook ${channelId}] stored: ${result.reason}`, result.evolved);
+                                broadcast({ type: 'phase', phase: 'd_done', detail: result.reason }, channelId);
+                            }
+                            else if (result && result.reason) {
+                                console.log(`[D-hook ${channelId}] skipped: ${result.reason}`);
+                                broadcast({ type: 'phase', phase: 'd_skip', detail: result.reason }, channelId);
+                            }
+                        })
+                            .catch((err) => {
+                            console.warn(`[D-hook ${channelId}] failed:`, err);
+                            broadcast({ type: 'phase', phase: 'd_error', detail: String(err) }, channelId);
+                        });
+                    }
+                    catch (err) {
+                        console.warn(`[D-hook ${channelId}] sync error:`, err);
+                    }
                 });
+                // 2026-06-11: 202 已发的话, 不要重复 res.json (会抛 ERR_HTTP_HEADERS_SENT)
+                if (!res.headersSent)
+                    res.json({ ok: true });
             }
-            // 2026-07-01 (v0.2.5): 持久化当前 messageHistory — 让 web 用户跨刷新保留对话.
-            //   saveCurrentSession 失败静默, 不阻塞 channel 状态清理.
-            //   saveCurrentSession 内部走 SessionStore (默认 ~/.bolloon/sessions/cache/<sessionKey>.json).
-            //   agent 可能在 try 抛错后仍为 null (getAgentForChannel 失败), null-guard 跳过 save.
-            if (agent) {
-                try {
-                    await agent.saveCurrentSession(sessionKey);
+            catch (err) {
+                broadcast({ type: 'error', content: err.message }, channelId);
+                broadcast({ type: 'done' }, channelId);
+                if (!res.headersSent)
+                    res.status(500).json({ error: err.message });
+            }
+            finally {
+                // 2026-07-04: 清掉 pivot 强制 timeout timer, 避免 hang 情况下 timer 在
+                //   process 里一直挂着. forceTimeout 在 try 外创建, finally 在闭包里
+                //   能直接拿到引用.
+                clearTimeout(forceTimeout);
+                finishChannelRun(channelId, runState);
+                // 2026-07-01 (v0.2.5): 持久化当前 messageHistory — 让 web 用户跨刷新保留对话.
+                //   saveCurrentSession 失败静默, 不阻塞 channel 状态清理.
+                //   saveCurrentSession 内部走 SessionStore (默认 ~/.bolloon/sessions/cache/<sessionKey>.json).
+                //   agent 可能在 try 抛错后仍为 null (getAgentForChannel 失败), null-guard 跳过 save.
+                if (agent) {
+                    try {
+                        await agent.saveCurrentSession(sessionKey);
+                    }
+                    catch (saveErr) {
+                        console.warn(`[web] saveCurrentSession failed (non-fatal): ${saveErr.message?.slice(0, 100)}`);
+                    }
                 }
-                catch (saveErr) {
-                    console.warn(`[web] saveCurrentSession failed (non-fatal): ${saveErr.message?.slice(0, 100)}`);
+                // 2026-08-02: run-end skill 候选扫描 (fire-and-forget, 不阻塞 finally)
+                //   从本轮 lastSteps 提取连续成功的工具调用模式, 写入 ~/.bolloon/skill-candidates/.
+                //   agent 之后可调 list_skill_candidates / promote_skill 决定是否转正.
+                // 2026-08-04: 抽公共函数 writeRunEndSkillCandidates (Web server 与 CLI 共用)
+                try {
+                    const steps = runState.lastSteps || [];
+                    const okTools = steps.filter(s => s.status === 'ok' && s.name && s.name !== 'system');
+                    if (okTools.length >= 2) {
+                        setImmediate(async () => {
+                            try {
+                                const { writeRunEndSkillCandidates } = await import('../agents/skill-writer.js');
+                                const r = await writeRunEndSkillCandidates(steps, `channel:${channelId}`);
+                                if (r.wrote)
+                                    console.log(`[skill-candidates] 写入候选 ${r.file} (${r.count} tools)`);
+                            }
+                            catch (candErr) {
+                                console.warn('[skill-candidates] 写入失败 (non-fatal):', candErr?.message?.slice(0, 150));
+                            }
+                        });
+                    }
                 }
+                catch { /* 非致命 */ }
             }
-            // 2026-08-02: run-end skill 候选扫描 (fire-and-forget, 不阻塞 finally)
-            //   从本轮 lastSteps 提取连续成功的工具调用模式, 写入 ~/.bolloon/skill-candidates/.
-            //   agent 之后可调 list_skill_candidates / promote_skill 决定是否转正.
-            // 2026-08-04: 抽公共函数 writeRunEndSkillCandidates (Web server 与 CLI 共用)
+        };
+        // 投进该 channel 的内核邮箱: 同通道 FIFO 串行 / 跨通道并行 (与 didFix 共用同一邮箱, 语义一致)。
+        // 失败必须**响亮** (不许静默吞掉一条没跑的消息)。
+        void getChannelQueue(channelId).submit(runChannelMessage).catch((e) => {
+            console.error('[K8] runChannelMessage 失败:', e?.message?.slice(0, 200));
             try {
-                const steps = runState.lastSteps || [];
-                const okTools = steps.filter(s => s.status === 'ok' && s.name && s.name !== 'system');
-                if (okTools.length >= 2) {
-                    setImmediate(async () => {
-                        try {
-                            const { writeRunEndSkillCandidates } = await import('../agents/skill-writer.js');
-                            const r = await writeRunEndSkillCandidates(steps, `channel:${channelId}`);
-                            if (r.wrote)
-                                console.log(`[skill-candidates] 写入候选 ${r.file} (${r.count} tools)`);
-                        }
-                        catch (candErr) {
-                            console.warn('[skill-candidates] 写入失败 (non-fatal):', candErr?.message?.slice(0, 150));
-                        }
-                    });
-                }
+                broadcast({ type: 'error', content: `执行失败: ${String(e?.message || e).slice(0, 200)}` }, channelId);
             }
-            catch { /* 非致命 */ }
-        }
+            catch { /* 广播失败不影响错误已记 */ }
+            try {
+                broadcast({ type: 'done' }, channelId);
+            }
+            catch { /* 同上 */ }
+        });
     });
     // ---------- 频道元数据后台修复队列 ----------
     // 关键点: 旧实现会在每次 GET /channels 时同步执行 KeyManager.generate() + IPFS POST,
     // 多频道场景下持续分配密钥对 + 发起 HTTP 请求, 几轮就会把 Node 内存撑爆。
     // 新实现: 入队 + 节流(2s) + 单飞, 立刻返回当前 channels, 修复异步进行。
-    const didFixQueue = new Set(); // 待修复的 channelId
-    let didFixRunning = false;
+    const didFixQueue = new Set(); // 待修复的 channelId (调度节流的**入队缓冲**, 执行已交内核邮箱)
     let didFixTimer = null;
     // 2026-08-02: channelRunState 已提升为模块级 (triggerRemoteFollowup 也访问), 这里复用
     function getOrCreateRunState(channelId) {
         let s = channelRunState.get(channelId);
         if (!s) {
-            s = { running: false, queue: [], abortController: null, lastSteps: [], lastSummary: '', lastFinalReply: '', lastTokens: {} };
+            s = { running: false, lastSteps: [], lastSummary: '', lastFinalReply: '', lastTokens: {} };
             channelRunState.set(channelId, s);
         }
         return s;
     }
-    /** 抽离 attachment contextHint 出来 — 给 queue-drain 用; /message 主路径有 inline 等价版避免重复 hoist 错误 */
-    function buildAttachmentContextForQueue(parsedAttachments) {
-        if (!parsedAttachments || parsedAttachments.length === 0)
-            return '';
-        return `[系统上下文] 用户上传了 ${parsedAttachments.length} 个附件: ` +
-            parsedAttachments.map((a) => `${a.filename || a.attachmentId} (id=${a.attachmentId}, mime=${a.mimeType || '?'}, size=${a.size ?? '?'}B, URL=/api/attachments/${a.attachmentId})`).join('; ') +
-            `\n你可以调用文件读工具 (curl /api/attachments/<id>) 拉取真实内容。\n\n`;
-    }
+    // K8 正刀 (2026-10-02): `runMessageFromQueue` (排在队尾执行的**简化版**第二条路径) 与它专用的
+    //   `buildAttachmentContextForQueue` 一并删除 —— 每条消息现在都走 `runChannelMessage` 这**一条**完整路径,
+    //   通道自带的 queue 与异步 handoff 都不复存在 (旧 handoff 会静默丢消息, 见先行门 ③)。
     /**
-     * 2026-07-15 修 Bug 8: 队列消息的执行器 — finally 排空 queue 时调这里
-     * 跑下一条 queued 消息.
+     * 一轮跑完的收尾 (2026-10-02 K8 → K8 正刀)。
      *
-     * 设计: 这是个 fire-and-forget wrapper, 复用 /message 主路径的 broadcast / save / etc.
-     * 简化路径 (跟主路径 500 行 try 块相比):
-     *   - 不重新建载 judgment hint / persona / context — server.ts 这次明确把这些容
-     *     易"廉价放"在 /message 主路径, queue 路径只用基本标识
-     *   - 仍然是合法: agent.promptStream → broadcast(type:user) → broadcast(type:ai) → done
-     *   - 处理 attachments: 跟主路径一样
+     * **它现在只做三件事**: 清"在飞"标志 · 清 abort 句柄 · 广播状态。
+     * **不再排空队列** —— 正刀后每条消息一进来就投该 channel 的**内核邮箱**
+     * (`getChannelQueue(channelId).submit(runChannelMessage)`), 同通道 FIFO 串行由内核保证 (与 K5 同一条语义),
+     * 通道自己不再兼任调度器, 也不再有"同步置 `running = false` + 异步 handoff"这一步
+     * (正是那一步会让排队消息被静默丢掉 —— 见 `src/test/k8-mailbox-scheduling.test.ts` ③ 的机制复刻)。
      *
-     * 如果要 1:1 复刻主路径的所有 hooks (judgment hint / persona / manifest / etc),
-     * 后续可以把 /message 主路径的 try 块抽成 runPromptChannel 共享.
+     * 顺带删掉的: `runMessageFromQueue` (排在队尾执行的**简化版第二条路径**, 没有 judgment hint / persona /
+     * slash 命令 / 附件上下文) 与它专用的 `buildAttachmentContextForQueue` —— 现在只有**一条**完整路径。
      */
-    async function runMessageFromQueue(queued) {
-        const { channelId, text, attachments, channelDid: reqChannelDid, boundWalletAddress, autoToolsEnabled } = queued;
-        const runState = getOrCreateRunState(channelId);
-        if (runState.running)
-            return; // 防重入 — queue 已经并发去重
-        runState.running = true;
-        runState.abortController = new AbortController();
-        const currentSessionId = (await loadChannels()).find(c => c.id === channelId)?.currentSessionId || 'default';
-        const realChannelDid = reqChannelDid || (await loadChannels()).find(c => c.id === channelId)?.did || '';
-        const parsedAttachments = Array.isArray(attachments) ? attachments : [];
-        const attachmentContext = buildAttachmentContextForQueue(parsedAttachments);
-        const sessionKey = `${channelId}:${currentSessionId}`;
-        // 防 LLM hang 安全网
-        const PIVOT_FORCE_TIMEOUT_MS = 5 * 60 * 1000;
-        const forceTimeout = setTimeout(() => {
-            console.warn(`[server] queue-drain pivot 强制 timeout, aborting`);
-            runState.abortController?.abort();
-        }, PIVOT_FORCE_TIMEOUT_MS);
-        let agent = null;
-        try {
-            // 1) broadcast user 给前端 (跟主路径一致)
-            broadcast({ type: 'user', content: text }, channelId);
-            // 2) 取 agent + session
-            agent = await getAgentForChannel(channelId, currentSessionId).catch(() => null);
-            if (!agent) {
-                throw new Error(`No agent for channel=${channelId}`);
-            }
-            // 3) 重 build contextHint (基本版, 不全 500 行 hook)
-            //   原因: queue-drain 是常见调试路径, 全量 hooks 性能大. 关键是 attachments 带上.
-            const contextHint = attachmentContext + `[系统上下文] 队列消息 (auto-drain)\n`;
-            // 4) promptStream
-            const markedPrompt = `【本轮用户请求】\n${text}\n【请求结束】\n\n${contextHint}`;
-            const agentForRun = agent;
-            const fullResponse = await deliverThroughActor(agentForRun, () => agentForRun.promptStream(markedPrompt, () => { }, runState.abortController?.signal, channelId));
-            if (!fullResponse.trim()) {
-                broadcast({ type: 'error', content: '⚠️ AI 未返回内容' }, channelId);
-            }
-            else {
-                broadcast({ type: 'ai', content: fullResponse }, channelId);
-                // 落 session
-                try {
-                    const existing = await loadSession(channelId, currentSessionId);
-                    const session = existing || { channelId, sessionId: currentSessionId, messages: [], lastUpdated: new Date().toISOString() };
-                    session.sessionId = currentSessionId;
-                    // 跟主路径相同: 不重复 push user (主路径已 broadcast/push), 只 push ai
-                    session.messages.push({
-                        id: crypto.randomUUID(),
-                        type: 'ai',
-                        content: fullResponse,
-                        timestamp: new Date().toISOString(),
-                        source: 'local',
-                    });
-                    session.lastUpdated = new Date().toISOString();
-                    await saveSession(session);
-                }
-                catch (e) {
-                    console.warn('[queue-drain] saveSession failed:', e?.message?.slice(0, 100));
-                }
-            }
-            broadcast({ type: 'done' }, channelId);
-        }
-        catch (err) {
-            console.warn('[queue-drain] failed:', err?.message?.slice(0, 200));
-            broadcast({ type: 'error', content: 'queue-drain: ' + (err?.message || 'failed') }, channelId);
-        }
-        finally {
-            clearTimeout(forceTimeout);
-            runState.running = false;
-            runState.abortController = null;
-            broadcastQueueUpdate(channelId);
-            // 递归 drain — 同 /message 主路径 finally 行为保持一致
-            if (runState.queue.length > 0) {
-                const next = runState.queue.shift();
-                console.log(`[queue-drain-recursive] channel=${next.channelId} text="${next.text.slice(0, 30)}"`);
-                setImmediate(() => {
-                    void runMessageFromQueue(next).catch((e) => {
-                        console.error('[queue-drain-recursive] error:', e?.message?.slice(0, 200));
-                    });
-                });
-            }
-            if (agent) {
-                try {
-                    await agent.saveCurrentSession(sessionKey);
-                }
-                catch { }
-            }
-        }
+    function finishChannelRun(channelId, runState) {
+        // K8 正刀 (2026-10-02): **这里不再排空队列** —— 每条消息自己进内核邮箱, 通道不持有队列,
+        //   也就不存在"同步置 running=false + 异步 handoff"那一步 (那一步会静默丢消息, 见先行门 ③)。
+        runState.running = false;
+        // K8 收尾: 取消位不在这里复位 —— 它属于 actor, 下一次 beginCancellation() 自然换代
+        broadcastQueueUpdate(channelId);
     }
     function broadcastQueueUpdate(channelId) {
         const s = channelRunState.get(channelId);
-        const queueLength = s ? s.queue.length : 0;
         const running = s ? s.running : false;
+        // K8 正刀 (2026-10-02): 队列长度改读**内核邮箱** (通道不再自己数) —— pending 含正在跑的那条, 减掉它才是"等待中"。
+        const pending = getChannelQueue(channelId).pending;
+        const queueLength = Math.max(0, pending - (running ? 1 : 0));
         try {
             broadcast({ type: 'queue_update', channelId, queueLength, running }, channelId);
         }
@@ -5845,25 +5777,28 @@ fetchState();
             void runDidFixOnce();
         }, 2000);
     }
+    /**
+     * K8 收口 (2026-10-02): 待办**不再由通道自己单飞**。
+     *
+     * 旧写法 = `didFixRunning` 全局单飞 + while 循环自己取件 ⇒ "各通道自己的调度状态"。
+     * 新写法 = 执行投进该 channel 的**内核邮箱** (`getChannelQueue`), 由 `SerialMailbox` 串行:
+     *   · 同 channel 的修复**串行** (不会两个 repairs 同时 load/save 同一份 channels)
+     *   · 跨 channel 可并行 (K5 既定语义: 同通道串行 / 跨通道并行)
+     * 2s 节流 + 入队 Set 保留 (那是**调度策略**, 不是执行机制)。
+     *
+     * ⚠️ 行为差量 (如实记): 旧实现全局一次一个 repair; 新实现同通道串行、跨通道可并行。
+     */
     async function runDidFixOnce() {
-        if (didFixRunning)
-            return;
-        didFixRunning = true;
-        try {
-            while (didFixQueue.size > 0) {
-                const id = didFixQueue.values().next().value;
-                didFixQueue.delete(id);
-                try {
-                    await fixOneChannelDID(id);
-                }
-                catch (e) {
-                    console.log(`[DID 修复] ${id} 失败: ${e.message}`);
-                }
+        const ids = [...didFixQueue];
+        didFixQueue.clear();
+        await Promise.all(ids.map((id) => getChannelQueue(id).submit(async () => {
+            try {
+                await fixOneChannelDID(id);
             }
-        }
-        finally {
-            didFixRunning = false;
-        }
+            catch (e) {
+                console.log(`[DID 修复] ${id} 失败: ${e.message}`);
+            }
+        })));
     }
     async function fixOneChannelDID(channelId) {
         const channels = await loadChannels();
@@ -6974,7 +6909,8 @@ fetchState();
             // 2026-06-15: 同 /message 路径, 用显式 marker 包裹 userMessage, 避免 LLM 把它当背景信息
             const regenHint = await buildJudgmentHint(channel, channelId);
             const markedRegen = `${regenHint}\n\n【本轮用户请求】\n${userMessage}\n【请求结束】\n`;
-            fullResponse = await deliverThroughActor(agent, () => agent.promptStream(markedRegen, streamCallback, undefined, channelId));
+            // 2026-10-02 (K8): 同上 (零差量)
+            fullResponse = await deliverThroughActor(agent, () => requireRunExecution(agent)({ input: markedRegen, onStream: streamCallback, channelId }));
             // 2026-07-06: 防御性兜底 — 同 /message 路径
             if (!fullResponse.trim()) {
                 fullResponse = '⚠️ AI 未返回内容, 请重试';
@@ -8053,10 +7989,10 @@ fetchState();
             const { channelId } = req.body;
             if (!channelId)
                 return res.status(400).json({ error: 'channelId required' });
-            const s = channelRunState.get(channelId);
-            if (s?.abortController) {
-                s.abortController.abort();
-                console.log(`[abort] user aborted channel=${channelId}`);
+            // K8 收尾: 中止经内核 actor 注册表 (按 channel 扫描; 返回**真的中止了几个**)
+            const aborted = abortActorsOfChannel(channelId, 'user abort');
+            if (aborted > 0) {
+                console.log(`[abort] user aborted channel=${channelId} (${aborted} 个 actor)`);
                 // 2026-08-02 fix: abort 后立即广播 done — 之前前端靠 1.5s 兜底 setTimeout 切回 idle,
                 //   视觉上"点了没反应". 这里主动推 done, 前端 finalizeTimelineAsMessage + setSendMode('idle') 立刻生效.
                 try {