@bolloon/bolloon-agent 0.6.5 → 0.6.7

package/dist/ios/routes-contacts.js

@@ -413,8 +413,101 @@ export function registerContactRoutes(app, opts = {}) {
             res.status(500).json({ ok: false, error: String(err?.message || err) });
         }
     });
+    // ── 手机号目录 (2026-10-11, phone-account-lookup-design 落点 A) ────────────
+    // 隐私: 请求/响应全程只过「盲化哈希」, 明文手机号只在请求体出现一次 (发布/查询),
+    //       永不出现在响应里 (与 contacts 既有红线一致)。
+    const dirHome = () => opts.home || undefined;
+    /** 发布手机号 → DID 指针 (opt-in; 用户显式调用) */
+    app.post('/api/contacts/directory/publish', async (req, res) => {
+        try {
+            const { publishEntry, isPlausiblePhone } = await import('../agents/contacts/human-directory.js');
+            const phone = String(req.body?.phone || '');
+            const did = String(req.body?.did || ownerDidFromDisk());
+            if (!isPlausiblePhone(phone))
+                return res.status(400).json({ ok: false, error: '手机号格式不正确' });
+            const e = await publishEntry(phone, did, {
+                displayName: req.body?.displayName ? String(req.body.displayName) : undefined,
+                publicKeyHex: req.body?.publicKeyHex ? String(req.body.publicKeyHex) : undefined,
+                homeDir: dirHome(),
+            });
+            res.json({ ok: true, phoneHash: e.phoneHash.slice(0, 8) + '…', did: e.did, publicKeyHex: e.publicKeyHex || null, publishedAt: e.publishedAt });
+        }
+        catch (err) {
+            res.status(500).json({ ok: false, error: String(err?.message || err) });
+        }
+    });
+    /** 撤销目录条目 (软删) */
+    app.post('/api/contacts/directory/retract', async (req, res) => {
+        try {
+            const { retractEntry } = await import('../agents/contacts/human-directory.js');
+            const did = String(req.body?.did || ownerDidFromDisk());
+            const ok = await retractEntry(did, dirHome());
+            res.json({ ok, revoked: ok });
+        }
+        catch (err) {
+            res.status(500).json({ ok: false, error: String(err?.message || err) });
+        }
+    });
+    /** 按手机号查账号 (在本机目录内找; 响应只回 DID/昵称, 绝不回手机号) */
+    app.post('/api/contacts/directory/lookup', async (req, res) => {
+        try {
+            const { lookupPhone, isPlausiblePhone } = await import('../agents/contacts/human-directory.js');
+            const phone = String(req.body?.phone || '');
+            if (!isPlausiblePhone(phone))
+                return res.status(400).json({ ok: false, error: '手机号格式不正确' });
+            const r = await lookupPhone(phone, dirHome());
+            if (!r.found)
+                return res.json({ ok: true, found: false, note: '未找到 (未注册或未公开)' });
+            res.json({ ok: true, found: true, did: r.did, publicKeyHex: r.publicKeyHex || null, displayName: r.displayName || null });
+        }
+        catch (err) {
+            res.status(500).json({ ok: false, error: String(err?.message || err) });
+        }
+    });
+    /** 按手机号直接发好友请求 (P1, 2026-10-15): directory lookup → publicKeyHex → 既有 /api/friend-request */
+    app.post('/api/contacts/directory/add-friend', async (req, res) => {
+        try {
+            const { lookupPhone, isPlausiblePhone } = await import('../agents/contacts/human-directory.js');
+            const phone = String(req.body?.phone || '');
+            if (!isPlausiblePhone(phone))
+                return res.status(400).json({ ok: false, error: '手机号格式不正确' });
+            const r = await lookupPhone(phone, dirHome());
+            if (!r.found)
+                return res.json({ ok: true, found: false, note: '未找到 (未注册或未公开)' });
+            if (!r.publicKeyHex)
+                return res.status(422).json({ ok: false, found: true, error: `对方已注册目录但未公开 P2P 公钥 (${r.did?.slice(0, 20)}…), 无法直接加好友` });
+            // 委托给既有好友请求链路 (本机端口; 与 pi-sdk accept 工具同口径)
+            const port = process.env.PORT || '54188';
+            const fr = await fetch(`http://127.0.0.1:${port}/api/friend-request`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    targetPublicKey: r.publicKeyHex,
+                    name: req.body?.name ? String(req.body.name) : r.displayName || undefined,
+                    message: req.body?.message ? String(req.body.message) : `来自手机号目录: 想加你为好友`,
+                    note: `via-phone-directory`,
+                }),
+            });
+            const data = await fr.json();
+            res.status(fr.status).json({ ok: data.ok !== false, found: true, did: r.did, friend: data });
+        }
+        catch (err) {
+            res.status(500).json({ ok: false, error: String(err?.message || err) });
+        }
+    });
+    /** 列出已发布条目 (本机审计; 只回脱敏哈希) */
+    app.get('/api/contacts/directory/list', async (_req, res) => {
+        try {
+            const { readDirectory, summarizeEntries } = await import('../agents/contacts/human-directory.js');
+            const entries = await readDirectory(dirHome());
+            res.json({ ok: true, entries: summarizeEntries(entries) });
+        }
+        catch (err) {
+            res.status(500).json({ ok: false, error: String(err?.message || err) });
+        }
+    });
     // ── 隐藏守卫自检 (验收/测试直接用) ──────────────────────────────────────────
     app.get('/api/contacts/_selfcheck', (_req, res) => {
-        res.json({ ok: true, plaintextGuard: looksLikePlaintextSecret({ contacts: [{ value: '+8613812345678' }] }) });
+        res.json({ ok: true, plaintextGuard: looksLikePlaintextSecret({ contacts: [{ value: '+861****5678' }] }) });
     });
 }

package/dist/ios/routes-world.js

@@ -12,7 +12,10 @@ function bodyOf(req) {
 }
 /** 限制输入形状: 只收明确字段, 不整个吞前端对象 */
 function intentInputFromBody(body) {
-    const b = bodyOf(body);
+    // 2026-10-06 修 bug: 之前调 bodyOf(body) —— bodyOf 期望 Request 访问 .body,
+    //   传 body 对象本身时 req.body = body.body = undefined ⇒ 永远返回 {} ⇒ 所有字段都丢。
+    //   body 此刻已是 express.json 解析后的对象, 直接校验即可。
+    const b = body && typeof body === 'object' ? body : {};
     const out = {};
     if (typeof b.text === 'string' && b.text.trim())
         out.text = b.text.trim();
@@ -69,7 +72,15 @@ export function registerWorldRoutes(app) {
         const minScore = Number(minScoreRaw);
         const limitRaw = typeof req.query.limit === 'string' ? req.query.limit : '50';
         const limit = Math.max(1, Math.min(200, parseInt(limitRaw, 10) || 50));
-        const r = await scanOpportunities({ minScore: Number.isFinite(minScore) ? minScore : 0.4, limit });
+        // 2026-10-16: 通讯录卡片 — dids=<did1>,<did2> 只返回这些 provider 投递的机会 (手机号通讯录联系人)
+        const providerDids = typeof req.query.dids === 'string'
+            ? req.query.dids.split(',').map((d) => d.trim()).filter(Boolean)
+            : [];
+        const r = await scanOpportunities({
+            minScore: Number.isFinite(minScore) ? minScore : 0.4,
+            limit,
+            providerDids: providerDids.length ? providerDids : undefined,
+        });
         if (!r.ok)
             return json(res, 500, { ok: false, error: r.error });
         json(res, 200, { ok: true, count: r.results.length, minScore, opportunities: r.results });

package/dist/ios/server.js

@@ -920,6 +920,7 @@ async function handleV3P2PMessage(parsed, conn, comm) {
                             output: event.output,
                             error: event.error,
                             args: event.args,
+                            durationMs: event.durationMs, // 2026-10-12: 命令执行时间读秒
                             fromPublicKey: v3P2PRef?.getPublicKey() || ''
                         }
                     });
@@ -1668,6 +1669,30 @@ export async function createWebServer(port = 3000, options = {}) {
     catch (err) {
         console.warn('[runs] 对账失败 (非致命):', err?.message);
     }
+    // 2026-10-16 (leo: 双内核冗余 — 独立 kernel 守护进程): HA 双活 — 主进程以 primary 写心跳,
+    //   spawn 独立 kernel 守护进程 (standby), 主死 → daemon 接管; daemon 死 → 自动重启。
+    //   环境变量门控: BOLLOON_HA=1 启用 (默认关 — 单节点常规运行不启动额外进程)。
+    if (process.env.BOLLOON_HA === '1') {
+        try {
+            const { createHaSupervisor } = await import('../agents/ha-supervisor.js');
+            const haSup = createHaSupervisor({
+                log: (level, message) => {
+                    if (level === 'error')
+                        console.warn(message);
+                    else if (level === 'warn')
+                        console.warn(message);
+                    else if (process.env.BOLLOON_VERBOSE === '1')
+                        console.log(message);
+                },
+            });
+            await haSup.start();
+            globalThis.__bolloonHaSupervisor = haSup;
+            console.log('[ha] 双活守护已启动 (primary 心跳 + standby kernel 守护进程)');
+        }
+        catch (err) {
+            console.warn('[ha] 双活守护启动失败 (非致命):', err?.message);
+        }
+    }
     // 2026-09-16 (M2-B): ExecutionSupervisor —— 长期执行层。
     //   页面关掉、进程重启后由它把 Goal 继续下去; 跨进程排他靠 Goal lease (不是内存状态)。
     //   Harness 管"这一段能不能安全执行", Supervisor 管"这个目标还要不要继续执行"。
@@ -4941,7 +4966,7 @@ fetchState();
             //   (与邮箱串行一致), web 不再自己持 abortController。取到 agent 后立刻开户 (见下面 getAgentForChannel 之后)。
             let abortSignal;
             // 2026-07-04: pivot loop safety net — 防止 LLM hang (minimax M3
-            //   偶尔反复 think 不输出 <final gen>, pivot 连 5 次无进展时会 hang 在
+            //   偶尔反复 think 不输出结果, pivot 连 5 次无进展时会 hang 在
             //   quality 评估). setTimeout 让 LLM 客户端收 signal 主动 break.
             // 2026-07-06: 30s 太短 — minimax M3 单次 LLM 约 10s, pivot 默认 moderate profile 30 iter
             //   留 ~300s. 之前 30s 自动 abort 时, 一次"你好"调用就被截断, 用户看到 ❌ 循环异常 + 空内容.
@@ -5166,56 +5191,38 @@ fetchState();
                 const judgmentHint = await buildJudgmentHint(channelForJudgment, channelId);
                 if (judgmentHint)
                     contextHint += judgmentHint;
-                // 2026-06-10: 注入 skills 列表 (本机 ~/.bolloon/skills/ 下所有 skills)
-                // 让 LLM 知道有哪些 skill 可用, 在回复中提示用户
+                // 2026-06-10: 注入 skills 存在性提示 (2026-10-16 按需化: 删逐条列表 —
+                //   pi-sdk buildSkillsIndex 已注入前 40 技能名+描述, 这里只保留存在提示与触发语法)
                 try {
-                    const { loadSkillsFromPaths, defaultSkillPaths, describeSkill } = await import('../agents/skill-loader.js');
+                    const { loadSkillsFromPaths, defaultSkillPaths } = 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 += `[系统上下文] 本机已加载 ${skills.length} 个 skills (技能名+描述见上方技能库索引; 需要详情时用 list_skills / read_skill 按需读取). 调用语法: 用户说 "/技能名 ..." 或 你回复时建议 "/技能名 ..." 让用户主动触发.\n\n`;
                     }
                 }
                 catch (err) {
                     // 静默失败 — skills 不是核心, 加载失败不阻塞
                 }
-                // 2026-06-10: 注入 human values 摘要 (最常用的 judgment / 价值偏好)
-                // 与 judgment 不同: values 是更宏观的"用户偏好", judgment 是针对具体决策的约束
+                // 2026-06-10: human values 存在性提示 (2026-10-16 按需化: 删 8 条摘要列表 —
+                //   buildJudgmentHint 已注入绑定判断力 + 候选, 这里只保留"库里有多少"的指针)
                 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 += `[系统上下文] 判断力库存 ${allJudgments.length} 条历史 judgment (绑定判断力见上方; 需要更多时用读取判断力的工具按需取, 软参考体现而非复述).\n\n`;
                     }
                 }
                 catch (err) {
                     // 静默失败
                 }
-                // 2026-06-10: 注入 documents 列表 (本机 documents/ 目录的文档元数据)
-                // 让 LLM 知道有文档存在, 用户可主动要求读
+                // 2026-06-10: documents 存在性提示 (2026-10-16 按需化: 删逐条元数据 —
+                //   只留计数, 用户提到某文档时用读文档工具按需读取)
                 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 += `[系统上下文] 本机 documents ${docs.length} 篇 (用户提到某文档时, 用读文档工具按需读取并总结).\n\n`;
                     }
                 }
                 catch (err) {
@@ -5281,8 +5288,10 @@ fetchState();
                             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`;
+                            // 2026-10-16 按需化: 历史记忆只注尾部 800 chars 作为"上次做到哪"的锚,
+                            //   完整摘要按需用 read 工具取 (记忆是引用而非复述, 全量 2500 常驻浪费)
+                            const memBlock = summariesToRead.map(s => s.trim().slice(-800)).join('\n\n---\n\n');
+                            contextHint += `[系统上下文] 动态状态层 · chat-worksite (上次做到哪 — 本 channel 历史记忆尾部摘录, 来自 memory-compressor 摘要, 引用而非复述):\n${memBlock.slice(-800)}\n\n`;
                         }
                         else {
                             // 2026-08-08 (DID 目录读侧): 磁盘无摘要时, 回退读 DID 目录 memory 表 (跨设备同步来的记忆)
@@ -5293,11 +5302,11 @@ fetchState();
                                     const rows = catalogMemoryRows(cat, agentId);
                                     if (rows.length > 0) {
                                         const memBlock = rows.slice(0, 2)
-                                            .map(({ row }) => String(row.data.summary || '').slice(-1500))
+                                            .map(({ row }) => String(row.data.summary || '').slice(-800))
                                             .filter(Boolean)
                                             .join('\n\n---\n\n');
                                         if (memBlock) {
-                                            contextHint += `[系统上下文] 动态状态层 · chat-worksite (DID 目录同步记忆, 引用而非复述):\n${memBlock.slice(-2500)}\n\n`;
+                                            contextHint += `[系统上下文] 动态状态层 · chat-worksite (DID 目录同步记忆尾部摘录, 引用而非复述):\n${memBlock.slice(-800)}\n\n`;
                                         }
                                     }
                                 }
@@ -5338,24 +5347,27 @@ fetchState();
                 }
                 const linkedIds = channelForJudgment?.linkedDocumentIds;
                 if (Array.isArray(linkedIds) && linkedIds.length > 0) {
+                    // 2026-10-16 按需化: 关联文档不再每轮全文注入 (10篇×1.5KB=15KB 常驻 prompt),
+                    //   只列文件名指针, 用户提到某文档时用读文档工具按需读取。
+                    //   关联文档本身不常在单轮对话中被用到, 全量注入是浪费。
                     try {
                         const { documentStore } = await import('../documents/store.js');
-                        contextHint += `[系统上下文] 此 channel 关联了 ${linkedIds.length} 篇文档 (已自动加载内容, 你应基于它们回答):\n`;
-                        let loaded = 0;
+                        const names = [];
                         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++;
+                            names.push(name);
+                            if (names.length >= 5)
+                                break; // 指针只列前 5, 其余计数
                         }
-                        if (loaded === 0) {
-                            contextHint += `(但加载失败, 文档可能已被删除)\n\n`;
+                        if (names.length > 0) {
+                            const more = linkedIds.length > names.length ? ` (共 ${linkedIds.length} 篇)` : '';
+                            contextHint += `[系统上下文] 此 channel 关联了 ${linkedIds.length} 篇文档 — ${names.join('、')}${more}. 用户提到某篇时, 用读文档工具按需读取全文再回答.\n\n`;
                         }
                         else {
-                            contextHint += '\n';
+                            contextHint += `[系统上下文] 此 channel 关联了 ${linkedIds.length} 篇文档 (内容读取失败, 用读文档工具按需读取).\n\n`;
                         }
                     }
                     catch (err) {
@@ -6901,6 +6913,7 @@ fetchState();
                         output: event.output,
                         error: event.error,
                         args: event.args,
+                        durationMs: event.durationMs, // 2026-10-12: 命令执行时间读秒
                     }, channelId);
                 }
                 else if (event.type === 'error') {

package/dist/ios/style.css

@@ -126,13 +126,20 @@ body {
   flex-shrink: 0;
   transition: var(--transition);
   transform: translateX(0);
-  position: relative;
+  /* 2026-10-06: 改为 fixed 覆盖 — sidebar 收起时绝对定位脱离流, relative 会被挤成 0 宽,
+      恢复条必须固定在屏幕左侧才能被看到/点到 */
+  position: fixed;
+  left: 0;
+  top: 0;
+  height: 100%;
   z-index: 99;
 }
 
 .sidebar-collapsed.hidden {
   transform: translateX(calc(-1 * var(--sidebar-collapsed)));
-  position: absolute;
+  position: fixed;
+  left: 0;
+  top: 0;
   height: 100%;
 }
 
@@ -1876,18 +1883,19 @@ body {
   flex-shrink: 0;
 }
 .header-tab {
-  padding: 5px 14px;
+  padding: 7px 22px;
   background: transparent;
   border: none;
   border-radius: 6px;
   color: var(--text-secondary);
-  font-size: 12px;
+  font-size: 13px;
   font-weight: 600;
   cursor: pointer;
   transition: var(--transition);
   display: flex;
   align-items: center;
-  gap: 4px;
+  gap: 5px;
+  white-space: nowrap;
 }
 .header-tab:hover {
   color: var(--text-primary);

package/dist/ios/sw.js

@@ -6,7 +6,7 @@
  * 现在: 代码类资源 (html/js/css/json) 一律 **network-first** (拿不到网才回退缓存),
  *   缓存名带版本号, activate 时清掉所有旧缓存; 图标等静态资源仍 cache-first。
  */
-const CACHE = 'bolloon-mobile-v0.6.5';
+const CACHE = 'bolloon-mobile-v0.6.6';
 const SHELL = [
   './mobile.html',
   './mobile.css',

package/dist/ios/ui/message-renderer.js

@@ -261,21 +261,10 @@ function segmentChatReply(reply, ctx) {
   if (remaining.trim()) {
     remaining = filterFillerText(remaining);
   }
-  const finalIdx = remaining.indexOf("<final gen>");
-  let beforeFinalText = remaining;
-  if (finalIdx >= 0) {
-    beforeFinalText = remaining.substring(0, finalIdx);
-  }
-  const textContent = beforeFinalText.trim();
+  const textContent = remaining.trim();
   if (textContent) {
     segments.push({ type: "text", content: textContent });
   }
-  if (finalIdx >= 0) {
-    const afterFinal = remaining.substring(finalIdx + "<final gen>".length).trim();
-    if (afterFinal) {
-      segments.push({ type: "final", content: afterFinal });
-    }
-  }
   return segments;
 }
 function extractAndPush(type, text, out, re) {
@@ -530,11 +519,7 @@ function addMessage(content, type, save = true, container, usedJudgmentIds = [],
   div.className = `message message-${type}`;
   let cleanContent = content;
   if (type === "ai") {
-    cleanContent = cleanContent.replace(/<think>[\s\S]*?<\/think>/g, "");
-    const finalGenIdx = cleanContent.indexOf("<final gen>");
-    if (finalGenIdx >= 0) {
-      cleanContent = cleanContent.substring(0, finalGenIdx).trim();
-    }
+    cleanContent = cleanContent.replace(/ thinking[\s\S]*?<\/think>/g, "");
   }
   const knownToolNames = ctx && ctx.knownToolNames || /* @__PURE__ */ new Set();
   const segments = segmentChatReply(cleanContent, { knownToolNames });
@@ -858,7 +843,8 @@ function handleStepEvent(data, ctx = { messagesEl: null, messagesContainers: /*
     args: data.args,
     success: data.success,
     output: data.output,
-    error: data.error
+    error: data.error,
+    durationMs: data.durationMs
   });
 }
 function flushStepEventBuffer(channelId, ctx) {

package/dist/ios/ui/step-timeline.js

@@ -1,6 +1,15 @@
 // src/web/ui/step-timeline.ts
 var MAX_VISIBLE_NODES = 20;
 var STORAGE_PREFIX = "bolloon.stepTimeline.expanded.";
+function formatDuration(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return "(耗时未知)";
+  if (ms < 1e3) return `${ms}ms`;
+  const s = ms / 1e3;
+  if (s < 60) return `${s.toFixed(1)}s`;
+  const m = Math.floor(s / 60);
+  const rem = Math.round(s % 60);
+  return `${m}m${rem}s`;
+}
 var stateMap = /* @__PURE__ */ new WeakMap();
 function readExpanded(channelId) {
   if (!channelId) return false;
@@ -121,7 +130,10 @@ function render(timelineEl) {
       }
       node.setAttribute("data-status", step.status);
       const label = node.querySelector(".step-timeline-label");
-      if (label) label.textContent = step.name;
+      if (label) {
+        const dur = step.durationMs !== void 0 && step.status !== "active" ? ` · ${formatDuration(step.durationMs)}` : "";
+        label.textContent = step.name + dur;
+      }
       const argsEl = node.querySelector(".step-timeline-args");
       if (argsEl) {
         const argStr = step.args && Object.keys(step.args).length > 0 ? JSON.stringify(step.args).slice(0, 60) : "";
@@ -265,6 +277,7 @@ function pushStepToTimeline(timelineEl, eventType, data) {
       steps[targetIdx].status = data.success === false ? "error" : "done";
       if (data.output) steps[targetIdx].output = data.output;
       if (data.error) steps[targetIdx].error = data.error;
+      if (data.durationMs !== void 0) steps[targetIdx].durationMs = data.durationMs;
     } else {
       steps[targetIdx].status = "error";
       if (data.error) steps[targetIdx].error = data.error;

package/dist/kernel/channel-actor.js

@@ -23,6 +23,17 @@ import { AsyncLocalStorage } from 'node:async_hooks';
  * ⇒ 用 ALS 记住"我在谁的上下文里", 同 actor 重入时**直跑**, 不同 actor 照常排队。
  */
 const actorCtx = new AsyncLocalStorage();
+/**
+ * 2026-10-13: 当前 mailbox 任务被注入的**取消信号**。
+ * `deliverThroughActor` 进入执行时调 `actor.beginCancellation()` 并把 signal 注入本 ALS,
+ * 业务侧 (CLI/Web) 在 run() 里经 `currentRequestSignal()` 取它传给模型/循环调用 ⇒
+ * Ctrl+C / 终止按钮走 `actor.abort()` / `abortActorsOfChannel()` 能真正打断回合。
+ * 零业务依赖: 只用 node:async_hooks, 不 import 任何业务模块。
+ */
+const requestSignalCtx = new AsyncLocalStorage();
+export function currentRequestSignal() {
+    return requestSignalCtx.getStore() ?? undefined;
+}
 /** 当前是否正跑在某个 Actor 的 mailbox 任务内 (诊断用) */
 export function currentActorContext() {
     return actorCtx.getStore();
@@ -245,6 +256,18 @@ export function resetActors() {
     channelQueues.clear();
     privateActorsCreated = 0;
 }
+/**
+ * 2026-10-13: 在 mailbox 任务体内开新的取消位并把 signal 注入 ALS (见 deliverThroughActor)。
+ * 收尾时**只有本任务仍是取消位主人**才清掉 —— 嵌套/并行路径下防 abort 打到下一个任务。
+ */
+function runWithCancellation(actor, run) {
+    const ac = new AbortController();
+    actor.state.cancellation = ac;
+    return requestSignalCtx.run(ac.signal, () => Promise.resolve(run()).finally(() => {
+        if (actor.state.cancellation === ac)
+            actor.state.cancellation = null;
+    }));
+}
 export async function deliverThroughActor(
 // 形参故意放宽成 `unknown`: 调用点的 receiver 类型五花八门 (AgentSession / 结构子集 / any),
 //   写成 `{ actor?: ChannelActor }` 会触发 TS 的弱类型检查 ("no properties in common") 而误报。
@@ -264,10 +287,15 @@ holder, run, opts = {}) {
             const q = getChannelQueue(ch);
             if (channelCtx.getStore() === q)
                 return run();
-            return q.submit(() => channelCtx.run(q, () => actor.submit(() => actorCtx.run(actor, () => run()))));
+            return q.submit(() => channelCtx.run(q, () => actor.submit(() => actorCtx.run(actor, () => runWithCancellation(actor, run)))));
         }
     }
-    return actor.submit(run);
+    // 2026-10-13 (leo: 「Ctrl+C 中断的落点必须是 kernel 的取消通道」):
+    //   mailbox 任务体内开一个新的取消位 (state.cancellation) 并把 signal 注入 ALS ——
+    //   业务侧 run() 经 `currentRequestSignal()` 取到它 ⇒ Ctrl+C abort 能打断回合。
+    //   **重入保护里直跑的分支不重新开位**: 嵌套的 inner run 复用同一个外层的 signal,
+    //   不会被内层 abort 清掉 (abort() 把 state.cancellation 置 null, 而 signal 经 ALS 走闭包引用)。
+    return actor.submit(() => actorCtx.run(actor, () => runWithCancellation(actor, run)));
 }
 // ─────────────────────────────────────────────────────────────────────────────
 // channel 级串行锁 (K5 步骤⑤) —— **能力先落地, 默认不启用**

package/dist/kernel/gate-scan.js

@@ -108,7 +108,7 @@ export function scanProhibition(files, p) {
     const out = [];
     const targets = p.targets ?? [];
     const calls = p.writeCalls ?? [];
-    const callRe = calls.length ? new RegExp(`\\b(${calls.join('|')})\\s*\\(`) : null;
+    const callRe = calls.length ? new RegExp(`(?<![\\w.])(?<!async\\s)(${calls.join('|')})\\s*\\(`) : null;
     for (const f of files) {
         if (p.mode === 'import-edge') {
             for (const { line, spec } of importSpecifiers(f.text)) {
@@ -238,7 +238,7 @@ export function validateDeletionRecord(rec) {
     return bad;
 }
 /** 第一批删除候选 = 产品码里 **0 入边引用** 且非入口形态 (机械派生, 不手写) */
-const ENTRY_SHAPE_RE = /(index\.ts$|cli-entry\.ts$|electron\.ts$|\.d\.ts$|server\.ts$|main\.ts$|route|command|register|setup|bootstrap|migration|types\.ts$|constants?\.ts$|config)/;
+const ENTRY_SHAPE_RE = /(index\.ts$|cli-entry\.ts$|electron\.ts$|\.d\.ts$|server\.ts$|main\.ts$|daemon\.ts$|route|command|register|setup|bootstrap|migration|types\.ts$|constants?\.ts$|config)/;
 /**
  * **豁免规则 (2026-10-02)**: 冻结面自身的文件 (KERNEL_FILES 成员 —— `kernel/roster.ts` / `kernel/plan*.ts`)
  * **不算删除候选**。它们是台账/名册, 在"0 入边"口径下天然是孤岛, 每加一个台账就会让候选集变一次