@bolloon/bolloon-agent 0.5.4 → 0.5.5

package/dist/index.js

@@ -2,7 +2,9 @@ import { createHyperswarmCommunicator, createTopic, KeyManager, AgentAuthManager
 import { irohTransport } from './network/iroh-transport.js';
 import { getLastAiTiming, getLastAiUsage } from './llm/pi-ai.js';
 import { setHistoryScope } from './cli/input-history.js';
-import { statusSegments, fitSegments, rightAlignPad } from './cli/status-segments.js';
+import { statusSegments, fitSegments, rightAlignPad, dispWidthSafe, statusLineBudget } from './cli/status-segments.js';
+import { renderReasoning } from './cli/reasoning-view.js';
+import { traceLabel } from './cli/trace-line.js';
 import { loadWalletTool } from './agents/wallet-tools.js';
 import { HybridMessenger } from './network/hybrid-messenger.js';
 import * as ed25519 from '@noble/ed25519';
@@ -29,10 +31,83 @@ import { installStartupLogGate, isStartupVerbose, startupLogPath, VERBOSE_ENV, c
 // 2026-09-27: 回复流卫生 — 内部运行日志 (循环推进/运行登记/收尾计数…) 不进对话回复流, 改落日志文件
 import { isInternalRunLog, appendInternalRunLog } from './cli/reply-hygiene.js';
 // 2026-09-27: 启动**前言 / 就绪度报告**闸门 (默认不上屏 → 面板一行 + 显式查询命令; 失败折成面板提示)
-import { noticeLine as noticePreamble, flushStartupNotices, setStartupReadiness, alertsFromSetup, readinessLine, preambleHintLine, startupPreambleVisible, pushStartupAlert, takeStartupPanelNotes, clearBufferedNotices, } from './cli/startup-notice.js';
+import { onlyConnectivityRetest, SETUP_STATUS_CMD, noticeLine as noticePreamble, flushStartupNotices, setStartupReadiness, alertsFromSetup, readinessLine, preambleHintLine, startupPreambleVisible, pushStartupAlert, takeStartupPanelNotes, clearBufferedNotices, } from './cli/startup-notice.js';
 import { clipboardWrite } from './cli/clipboard.js';
 // 启动自动检查更新：后台、节流、检测到新版本自动安装（可被 --no-update / BOLLOON_SKIP_UPDATE 关闭）
 import { createRequire } from 'module';
+export function parseGroupSub(input) {
+    const rest = String(input || '').replace(/^\/group\b/i, '').trim();
+    if (!rest)
+        return { sub: 'list', arg: '' };
+    const sp = rest.indexOf(' ');
+    const head = (sp === -1 ? rest : rest.slice(0, sp)).toLowerCase();
+    const arg = sp === -1 ? '' : rest.slice(sp + 1).trim();
+    const aliases = { ls: 'list', l: 'list', n: 'new', create: 'new', add: 'join', msg: 'send', history: 'log', use_: 'use' };
+    const sub = aliases[head] || head;
+    // 2026-10-01 (用户: 「group 命令无法选中进群, 要可以选中」): 裸序号 ⇒ 直接选中该群
+    //   与 `/channel <序号>` 同一个习惯 ✓ (列表里就带序号)
+    if (/^\d+$/.test(head))
+        return { sub: 'use', arg: head };
+    const known = ['list', 'new', 'join', 'leave', 'use', 'send', 'log', 'members', 'help'];
+    return { sub: known.includes(sub) ? sub : 'help', arg: known.includes(sub) ? arg : rest };
+}
+export const CLI_KNOWN_COMMAND_HEADS = new Set([
+    '/group',
+    '/agent',
+    '/answer',
+    '/approve',
+    '/contacts',
+    '/copy',
+    '/criteria',
+    '/cron',
+    '/dequeue',
+    '/did',
+    '/dq',
+    '/dream',
+    '/email',
+    '/fork',
+    '/goal',
+    '/goals',
+    '/help',
+    '/insight',
+    '/ipfs',
+    '/ipns',
+    '/judgement',
+    '/judgments',
+    '/login',
+    '/logout',
+    '/loop',
+    '/mcp',
+    '/memory',
+    '/model',
+    '/net',
+    '/now',
+    '/p2p',
+    '/pause',
+    '/payments',
+    '/plan',
+    '/q',
+    '/questions',
+    '/queue',
+    '/reject',
+    '/resume',
+    '/runs',
+    '/session',
+    '/sessions',
+    '/setup',
+    '/skill',
+    '/skills',
+    '/suggestions',
+    '/supervise',
+    '/todo',
+    '/tools',
+    '/trace',
+    '/tx',
+    '/wake',
+    '/wallet',
+    '/wiki',
+    '/x402',
+]);
 const _require = createRequire(import.meta.url);
 const _BOLLOON_VERSION = (() => {
     try {
@@ -68,6 +143,75 @@ const MOVE_UP = '\x1b[A';
 const CLEAR_LINE = '\x1b[2K';
 const HIDE_CURSOR = '\x1b[?25l';
 const SHOW_CURSOR = '\x1b[?25h';
+/**
+ * 统一出口 (2026-10-01, 用户: 「还是UI有污染」)。
+ * 为什么: Ink 被显式设成 `patchConsole: false` ⇒ **不接管 console** ✗ ⇒ 运行期任何 `console.log`
+ *   都写在 Ink 托管区**之外** ⇒ 每次直写都把正在渲染的 footer(提示行 + 分界线)往下推一份 ✗
+ *   ⇒ 屏幕上重复出现「· 回车发送 · ↑↓ 历史 · PgUp 回看 · Esc 双击退出」✓(真机实测就是这个)。
+ * 判据复用已有的 `startupPanelReady`(启动面板画好了 = Ink 已在跑 ✓):
+ *   Ink 在跑 ⇒ **一律走它自己的消息流**; 没跑(boot 期)⇒ 才直写 ✓。
+ */
+function writeOut(line) {
+    // 2026-10-01 (用户: 「时间好像是面板后面启动的」+「继续，还没去掉」):
+    //   **关键**: 启动那几步**不是 await 的** ✗(fire-and-forget)⇒ 它们常在 `startupPanelReady = true`
+    //   **之后**才打印 ✓ ⇒ 用"面板好了没"当判据必然漏 ✗(我上一版就栽在这 ✓)。
+    //   改成**独立的启动期标志** `bootPhase` ✓: 启动期内的**进度类**输出一律只落盘 ✓, 与面板状态无关 ✓。
+    if (bootPhase) {
+        bootLogOnly(line);
+        return;
+    }
+    if (startupPanelReady) {
+        try {
+            appendLine(line);
+            return;
+        }
+        catch { /* 落到落盘 */ }
+    }
+    // 2026-10-01 (用户: 「启动那几行……继续，还没去掉」): **启动期的"进度类"输出直接不进屏** ✓
+    //   上一版我把它们**搬进对话流**了 ✗ —— 但用户要的是**去掉** ✓(面板已经把版本/模型/技能这些要点画了 ✓,
+    //   而 `复用 DID` / `iroh:` / `主题:` / `[N/5]` 这类属于**过程细节** ✓)。
+    //   现在: 启动期 ⇒ **只落日志**(~/.bolloon/logs/startup.log ✓ 事后照样能查 ✓), 不上屏 ✓。
+    bootLogOnly(line);
+}
+/**
+ * 启动期**警告/错误**仍然要上屏 ✓ (不许因为"想干净"把问题藏起来 ✗):
+ *   Ink 没起 ⇒ 先缓冲, `flushBootBuffer()` 在 Ink 起来后灌进对话流 ✓; Ink 已在跑 ⇒ 直接进 ✓。
+ */
+function writeOutWarn(line) {
+    if (startupPanelReady) {
+        try {
+            appendLine(line);
+            return;
+        }
+        catch { /* 落到缓冲 */ }
+    }
+    if (bootBuffer.length < 500) {
+        bootBuffer.push(line);
+        return;
+    }
+    console.log(line);
+}
+/** 启动期进度类输出: 只落盘(不上屏 ✓) */
+function bootLogOnly(line) {
+    try {
+        const clean = String(line).replace(/\x1b\[[0-9;]*[A-Za-z]/g, '');
+        fsSync.appendFileSync(startupLogPath(), `[boot] ${clean}\n`);
+    }
+    catch { /* 落盘失败也不上屏(它本来就是过程细节 ✓) */ }
+}
+/** 启动期"警告/错误"缓冲: Ink 起来之前攒着, `flushBootBuffer()` 一次性灌进对话流 ✓ */
+const bootBuffer = [];
+export function flushBootBuffer() {
+    while (bootBuffer.length) {
+        const line = bootBuffer.shift();
+        try {
+            appendLine(line);
+        }
+        catch {
+            console.log(line);
+        }
+    }
+}
 const s = {
     banner: () => {
         printBanner(_BOLLOON_VERSION);
@@ -78,52 +222,48 @@ const s = {
                 status === 'warn' ? `${YELLOW}⚠` :
                     status === 'error' ? `${MAGENTA}✗` :
                         `${CYAN}●`;
-        console.log(`  ${check} ${WHITE}[${num}/${total}]${GRAY} ${text}${RESET}`);
+        writeOut(`  ${check} ${WHITE}[${num}/${total}]${GRAY} ${text}${RESET}`);
     },
-    success: (text) => console.log(`  ${GREEN}✓${RESET} ${text}`),
-    warn: (text) => console.log(`  ${YELLOW}⚠${RESET} ${text}`),
-    error: (text) => console.log(`  ${MAGENTA}✗${RESET} ${text}`),
-    info: (text) => console.log(`  ${CYAN}●${RESET} ${text}`),
+    success: (text) => writeOut(`  ${GREEN}✓${RESET} ${text}`),
+    warn: (text) => writeOutWarn(`  ${YELLOW}⚠${RESET} ${text}`),
+    error: (text) => writeOutWarn(`  ${MAGENTA}✗${RESET} ${text}`),
+    info: (text) => writeOut(`  ${CYAN}●${RESET} ${text}`),
     section: (title) => {
-        console.log(`\n${BLUE}━━━ ${WHITE}${BOLD}${title}${RESET} ${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}`);
+        writeOut(`\n${BLUE}━━━ ${WHITE}${BOLD}${title}${RESET} ${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}`);
     },
-    divider: () => console.log(`\n${GRAY}${'─'.repeat(50)}${RESET}\n`),
-    prompt: (text) => console.log(`\n${CYAN}❯ ${WHITE}${text}${RESET}`),
+    divider: () => writeOut(`\n${GRAY}${'─'.repeat(50)}${RESET}\n`),
+    prompt: (text) => writeOut(`\n${CYAN}❯ ${WHITE}${text}${RESET}`),
     response: (label, content) => {
-        console.log(`\n${GREEN}${label}${RESET}\n${content}\n`);
+        writeOut(`\n${GREEN}${label}${RESET}\n${content}\n`);
     },
     agentCard: (agent) => {
         const statusColor = agent.status === 'active' ? GREEN :
             agent.status === 'idle' ? YELLOW :
                 agent.status === 'busy' ? MAGENTA : GRAY;
-        console.log(`  ${WHITE}${BOLD}${agent.name}${RESET}`);
-        console.log(`    ${GRAY}ID:${RESET} ${agent.id}`);
-        console.log(`    ${GRAY}状态:${RESET} ${statusColor}${agent.status}${RESET}`);
-        console.log(`    ${GRAY}能力:${RESET} ${agent.capabilities.join(', ')}`);
+        writeOut(`  ${WHITE}${BOLD}${agent.name}${RESET}`);
+        writeOut(`    ${GRAY}ID:${RESET} ${agent.id}`);
+        writeOut(`    ${GRAY}状态:${RESET} ${statusColor}${agent.status}${RESET}`);
+        writeOut(`    ${GRAY}能力:${RESET} ${agent.capabilities.join(', ')}`);
         if (agent.did)
-            console.log(`    ${GRAY}DID:${RESET} ${agent.did}`);
-        console.log();
+            writeOut(`    ${GRAY}DID:${RESET} ${agent.did}`);
+        writeOut('');
     },
     Thinking: () => {
-        const frames = ['(｀・ω・´)', '(´･_･`)', '(｡•́︿•̀｡)', 'ᕙ(▀̿̿Ĺ̯̿̿▀̿ ̿)ᕗ', '(◕‿◕)'];
-        let i = 0;
-        let dots = 0;
-        const frame = frames[0];
-        appendLine(`  ${frame} 思考...`);
-        return setInterval(() => {
-            i = (i + 1) % frames.length;
-            dots = (dots + 1) % 4;
-            const dotStr = '.'.repeat(dots || 1);
-            appendLine(`\r  ${frames[i]} 思考${dotStr}   `);
-        }, 600);
+        // 2026-10-01 (用户: 「颜文字被加载进去了」/「可能是 ink 渲染的问题」): **真凶在这里** ✗ ——
+        //   原来每一帧都走 `appendLine` ⇒ 而对话流是 Ink 的 `<Static>`(**写一次永不重绘** ✓)
+        //   ⇒ 于是每 600ms 就有一条「思考中...」被**永久烙进滚动区** ✗, 带 `\r` 也擦不掉 ✗,
+        //   滚出来的残影还能被框选/拖进输入框 ⇒ 混进上下文 ✓。
+        //   现在改成走 **Ink 的瞬时行**(footer 自己帧进动画 ✓, 只重绘一行 ✓, 不落进 Static ✓)。
+        inkSetThinking(true);
+        return setInterval(() => { }, 600);
     },
     clearThinking: (interval) => {
         clearInterval(interval);
-        process.stdout.write('\r' + ' '.repeat(40) + '\r');
+        inkSetThinking(false);
     },
     dialog: async (title, promptText) => {
         return new Promise((resolve) => {
-            console.log(renderDialog({ title, prompt: promptText }));
+            writeOut(renderDialog({ title, prompt: promptText }));
             const rl = readline.createInterface({
                 input: process.stdin,
                 output: process.stdout
@@ -149,6 +289,14 @@ ed25519.hashes.sha512 = sha512;
 let startupPanelFirst = false;
 /** 面板第一帧已经画出来了 (startCLI 取走面板提示之后): 晚到的降级提示直接追加进面板 */
 let startupPanelReady = false;
+/**
+ * **启动期**标志 (2026-10-01): 与 `startupPanelReady` **不是一回事** ✗ ——
+ *   启动那几步是 fire-and-forget, 打印时间常在面板之后 ✓ ⇒ 只有用独立标志才拦得住 ✓。
+ * 结束条件: **用户第一次发消息** ✓(他真正接管了)或启动后 **20s 兜底** ✓。
+ */
+let bootPhase = true;
+function endBootPhase() { bootPhase = false; }
+setTimeout(() => { bootPhase = false; }, 20_000).unref?.();
 /**
  * 2026-09-30: 启动面板 / 就绪行**各只许追加一次**.
  *   防任何重入路径 (会话切换 / 重复 boot / 恢复) 把面板再叠一条 —— leo 报的「顶框重复 14 次」那一类
@@ -235,8 +383,8 @@ async function bootstrapIdentity() {
     const username = getUserName();
     const suffix = did.split(':').pop()?.substring(0, 4);
     const name = `blln-${username}-${suffix}`;
-    console.log(`     ${reused ? GRAY + '复用 ' : ''}${GRAY}DID:${RESET} ${did}`);
-    console.log(`     ${GRAY}名称:${RESET} ${name}`);
+    writeOut(`     ${reused ? GRAY + '复用 ' : ''}${GRAY}DID:${RESET} ${did}`);
+    writeOut(`     ${GRAY}名称:${RESET} ${name}`);
     s.step(1, 5, reused ? '复用 DIAP 身份' : '生成 DIAP 身份', 'ok');
     return { keypair: kp, did, name };
 }
@@ -297,7 +445,7 @@ async function bootstrapP2P(verifier) {
     await comm.start();
     const topic = createTopic('bolloon-agent-harness');
     await comm.joinTopic(topic);
-    console.log(`     ${GRAY}主题:${RESET} ${topic.slice(0, 8).toString('hex')}...`);
+    writeOut(`     ${GRAY}主题:${RESET} ${topic.slice(0, 8).toString('hex')}...`);
     s.step(3, 5, '启动 P2P 网络', 'ok');
     return comm;
 }
@@ -315,20 +463,20 @@ async function bootstrapIroh(keypair, name) {
     s.step(4, 5, '启动 iroh P2P', 'loading');
     try {
         const node = await irohTransport.start();
-        console.log(`     ${GRAY}iroh:${RESET} ${node.nodeId.substring(0, 16)}...`);
+        writeOut(`     ${GRAY}iroh:${RESET} ${node.nodeId.substring(0, 16)}...`);
         hybridMessenger = new HybridMessenger({
             preferIrohForLarge: true,
             largeThresholdBytes: 64 * 1024,
             enableRelay: true,
         });
         hybridMessenger.onMessage('task', async (msg) => {
-            console.log(`[iroh] Task from ${msg.from.substring(0, 12)}...: ${new TextDecoder().decode(msg.payload).substring(0, 50)}...`);
+            writeOut(`[iroh] Task from ${msg.from.substring(0, 12)}...: ${new TextDecoder().decode(msg.payload).substring(0, 50)}...`);
         });
         hybridMessenger.onMessage('blob', async (msg) => {
-            console.log(`[iroh] Blob from ${msg.from.substring(0, 12)}...: ${msg.payload.length} bytes`);
+            writeOut(`[iroh] Blob from ${msg.from.substring(0, 12)}...: ${msg.payload.length} bytes`);
         });
         hybridMessenger.onMessage('response', async (msg) => {
-            console.log(`[iroh] Response from ${msg.from.substring(0, 12)}...`);
+            writeOut(`[iroh] Response from ${msg.from.substring(0, 12)}...`);
         });
         if (agentIdentity) {
             agentIdentity.irohNodeId = node.nodeId;
@@ -337,13 +485,15 @@ async function bootstrapIroh(keypair, name) {
     }
     catch (e) {
         s.step(4, 5, '启动 iroh P2P', 'warn');
-        console.log(`     ${YELLOW}iroh 启动失败: ${e.message}${RESET}`);
-        console.log(`     ${GRAY}继续使用 Hyperswarm P2P${RESET}`);
+        writeOut(`     ${YELLOW}iroh 启动失败: ${e.message}${RESET}`);
+        writeOut(`     ${GRAY}继续使用 Hyperswarm P2P${RESET}`);
     }
 }
 // ---------------------------------------------------------------------------
 // Agent 懒加载
 // ---------------------------------------------------------------------------
+// 2026-10-01: /group 的"当前群"(进程内; 重启后需重新 /group use)
+let currentGroupId;
 let agent = null;
 /**
  * 退出存档 (2026-09-30, leo: 「按 ctrl+c / esc 退出的时候, 自动存档 session 进程, 最后显示再见👋」)
@@ -488,15 +638,34 @@ async function getAgent() {
         catch { /* 读不到就退默认 */ }
     }
     let identityDoc;
-    if (chIdentity?.did && chIdentity.publicKey) {
-        // channel 已有持久 DID → 用 channel 身份
+    // 2026-10-01 (用户实测: 两个不同 channel 都答同一个名字, get_identity 的 DID 为空):
+    //   旧逻辑要求 channel 记录**同时**有 did + publicKey, 否则落到 `agentIdentity`(进程级**共享**) ⇒
+    //   多个 channel 共用一个身份 ✗; 且 channel 里可能存着假 DID (did:local:…) 或干脆没有 did。
+    //   现在: 归属以 channel 的 agentId 为准 —— 现取现造**该 agent 的**真 did:key, 名字用**它自己的** persona。
+    const { channelIdentityUsable, nameForChannel } = await import('./agents/channel-identity.js');
+    let perAgentIdentity;
+    if (chIdentity?.agentId) {
+        try {
+            const { loadOrCreateAgentIdentity } = await import('./agents/agent-identity.js');
+            const mine = loadOrCreateAgentIdentity(chIdentity.agentId);
+            if (mine?.did)
+                perAgentIdentity = { did: mine.did, publicKey: mine.publicKey, name: nameForChannel(chIdentity, chIdentity.agentId) };
+        }
+        catch { /* 退回落 */ }
+    }
+    if (channelIdentityUsable(chIdentity)) {
+        // channel 自带**可用**的持久 DID (真 did:key) → 用它, 名字仍按该 agent 取 (不再用共享名)
         identityDoc = {
             did: chIdentity.did,
-            name: chIdentity.persona?.name || chIdentity.name || 'agent',
+            name: nameForChannel(chIdentity, chIdentity.agentId),
             publicKey: chIdentity.publicKey,
             createdAt: Date.now(),
         };
     }
+    else if (perAgentIdentity) {
+        // channel 缺身份 / 只有假 DID ⇒ 用**该 agent 自己的**真身份 (按 agentId 落盘密钥, 稳定)
+        identityDoc = { ...perAgentIdentity, createdAt: Date.now() };
+    }
     else if (agentIdentity) {
         identityDoc = {
             did: agentIdentity.did,
@@ -512,15 +681,60 @@ async function getAgent() {
     else {
         identityDoc = undefined;
     }
+    // 2026-10-01: **身份取值自证** —— 只在"可疑"时打一行事实 (不是刷屏):
+    //   缺 did / 假 did / channel 有 agentId 却没被用上 ⇒ 打出来, 免得靠猜。
+    //   用户实测过 DID 为空、名字串台、以及一个数据里根本不存在的 did ⇒ 这行能直接指认哪条分支被走了。
+    try {
+        const d = String(identityDoc?.did ?? '');
+        const suspicious = !d || /^did:(local|pi):/i.test(d) || (!chIdentity?.agentId && !!targetChannelId);
+        if (suspicious) {
+            console.warn(`[identity] 身份可疑: channel=${targetChannelId ?? '(无)'} · channel.agentId=${chIdentity?.agentId ?? '(无)'} · ` +
+                `分支=${channelIdentityUsable(chIdentity) ? 'channel 自带' : perAgentIdentity ? 'per-agent' : agentIdentity ? '**共享 agentIdentity**' : '默认'} · ` +
+                `did=${d ? d.slice(0, 30) : '(空)'} · name=${String(identityDoc?.name ?? '(空)')}`);
+        }
+    }
+    catch { /* 自证失败不影响主流程 */ }
+    // 2026-10-01: 把当前 agent 告诉进程 —— 项目上下文(context-collector)据此取**该 agent 的** persona,
+    //   否则它会读全局 persona.json, 于是 get_identity 已是「小龙」而上下文里还写着「小宝」✗。
+    if (chIdentity?.agentId)
+        process.env.BOLLOON_ACTIVE_AGENT_ID = chIdentity.agentId;
+    // 2026-10-01: **身份取值一行事实** —— 每次**建/切 agent** 打一行(不是每回合, 不刷屏)。
+    //   用户报「xiaomi 频道却拿到 233 的 DID + 小龙」而可疑判据没触发 ⇒ 猜不动了, 让代码直说。
+    try {
+        console.warn(`[identity] channel=${targetChannelId ?? '(无)'} · 查到=${chIdentity ? 'yes' : '**no**'} · ` +
+            `channel.agentId=${chIdentity?.agentId ?? '(无)'} · channel.did=${String(chIdentity?.did ?? '(无)').slice(0, 26)} · ` +
+            `分支=${channelIdentityUsable(chIdentity) ? 'channel自带' : perAgentIdentity ? 'per-agent' : agentIdentity ? '**共享' : '默认'} · ` +
+            `结果 did=${String(identityDoc?.did ?? '(空)').slice(0, 26)} name=${String(identityDoc?.name ?? '(空)')}`);
+    }
+    catch { /* 自证失败不影响主流程 */ }
     const loadSessionKey = targetChannelId
         ? `${targetChannelId}:${chIdentity?.currentSessionId || 'default'}`
         : undefined;
+    // 2026-10-01: 确保该 agent 名下有身份文档 (此前仓里没有任何"建文档"的路径 ⇒
+    //   用户四个 agent 的 persona/<agentId>/ 全空 ⇒ loadPersonaDocs 读回空 ⇒ 所有智能体一个样)。
+    //   挂在这里 = 建 agent / 切 channel 两条路都会走到; 幂等, 已存在的不覆盖。
+    if (chIdentity?.agentId) {
+        try {
+            const { ensurePersonaDocs } = await import('./bootstrap/persona-init.js');
+            // 2026-10-01: 名字必须和该 agent 的 persona.json 一致 —— 之前传的是**渠道名**,
+            //   于是 soul.md 写「我是 233」而 persona.json 写「小龙」⇒ 用户看到"身份没匹配上" ✗。
+            const r = await ensurePersonaDocs(chIdentity.agentId, { name: nameForChannel(chIdentity, chIdentity.agentId) });
+            if (r.created.length)
+                console.warn(`[persona] 已为 ${r.agentId} 生成 ${r.created.length} 份起步身份文档: ${r.created.join(' · ')} → ${r.dir}`);
+        }
+        catch { /* 非致命 */ }
+    }
     agent = await createAgentSession({
         cwd: process.cwd(),
         peerId: targetChannelId ?? 'harness',
-        identityDoc,
         // 2026-08-09: 透传 channel.agentId → persona docs 按 agent 加载 (身份真正变化)
         agentId: chIdentity?.agentId || (targetChannelId ? undefined : agentIdentity?.name),
+        // 2026-10-01 ★ **必须传 identityDoc** —— 之前漏了 ✗, 后果有两层:
+        //   ① 上面按频道算好的身份(名字 + 该 agent 自己的 did)被**丢掉**, session 用自己造/复用的;
+        //   ② session 工厂的更新路径 (pi-sdk-session-factory.updateIdentity) 以 `config.identityDoc?.did`
+        //      为条件 ⇒ 缺它 **永不触发** ⇒ 切频道时复用同一个 session 实例, 身份却**不换** ✗✗
+        //   (实测: 233→智能体 后答 233 的身份; 智能体→233 后答 智能体的身份 = 身份"差一格" ✓ 根因在此)
+        identityDoc,
         loadSessionKey,
     });
     agentBoundChannelId = targetChannelId;
@@ -548,7 +762,7 @@ async function dispatchTask(raw) {
     const task = safeParse(body);
     if (!task)
         return `ERR|${JSON.stringify({ code: 'bad_format' })}`;
-    console.log(`\n📥 [${task.type}]  from=${task.from?.substring(0, 18)}...  id=${task.id}`);
+    writeOut(`\n📥 [${task.type}]  from=${task.from?.substring(0, 18)}...  id=${task.id}`);
     try {
         switch (task.type) {
             case 'summarize':
@@ -568,7 +782,7 @@ async function handleSummarize(task) {
         return `ERR|${JSON.stringify({ code: 'no_path' })}`;
     const a = await getAgent();
     const { summary, qualityScore } = await a.summarizeDocument(task.documentPath);
-    console.log(`     ✅ 质量=${(qualityScore * 10).toFixed(1)}/10`);
+    writeOut(`     ✅ 质量=${(qualityScore * 10).toFixed(1)}/10`);
     return `OK|${JSON.stringify({ id: task.id, type: 'summarize', qualityScore, summary })}`;
 }
 async function handleImprove(task) {
@@ -582,7 +796,7 @@ async function handleImprove(task) {
         context: `来自节点: ${task.from}`,
     });
     const ok = res.improved ?? false;
-    console.log(`     ✅ 改进${ok ? '成功' : '失败'}  质量=${(res.qualityScore * 10).toFixed(1)}/10  自动发送=${res.shouldAutoSend}`);
+    writeOut(`     ✅ 改进${ok ? '成功' : '失败'}  质量=${(res.qualityScore * 10).toFixed(1)}/10  自动发送=${res.shouldAutoSend}`);
     return `OK|${JSON.stringify({
         id: task.id, type: 'improve', improved: ok,
         qualityScore: res.qualityScore, shouldAutoSend: res.shouldAutoSend,
@@ -731,7 +945,12 @@ function getStatus() {
         return `${C_DIM}${icon}${RESET} ${color}${val}${RESET}`;
     });
     // 按剩余宽度取舍 (真机 112 列时右段被截 ⇒ 看着像没出现)
-    const __segsFit = fitSegments(__segs.map(x => x.replace(/\x1b\[[0-9;]*m/g, '')), Math.max(20, termWidth() - 2 - __leftPlainLen - 6));
+    // 2026-10-01: 底栏一律用**保守测宽** (Ambiguous 字符按 2 列) —— 超 1 列就会让终端折行、
+    //   进而打破 Ink 光标数学, 表现是整块底栏被重复打印 (见 status-segments.dispWidthSafe 注释)
+    // 2026-10-01: 预算按**保守宽度**给 (left + ≥1 格 + title ≤ width-1) ⇒ 任何字体下都不折行
+    const __notePlain = (cliSessionPreview && cliSessionTitleKey === cliSessionKey) ? `▸ ${cliSessionPreview}` : '';
+    const __budget = statusLineBudget(termWidth(), __leftPlainLen, String(__notePlain || ''));
+    const __segsFit = fitSegments(__segs.map(x => x.replace(/\x1b\[[0-9;]*m/g, '')), __budget, dispWidthSafe);
     const __live = __segsFit.length
         ? ` ${C_DIM}│${RESET} ` + __segsFit.map(x => {
             const m = /^(\S+)\s(.*)$/.exec(x);
@@ -742,13 +961,13 @@ function getStatus() {
         : '';
     // 2026-09-30 (leo: 「这个 title 需要顶格右侧」): 会话 Title **右对齐**贴右边缘 ——
     //   先算左半边+活数据段的显示宽, 再补空格把 `▸ 标题` 推到 width-1 处; 放不下就不显示 (不挤坏这一行)。
-    const __notePlain = (cliSessionPreview && cliSessionTitleKey === cliSessionKey) ? `▸ ${cliSessionPreview}` : '';
     let __noteStr = '';
     if (__notePlain) {
         // 宽度必须用 dispWidth (East Asian Width 表): 行内的 `│ ░ ◷ ▸ ◎ ✓ ↑ ⚙` 都是**单宽**,
         //   用 "charCode > 255 ⇒ 2" 的启发式会每行多算十几列 ⇒ 右对齐留一大截 (leo: 「没有完全右对齐」)。
-        const used = dispWidth(`${__left}${__live}`);
-        const pad = rightAlignPad(used, dispWidth(__notePlain), termWidth());
+        const used = dispWidthSafe(`${__left}${__live}`);
+        // 保守测宽 (同上): 右对齐后整行最多到 width-1, 在任何终端字体下都不会折行
+        const pad = rightAlignPad(used, dispWidthSafe(__notePlain), termWidth());
         if (pad !== null)
             __noteStr = ' '.repeat(pad) + `${C_DIM}${__notePlain}${RESET}`;
     }
@@ -1150,6 +1369,8 @@ async function startCLI(commReady) {
     startupPanelReady = true;
     // 2026-09-30: 面板在起帧前已进 store ⇒ 首帧里与输入框一起出现
     startInk((text) => { processInput(text, comm); }, initialStatus, getStatus);
+    // 2026-10-01: Ink 起来了 ⇒ 把启动期缓冲的日志一次性灌进对话流(不丢, 也不跟面板交错 ✓)
+    flushBootBuffer();
     // 2026-08-10: 自动整理心跳 (CLI 侧, 与社交心跳并列) — 启动后立即"固定看一下 skills view"
     //   (扫描遗留 skills), 之后按周期 (默认 30min, env BOLLOON_ORGANIZE_HEARTBEAT_MS) 完整进化经验.
     //   显示走 transient 颜文字行: 触发时显示, 结束后清空 (显示为空).
@@ -1303,6 +1524,7 @@ async function startCLI(commReady) {
  * scheduler 的每个 tick 会先查 resolveDnd(), 处于勿扰时把 due job 记 deferred 并留到下一轮.
  */
 async function processInput(input, comm) {
+    endBootPhase(); // 用户已接管 ⇒ 启动期结束(之后的输出照常上屏 ✓)
     const gate = globalThis.__bolloonMainTask;
     if (gate?.enterMainTask) {
         try {
@@ -1440,7 +1662,31 @@ async function processInputInner(input, comm) {
             const extra = prev && prev.name !== r.identity.name ? ` (从 ${prev.name} 切换)` : '';
             appendLine(`${C_ACCENT}→ 当前智能体: ${r.identity.name}${RESET}${extra}`);
             appendLine(`${C_DIM}  channel: ${r.channel.id}  [${r.match}]${RESET}`);
-            appendLine(`${C_DIM}  persona: ${r.channel.persona?.description || r.channel.persona?.personality || '无'}${RESET}`);
+            // 2026-10-01 (用户报「切换身份还没有成功」): 把**CLI 认为的身份**打进对话流 —— 之前用 console.warn,
+            //   在这套 TUI 里被吞掉, 用户从来看不到 ✗。切频道才一行, 不刷屏。
+            try {
+                const live = agent?.getIdentity?.() ?? null;
+                appendLine(`${C_DIM}  [identity] 频道身份=${r.identity.name} (did=${String(r.identity?.did ?? '(无)').slice(0, 26)})` +
+                    ` · agent 当前身份=${live?.name ?? '(读不到)'} (did=${String(live?.did ?? '(无)').slice(0, 26)})` +
+                    ` · agentId=${r.channel.agentId ?? '(无)'}${RESET}`);
+            }
+            catch { /* 自证失败不影响切换 */ }
+            // 2026-10-01: 这行原先读 channels.json 里**内联的 metadata** (你四条 channel 都空 ⇒ 恒打"无"),
+            //   而身份真源是 ~/.bolloon/persona/<agentId>/ 的 6 份文档 ⇒ 改读真源, 如实报"加载到几份"。
+            try {
+                const { loadPersonaDocs, PERSONA_DOC_FILES_HINT } = await import('./bootstrap/persona-loader.js').then(async (m) => ({ loadPersonaDocs: m.loadPersonaDocs, PERSONA_DOC_FILES_HINT: ['soul', 'identity', 'project', 'user', 'agent', 'wiki'] }));
+                const agentId = r.channel.agentId || '';
+                const docs = agentId ? await loadPersonaDocs(agentId) : null;
+                const loaded = docs ? PERSONA_DOC_FILES_HINT.filter((k) => String(docs[k] || '').trim().length > 0) : [];
+                appendLine(agentId
+                    ? (loaded.length
+                        ? `${C_DIM}  persona: ${loaded.length}/6 份身份文档 (${loaded.join(' · ')}) · agentId=${agentId}${RESET}`
+                        : `${C_DIM}  persona: 未初始化 (agentId=${agentId}, 目录 ${'~/.bolloon/persona/' + agentId}/ 为空 — 下次加载会自动生成起步模板)${RESET}`)
+                    : `${C_DIM}  persona: 该 channel 没有 agentId ⇒ 无法按 agent 加载身份文档${RESET}`);
+            }
+            catch {
+                appendLine(`${C_DIM}  persona: (读身份文档失败, 不影响本次切换)${RESET}`);
+            }
         }
         catch (e) {
             appendLine(`${C_ERROR}/channel 失败: ${String(e.message || e).slice(0, 200)}${RESET}`);
@@ -1522,7 +1768,7 @@ async function processInputInner(input, comm) {
                     });
                 }
                 await fs.writeFile(agentsPath, JSON.stringify(arr, null, 2), 'utf-8');
-                console.log(`[创建频道] agent 同步进 agents.json: ${agentId} → channel ${id}`);
+                writeOut(`[创建频道] agent 同步进 agents.json: ${agentId} → channel ${id}`);
             }
             catch { /* agents.json 写失败不阻塞创建 */ }
             // 刷新 store 缓存 (updateChannels 走了 server-storage, store 内存还是旧的)
@@ -1619,6 +1865,14 @@ async function processInputInner(input, comm) {
     //   不能全局改成"首词" —— 同文件里 `/email clear` 这类多词命令就是靠整行匹配的。
     //   所以加一个**首词**给"带参数的命令"用 (cmd 保持原样给多词命令用)。
     const cmdHead = cmd.split(/\s+/)[0];
+    // 2026-10-01: **未知命令兜底** —— 以 / 开头但不在白名单里的输入, 不当消息发下去 ✗
+    //   (用户实测: /group 不是命令 ⇒ 却发给模型, 白烧一轮工具调用)
+    if (cmd.startsWith('/') && !CLI_KNOWN_COMMAND_HEADS.has(cmdHead)) {
+        const near = [...CLI_KNOWN_COMMAND_HEADS].filter((h) => h.includes(cmdHead.slice(1)) || cmdHead.includes(h.slice(1))).slice(0, 6);
+        appendLine(`${C_WARN}未知命令 ${cmdHead}${RESET}${C_DIM} —— 输入${RESET} / ${C_DIM}看命令列表, 或 /help 看用法${RESET}`
+            + (near.length ? `${C_DIM} · 你是不是想用: ${near.join(' / ')}${RESET}` : ''));
+        return;
+    }
     // /net — Agent 网络快捷命令 (join/status/ctx, 2026-09-08)
     if (cmd === '/net' || cmd.startsWith('/net ')) {
         const arg = trimmed.slice(4).trim();
@@ -3576,6 +3830,153 @@ async function processInputInner(input, comm) {
         }
         return;
     }
+    // 「当前群」的取用: 没选过时, 只有恰好一个群就自动用它; 否则提示先 /group use
+    const ensureCurrentGroup = async (gg) => {
+        if (currentGroupId)
+            return currentGroupId;
+        const gs = await gg.listGroups();
+        if (gs.length === 1) {
+            currentGroupId = gs[0].id;
+            return currentGroupId;
+        }
+        if (!gs.length) {
+            appendLine(`${C_DIM}本地还没有群 —— 用 /group new <名字> 建一个${RESET}`);
+            return undefined;
+        }
+        appendLine(`${C_DIM}本地有 ${gs.length} 个群, 先 /group use <名字|id> 选一个${RESET}`);
+        return undefined;
+    };
+    // /group — OrbitDB 群聊 (2026-10-01; 接 gateway-group 那套: 建群/加入/收发/成员/日志)
+    if (cmd === '/group' || cmd.startsWith('/group ')) {
+        const { sub, arg } = parseGroupSub(trimmed);
+        const gg = await import('./agents/gateway-group.js');
+        const dim = (t) => appendLine(`${C_DIM}${t}${RESET}`);
+        try {
+            if (sub === 'help') {
+                appendLine(`${C_ACCENT}/group${RESET} —— OrbitDB 群聊`);
+                dim('  /group                    列出本地群');
+                dim('  /group new <名字>          建群 (默认创建者独占写; 会打印可分享地址)');
+                dim('  /group join <链接|地址>     加入');
+                dim('  /group leave <名字|id>     退出');
+                dim('  /group use <名字|id>       选定当前群 (之后 send/log/members 都指它)');
+                dim('  /group send <文本>         往当前群发一条');
+                dim('  /group log [N]             看当前群最近 N 条 (默认 10)');
+                dim('  /group members             列当前群成员');
+                return;
+            }
+            if (sub === 'list') {
+                const gs = await gg.listGroups();
+                if (!gs.length) {
+                    dim('本地还没有群 —— 用 /group new <名字> 建一个');
+                    return;
+                }
+                const rows = [];
+                gs.forEach((g, i) => {
+                    const cur = currentGroupId === g.id ? '●' : '○';
+                    const n = String(i + 1).padStart(2, ' ');
+                    rows.push(`${n}. ${cur} ${g.name}  ${String(g.id).slice(0, 18)}…`);
+                });
+                rows.push('');
+                rows.push('选中进群: /group <序号>   (或 /group use <名字|id>)');
+                appendLine(renderMessageBox({ title: 'OrbitDB 群', body: rows.join('\n'), color: C_ACCENT, maxLines: 24 }));
+                return;
+            }
+            if (sub === 'new') {
+                const r = await gg.createGroup(arg || '');
+                if (!r.ok) {
+                    appendLine(`${C_WARN}建群失败: ${r.error}${RESET}`);
+                    return;
+                }
+                currentGroupId = r.group?.id || currentGroupId;
+                appendLine(renderMessageBox({ title: '✅ 群已建立', body: `名字: ${r.group?.name || arg}\nid: ${r.group?.id || '-'}\n地址: ${r.group?.link || r.group?.address || '(未返回地址)'}\n\n把地址发给同伴, 用 /group join <地址> 加入`, color: C_ACCENT, maxLines: 12 }));
+                return;
+            }
+            if (sub === 'join') {
+                if (!arg) {
+                    dim('用法: /group join <链接|地址>');
+                    return;
+                }
+                const r = await gg.joinGroup(arg);
+                if (!r.ok) {
+                    appendLine(`${C_WARN}加入失败: ${r.error}${RESET}`);
+                    return;
+                }
+                currentGroupId = r.group?.id || currentGroupId;
+                appendLine(`${C_ACCENT}✓ 已加入 ${r.group?.name || arg}${RESET}`);
+                return;
+            }
+            if (sub === 'leave') {
+                if (!arg) {
+                    dim('用法: /group leave <名字|id>');
+                    return;
+                }
+                const r = await gg.leaveGroup(arg);
+                appendLine(r.ok ? `${C_ACCENT}✓ 已退出 ${r.removed || arg}${RESET}` : `${C_WARN}退出失败: ${r.error}${RESET}`);
+                if (r.ok && currentGroupId === arg)
+                    currentGroupId = undefined;
+                return;
+            }
+            if (sub === 'use') {
+                if (!arg) {
+                    dim('用法: /group use <名字|id>');
+                    return;
+                }
+                const gs = await gg.listGroups();
+                // 序号 (与 /group 列表里的编号一致) → 名字 → id → 名字子串
+                let hit = /^\d+$/.test(arg) ? gs[parseInt(arg, 10) - 1] : undefined;
+                if (!hit)
+                    hit = gs.find((g) => g.id === arg || g.name === arg) || gs.find((g) => String(g.name).includes(arg));
+                if (!hit) {
+                    appendLine(`${C_WARN}没找到群: ${arg}${RESET}${C_DIM} —— 先 /group 看编号${RESET}`);
+                    return;
+                }
+                currentGroupId = hit.id;
+                appendLine(`${C_ACCENT}✓ 当前群: ${hit.name} (${String(hit.id).slice(0, 18)}…)${RESET}${C_DIM}  现在可以 /group send <文本> 或 /group log${RESET}`);
+                return;
+            }
+            if (sub === 'send') {
+                if (!arg) {
+                    dim('用法: /group send <文本>');
+                    return;
+                }
+                const gid = await ensureCurrentGroup(gg);
+                if (!gid)
+                    return;
+                const r = await gg.groupSend(gid, arg, String(agentIdentity?.did || 'cli')).catch((e) => ({ ok: false, error: String(e?.message || e) }));
+                appendLine(r.ok === false ? `${C_WARN}发送失败: ${r.error}${RESET}` : `${C_ACCENT}✓ 已发到群${RESET}`);
+                return;
+            }
+            if (sub === 'log') {
+                const gid = await ensureCurrentGroup(gg);
+                if (!gid)
+                    return;
+                const n = Math.max(1, Math.min(100, parseInt(arg || '10', 10) || 10));
+                const msgs = await gg.groupMessages(gid, n);
+                if (!msgs.length) {
+                    dim('这个群还没有消息');
+                    return;
+                }
+                appendLine(renderMessageBox({ title: `群消息 (最近 ${msgs.length})`, body: msgs.map((m) => `${m.from ? String(m.from).slice(0, 10) : '?'}: ${String(m.text || '').slice(0, 200)}`).join('\n'), color: C_ACCENT, maxLines: 24 }));
+                return;
+            }
+            if (sub === 'members') {
+                const gid = await ensureCurrentGroup(gg);
+                if (!gid)
+                    return;
+                const ms = await gg.groupMembers(gid);
+                dim(ms.length ? ms.join('\n') : '(暂无成员记录)');
+                return;
+            }
+            dim('用法: /group help');
+        }
+        catch (e) {
+            // GroupStoreUnreachableError 等: 说清"本地群存储没起来", 不要笼统报错
+            const msg = String(e?.message || e);
+            const unreachable = e?.name === 'GroupStoreUnreachableError' || /unreachable|not open|未就绪/i.test(msg);
+            appendLine(`${C_WARN}${unreachable ? '本地群存储未就绪 —— 需要本机服务/OrbitDB 起来后才行' : '群操作失败'}: ${msg}${RESET}`);
+        }
+        return;
+    }
     if (trimmed.toLowerCase() === '/help' || trimmed === 'help') {
         appendLine(`${C_DIM}命令:${RESET}`);
         appendLine(`  ${C_ACCENT}!<cmd>${RESET}  执行终端命令  ${C_DIM}如 !ls -la${RESET}`);
@@ -3716,6 +4117,18 @@ async function processInputInner(input, comm) {
                 //   (thinking / status / phase / Reflection) 全被丢弃 → 用户只能看到输入和最终输出
                 // 用户偏好 (2026-08-07): 思考过程 = 圆角框渲染 (和回复同路径 renderMessageBox),
                 //   颜文字动画 (inkSetThinking) 只表示"正在运行", 不承载思考内容
+                // 2026-10-01: 思考记录 (模型的思维链) —— 暗色块 + 明确标注"未验证", 与正式回答分开 ✓
+                if (e.type === 'reasoning' && e.content) {
+                    // 2026-10-01 (用户: 「我要的是那种**短的**思考, 长思维链可以不显示」): 默认只显示**一句**"在想什么";
+                    //   想看全链 ⇒ BOLLOON_SHOW_THINKING=full; 不想看 ⇒ =0。
+                    const r = renderReasoning(String(e.content));
+                    if (r.text) {
+                        if (r.mode === 'short')
+                            appendLine(`${C_DIM}💭 ${r.text}${RESET}`);
+                        else
+                            appendLine(renderMessageBox({ title: '💭 思考 (未验证)', body: r.text, color: C_DIM, maxLines: 16 }));
+                    }
+                }
                 if (e.type === 'thinking' && e.content) {
                     // thinking 事件只有 "🤔 开始思考..." 占位 → 不 appendLine, 运行过程由动画表示;
                     //   真正思考内容在 status 的 Reflection/💡 事件 → 下方框渲染
@@ -3742,7 +4155,10 @@ async function processInputInner(input, comm) {
                     // Reflection / 反思 / 💡 → 圆角思考框 (和回复一样走 renderMessageBox, 白字+亮边框)
                     else if (content.includes('Reflection') || content.includes('反思') || content.includes('💡')) {
                         const body = content.replace(/^💡\s*/, '').slice(0, 1500);
-                        if (body.trim())
+                        // 2026-10-01: 只有标记词 (Reflection: / 反思 / 💡) 而无正文 ⇒ **不渲染**, 免得出空框 ✗
+                        const plain = body.replace(/\x1b\[[0-9;]*m/g, '').trim(); // 2026-10-01: 先剥 ANSI —— 只有彩色控制符的正文看着就是**空框** ✗
+                        const onlyMarker = /^(?:reflection|反思)\s*[:：\-—]?\s*$/i.test(plain);
+                        if (plain && !onlyMarker)
                             appendLine(renderMessageBox({ title: '💡 反思', body, color: C_WARN }));
                     }
                     else if (!content.includes('🔄 循环') && !content.includes('📋 参数')
@@ -3763,7 +4179,9 @@ async function processInputInner(input, comm) {
                     //   改用 transient 行显示"正在执行"(消息流只在 done 时出现一次完成行).
                     if (toolName !== 'system' && toolName !== 'loop' && toolName !== '?') {
                         const activeNames = tuiToolCalls.map(c => c.tool).filter(t => t !== 'system' && t !== 'loop' && t !== '?');
-                        const label = activeNames.length > 1 ? `执行 ${activeNames.length} 个工具: ${activeNames.join(', ')}` : `🔧 ${toolName}`;
+                        const label = activeNames.length > 1
+                            ? `执行 ${activeNames.length} 个工具: ${activeNames.join(', ')}`
+                            : `🔧 ${traceLabel(toolName)}`; // trace 执行描述: 写清这一步在做什么
                         inkSetTransient(`${C_DIM}${label} 运行中...${RESET}`);
                     }
                 }
@@ -3793,7 +4211,7 @@ async function processInputInner(input, comm) {
                     const remaining = tuiToolCalls.filter(c => c.tool !== 'system' && c.tool !== 'loop' && c.tool !== '?');
                     cliTurnToolCount = remaining.length; // ⚙ 状态栏用 (模块级)
                     if (remaining.length > 0) {
-                        const label = remaining.length > 1 ? `执行 ${remaining.length} 个工具: ${remaining.map(c => c.tool).join(', ')}` : `🔧 ${remaining[0].tool}`;
+                        const label = remaining.length > 1 ? `执行 ${remaining.length} 个工具: ${remaining.map(c => c.tool).join(', ')}` : `🔧 ${traceLabel(remaining[0].tool)}`; // trace 执行描述
                         inkSetTransient(`${C_DIM}${label} 运行中...${RESET}`);
                     }
                     else {
@@ -4895,18 +5313,18 @@ goalFlag) {
             error,
             metadata
         };
-        console.log(JSON.stringify(result, null, 2));
+        writeOut(JSON.stringify(result, null, 2));
     }
     else {
         if (error) {
             s.divider();
-            console.log(`${MAGENTA}${error}${RESET}\n`);
+            writeOut(`${MAGENTA}${error}${RESET}\n`);
         }
         else {
             s.divider();
-            console.log(`${response}\n`);
+            writeOut(`${response}\n`);
         }
-        console.log(`${GRAY}耗时: ${metadata.duration}ms${RESET}`);
+        writeOut(`${GRAY}耗时: ${metadata.duration}ms${RESET}`);
     }
 }
 async function runNonInteractive(args, comm) {
@@ -4922,11 +5340,11 @@ async function runNonInteractive(args, comm) {
         }
         else if (prompt) {
             const a = await getAgent();
-            console.log(await a.prompt(prompt));
+            writeOut(await a.prompt(prompt));
         }
         console.log = originalLog;
         await fs.writeFile(output, outputBuffer.trim(), 'utf-8');
-        console.log(`✅ 结果已保存到: ${output}`);
+        writeOut(`✅ 结果已保存到: ${output}`);
         return;
     }
     if (tool === 'prompt' && prompt) {
@@ -4938,20 +5356,20 @@ async function runNonInteractive(args, comm) {
             const response = await a.prompt(prompt);
             const elapsed = Date.now() - startTime;
             if (json) {
-                console.log(JSON.stringify({ success: true, response, elapsedMs: elapsed }, null, 2));
+                writeOut(JSON.stringify({ success: true, response, elapsedMs: elapsed }, null, 2));
             }
             else {
-                console.log(response);
-                console.log(`\n耗时: ${elapsed}ms`);
+                writeOut(response);
+                writeOut(`\n耗时: ${elapsed}ms`);
             }
         }
         catch (e) {
             const error = e?.message || String(e);
             if (json) {
-                console.log(JSON.stringify({ success: false, error }, null, 2));
+                writeOut(JSON.stringify({ success: false, error }, null, 2));
             }
             else {
-                console.log(`\n错误: ${error}`);
+                writeOut(`\n错误: ${error}`);
             }
             process.exit(1);
         }
@@ -4979,10 +5397,10 @@ async function runNonInteractive(args, comm) {
                 error: response.startsWith('错误:') ? response : undefined,
                 metadata: { duration, peers }
             };
-            console.log(JSON.stringify(result, null, 2));
+            writeOut(JSON.stringify(result, null, 2));
         }
         else {
-            console.log(response);
+            writeOut(response);
         }
     }
 }
@@ -5300,7 +5718,7 @@ function parseArgs() {
     return result;
 }
 function printHelp() {
-    console.log(`
+    writeOut(`
 🤖 Bolloon Agent - AI 可调用文档处理智能体
 
 用法:
@@ -5528,21 +5946,21 @@ async function main() {
             const res = await runStandaloneSupervisorHost({
                 once: !!args.superviseOnce,
                 dryRun: !!args.superviseDryRun,
-                log: (m) => console.log(m),
+                log: (m) => writeOut(m),
             });
             if (args.superviseOnce) {
                 const rep = res.lastReport;
                 if (rep) {
-                    console.log(`调度周期 #${rep.tick}: 认领 ${rep.claimed.length} · 执行 ${rep.executed.length} · 跳过 ${rep.skipped.length}${rep.errors.length ? ` · 错误 ${rep.errors.length}` : ''}`);
+                    writeOut(`调度周期 #${rep.tick}: 认领 ${rep.claimed.length} · 执行 ${rep.executed.length} · 跳过 ${rep.skipped.length}${rep.errors.length ? ` · 错误 ${rep.errors.length}` : ''}`);
                     for (const s of rep.skipped.slice(0, 8))
-                        console.log(`  跳过 ${s.goalId}: ${s.reason}`);
+                        writeOut(`  跳过 ${s.goalId}: ${s.reason}`);
                     for (const e of rep.executed)
-                        console.log(`  ▶ ${e.goalId} → run=${e.runId || '-'} ${e.status || ''}${e.error ? ` (${e.error})` : ''}`);
+                        writeOut(`  ▶ ${e.goalId} → run=${e.runId || '-'} ${e.status || ''}${e.error ? ` (${e.error})` : ''}`);
                 }
-                console.log(`supervisor 宿主: owner=${res.state.owner} worker=${res.state.workerId} ticks=${res.ticks} 状态文件=~/.bolloon/supervisor.json`);
+                writeOut(`supervisor 宿主: owner=${res.state.owner} worker=${res.state.workerId} ticks=${res.ticks} 状态文件=~/.bolloon/supervisor.json`);
             }
             else {
-                console.log(`[supervisor] 常驻宿主已启动 (owner=${res.state.owner}, worker=${res.state.workerId}); Ctrl-C 优雅停止`);
+                writeOut(`[supervisor] 常驻宿主已启动 (owner=${res.state.owner}, worker=${res.state.workerId}); Ctrl-C 优雅停止`);
             }
             return;
         }
@@ -5593,6 +6011,14 @@ async function main() {
                     if (process.env.BOLLOON_SKIP_SETUP === '1') {
                         noticePreamble('⚠ BOLLOON_SKIP_SETUP=1 → 诊断模式: 可以看状态/修配置, 但 agent 执行被门禁拦住 (不能绕过)');
                     }
+                    else if (onlyConnectivityRetest(gateEv)) {
+                        // 2026-10-01 (用户报「启动时候的日志也没去掉」):
+                        //   只差"连通性结果过期(需重测)"这一类 ⇒ **不在启动时跑 setup 向导** (跑一次要刷约 30 行前言)。
+                        //   改为: 面板内一行告警 + 让用户按需跑 `bolloon setup --test`; 门禁照旧拦住 agent 执行 (不绕过)。
+                        const a = `⚠ 连通性结果过期 → 跑 \`bolloon setup --test\` 复测 (启动时不自动跑), 全量: ${SETUP_STATUS_CMD}`;
+                        pushStartupAlert(a);
+                        noticePreamble(a);
+                    }
                     else {
                         const { runSetupWizard } = await import('./cli/setup-wizard.js');
                         // quietStartup: 向导的续跑前言默认不上屏 (它自己会在"要人回答/有失败"时先 flush)
@@ -5793,7 +6219,7 @@ async function main() {
             // 默认用户模式: 不自迭代, 自改卡片不自动出现, 仍可 POST /api/self-improve/trigger 手动触发
             const selfImprove = process.env.BOLLOON_DEV_MODE === '1' || process.env.BOLLOON_DEV_MODE === 'true';
             if (selfImprove) {
-                console.log('[startup] BOLLOON_DEV_MODE=1, 开发者模式: 自迭代已启用');
+                writeOut('[startup] BOLLOON_DEV_MODE=1, 开发者模式: 自迭代已启用');
             }
             const { createWebServer, openBrowser } = await import('./web/server.js');
             // 2026-06-24: CLI 默认 loopback bind (安全), LAN 访问需 BOLLOON_HOST=0.0.0.0
@@ -5808,7 +6234,7 @@ async function main() {
             console.info = originalInfo;
             process.stdout.write = originalStdoutWrite;
             s.info('执行命令...');
-            console.log();
+            writeOut('');
             await runNonInteractive(args, comm);
             comm?.stop();
             // chat-watch / chat-p2p-listen 是长循环, 不会自然 return, 走 SIGINT 自然退出