@bolloon/bolloon-agent 0.4.33 → 0.5.1

package/dist/index.js

@@ -16,7 +16,14 @@ import { getGlobalSharedContext } from './social/global-shared-context.js';
 import { createBollharnessIntegration } from './bollharness-integration/index.js';
 import * as readline from 'readline';
 import { printBanner, renderDialog, renderUserMessage, renderAgentMessage, renderMessageBox, renderToolCallListItem, termWidth, ROBOT_HEAD, BOLLOON_BANNER, dispWidth } from './cli/loading-tui.js';
-import { startInk, stopInk, inkAppendLine as appendLine, inkReplaceMatchingLine, inkSetStatus, inkSetThinking, inkSetTransient } from './cli/ink-app.js';
+import { startInk, stopInk, suspendInk, resumeInk, inkAppendLine as appendLine, inkReplaceMatchingLine, inkSetStatus, inkSetThinking, inkSetTransient } from './cli/ink-app.js';
+// 2026-09-26: 启动期日志闸门 (默认静默加载日志 + 写文件 + verbose 全量回流 + 信号行不吞)
+import { installStartupLogGate, isStartupVerbose, startupLogPath, VERBOSE_ENV, carriesHumanSignal, logStartupLine } from './cli/log-gate.js';
+// 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 { clipboardWrite } from './cli/clipboard.js';
 // 启动自动检查更新：后台、节流、检测到新版本自动安装（可被 --no-update / BOLLOON_SKIP_UPDATE 关闭）
 import { createRequire } from 'module';
 const _require = createRequire(import.meta.url);
@@ -124,6 +131,53 @@ const s = {
 // @ts-ignore - noble/ed25519 v3 requires sha512 to be set
 ed25519.hashes.sha512 = sha512;
 // ---------------------------------------------------------------------------
+// 启动期(面板之前)输出 —— 「面板优先」与「失败不许吞」两条口径的收口 (2026-09-27)
+// ---------------------------------------------------------------------------
+/**
+ * true = 这一程走「面板优先」口径 (交互 CLI 且没开 verbose/前言), 由 `main()` 的交互分支置位。
+ * 为什么需要它: 下面那些 `s.info` / `s.warn` (**面板之前**打的那几条进度/降级) 不能只看
+ * "有没有 ⚠" 决定上不上屏 —— 默认口径要求**面板第一帧之前一行都没有**, 而 leo 的铁律
+ * 又要求错误/降级**必须看得见**。两条同时成立 => 不放 stderr, 折进面板。
+ */
+let startupPanelFirst = false;
+/** 面板第一帧已经画出来了 (startCLI 取走面板提示之后): 晚到的降级提示直接追加进面板 */
+let startupPanelReady = false;
+/**
+ * 启动期(面板之前)一行进度 / 降级输出 —— 交互默认口径下的**唯一出路**。
+ *
+ * leo 口径 (2026-09-27, 两条必须同时成立):
+ *   ① 「打完 `bolloon --cli` 直接就是面板」⇒ 面板第一帧之前**一行都不许上屏** (进度/就绪度/初始化日志都算);
+ *   ② 「错误 / 降级 / 需人介入不许吞」⇒ 它必须**在屏上真能看到**。
+ * 于是这一层把面板之前那些 `s.info` / `s.warn` 分成两种去处:
+ *   · 带人信号的 (失败/降级/超时/不可用/⚠ …, 判据复用 `log-gate.carriesHumanSignal` —— 只有一处) →
+ *     **折进面板告警通道**: 面板还没画就登记 (`pushStartupAlert`, 与 `/!\ ⚠ 未就绪 …` 同一出路),
+ *     面板已经画了就地 `appendLine` 追加一行 (晚到的失败也不许消失在内存里);
+ *   · 不带信号的纯进度 → 不上屏, 只落 `~/.bolloon/logs/startup.log` (诊断不丢)。
+ *
+ * `--verbose` / `BOLLOON_STARTUP_PREAMBLE=1` / 非交互 / web: **逐字照旧** (`s.warn` / `s.info`
+ * 原样打屏, 非交互那几条就是正常输出 —— 那里没有面板接着显示, 折进面板等于吞)。
+ *
+ * @param fallback 老路径的渲染方式 (只有 publishDID 那条 `s.step(…, 'warn')` 与 `s.warn` 不同)
+ */
+function bootNotice(kind, line, fallback) {
+    if (!startupPanelFirst || startupPreambleVisible()) {
+        if (fallback)
+            fallback();
+        else if (kind === 'warn')
+            s.warn(line);
+        else
+            s.info(line);
+        return;
+    }
+    logStartupLine(line); // 诊断不丢: 无论上不上屏
+    if (!carriesHumanSignal(line))
+        return; // 纯进度: 默认口径下不上屏
+    if (startupPanelReady)
+        appendLine(`${C_WARN}/!\\ ${line}${RESET}`);
+    else
+        pushStartupAlert(line);
+}
+// ---------------------------------------------------------------------------
 // Harness loop  ─  poll-free event-driven (Hyperswarm DHT 自动推送)
 // ---------------------------------------------------------------------------
 /** 原始 Hyperswarm stream 缓存； HyperswarmCommunicator.sendToConnection 只打日志不写流 */
@@ -186,8 +240,14 @@ function publishDID(name, kp) {
             }
             catch (e) {
                 // 一次失败直接放弃 — 本地模式运行就够了, 不重试
-                appendLine(`     ${YELLOW}⚠ IPFS 发布失败 (${e?.message?.slice(0, 80) || 'unknown'}), 本地模式运行${RESET}`);
-                s.step(2, 5, '发布 DID → IPFS', 'warn');
+                const reason = e?.message?.slice(0, 80) || 'unknown';
+                // 失败详情照旧进面板 (appendLine → Ink): "为什么降级"这一条本来就是给面板看的
+                appendLine(`     ${YELLOW}⚠ IPFS 发布失败 (${reason}), 本地模式运行${RESET}`);
+                // 2026-09-27 口径收口: 这一行原来是打在**面板之前**的进度行 (默认口径下不许上屏),
+                //   可它是"降级" ⇒ 按铁律不许吞。两条同时成立的做法 = 折进面板告警通道
+                //   (`verify-cli-panel` 的 A1「面板前 0 行」+ A7「面板里能定位到这条降级原文」成对钉住)。
+                //   verbose / 非交互: 逐字回到老样子 (`s.step(…, 'warn')`)。
+                bootNotice('warn', `⚠ 降级: [2/5] 发布 DID → IPFS 失败 (${reason}) · 本地模式继续`, () => s.step(2, 5, '发布 DID → IPFS', 'warn'));
                 resolve({});
             }
         };
@@ -418,6 +478,8 @@ function rpcErr(code, msg) {
 // 2026-07-28: 改用 readline.createInterface + replReadline 循环
 let isRunning = false;
 let queueMode = false;
+// 2026-09-26: 启动期日志闸门句柄 (main() 里装; 诊断/验收用 `gate.stats` 读被静默的行数)
+let _startupLogGate = null;
 const pendingQueue = [];
 let cliStartTime = 0;
 let cliModelName = '…';
@@ -633,33 +695,11 @@ async function startCLI(commReady) {
     // 内部用法全空安全 (P2P 功能自动降级, 就绪后立即可用)
     let comm = null;
     commReady.then((c) => { comm = c; }).catch(() => { });
-    // CLI 模式下静音所有 console.log/warn/info/debug
-    // (Ink 用自己的 render 引擎, console 输出会污染终端)
-    console.log = () => { };
-    console.warn = () => { };
-    console.info = () => { };
-    console.debug = () => { };
-    // 过滤 process.stdout/stderr.write — 丢弃启动期 SDK/后台日志
-    //   (ISO 时间戳前缀如 `2026-09-08T...Z [info]:` 或被 [info]/[warn]/[error] 标记的行)
-    const _origStdout = process.stdout.write.bind(process.stdout);
-    const _origStderr = process.stderr.write.bind(process.stderr);
-    const isLogLine = (line) => {
-        const t = line.trimStart();
-        return t.startsWith('[') || /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(t) || /\[\s*(info|warn|error|debug|log)\s*\]/.test(t)
-            // Kubo/ipfs 启动噪声: "Use 'ipfs init --help'..." / "ipfs daemon is running..." 提示行无时间戳, 一并丢弃
-            || /ipfs init --help|ipfs daemon is running|please stop it to run this command/i.test(t);
-    };
-    const wrap = (orig) => (chunk, ...rest) => {
-        const s = typeof chunk === 'string' ? chunk : String(chunk);
-        if (!isLogLine(s))
-            return orig(chunk, ...rest);
-        const keep = s.split('\n').filter((l) => !isLogLine(l)).join('\n');
-        if (keep)
-            orig(keep, ...rest);
-        return true;
-    };
-    process.stdout.write = wrap(_origStdout);
-    process.stderr.write = wrap(_origStderr);
+    // 2026-09-26: 启动期日志静默**上移到 `src/cli/log-gate.ts`** (闸门在 main() 里装, 覆盖 CLI 交互 +
+    //   dashboard/web + plain 三个启动面)。这里不再自己 wrap stdout/stderr / 清空 console ——
+    //   旧写法只丢「行首 `[`」, 既漏掉依赖库的 ISO 时间戳日志, 又会把 `[supervisor] 初始化未就绪`
+    //   这种**需要人介入**的行一起吞掉 (与「错误不许被吞」冲突)。闸门按行分类, 信号行改道 stderr。
+    void _startupLogGate;
     let peerCount = 0;
     void commReady.then((c) => { try {
         if (c)
@@ -855,6 +895,24 @@ async function startCLI(commReady) {
         '⟳ 正在加载技能 / 工具...',
     ]);
     appendLine(bootBox);
+    // 2026-09-27 (leo 口径: `bolloon --cli` 起来直接就是面板, 启动前不刷前言):
+    //   就绪度报告 / 初始化续跑前言**默认不上屏** —— 但它们不是消失, 而是变成**面板里的行**:
+    //     · 就绪度折成一行 `就绪: basic ✓ · agent ✓ · durable ✗ · network ✓ · 详情: …`
+    //     · 失败 / 需人介入 (缺 key、连通性实测失败、初始化中断) 折成 `/!\` 开头的提示行 —— **不许吞**
+    //   注: 字面量里必须写 `\\ ` (反斜杠要转义), 否则 JS 会把 `\ ` 吃成空格 —— 屏上就变成 `/! ` 了
+    //   (验收门 `verify-cli-panel` 的 A4 按 `/!\` 判, 真踩过一次)。
+    //   全量版仍在 `startup.log`; `--verbose` / BOLLOON_VERBOSE=1 下逐字回到启动前的位置 (走 stderr)。
+    const notes = takeStartupPanelNotes();
+    const verbosePreamble = startupPreambleVisible();
+    if (notes.readiness && !verbosePreamble)
+        appendLine(`${C_DIM}${notes.readiness}${RESET}`);
+    for (const a of notes.alerts)
+        appendLine(`${C_WARN}/!\\ ${a}${RESET}`);
+    // 已经到面板了: 缓冲里剩下的纯前言**不上屏**(已在 startup.log), 丢掉引用免得下次启动重放
+    clearBufferedNotices();
+    // 面板第一帧之后: 晚到的降级提示 (后台 iroh / bootstrap / DID 发布…) 直接追加进面板,
+    //   不再等下一次 `takeStartupPanelNotes()` —— 否则它们会静静地烂在告警数组里 (= 吞)
+    startupPanelReady = true;
     void bootPanel({ dir: bootDirShort, model: (cliModelName && cliModelName !== '…') ? cliModelName : undefined, session: bootSessionId })
         .then((box) => { if (box)
         inkReplaceMatchingLine(bootBox, box); }).catch(() => { });
@@ -1345,6 +1403,10 @@ async function processInputInner(input, comm) {
             }
             const r = await agent.resumeRun(runId);
             appendLine(r.ok ? `${C_ACCENT}✅ 恢复执行完成${RESET}` : `${C_ERROR}恢复失败: ${r.reason}${RESET}`);
+            if (r.modelDrift?.drifted)
+                appendLine(`${C_ERROR}⚠ 模型配置已漂离快照: ${r.modelDrift.message}${RESET}`);
+            if (r.modelApplied)
+                appendLine(`${C_DIM}  本次恢复用的模型 (按 Run 快照装配): ${r.modelApplied.provider}/${r.modelApplied.model}${RESET}`);
         }
         catch (e) {
             appendLine(`${C_ERROR}/resume 失败: ${String(e?.message || e).slice(0, 200)}${RESET}`);
@@ -1408,6 +1470,8 @@ async function processInputInner(input, comm) {
             }
             const r = await agent.resumeRun(runId);
             appendLine(r.ok ? `${C_ACCENT}✅ 已批准并继续执行${RESET}` : `${C_ERROR}批准后恢复失败: ${r.reason}${RESET}`);
+            if (r.modelApplied)
+                appendLine(`${C_DIM}  本次恢复用的模型 (按 Run 快照装配): ${r.modelApplied.provider}/${r.modelApplied.model}${RESET}`);
         }
         catch (e) {
             appendLine(`${C_ERROR}/approve 失败: ${String(e?.message || e).slice(0, 200)}${RESET}`);
@@ -1598,6 +1662,7 @@ async function processInputInner(input, comm) {
         try {
             const { getSupervisor } = await import('./agents/execution-supervisor.js');
             const { wakeReport, listRunnableGoals, formatGoalLine } = await import('./agents/goal-store.js');
+            const { USER_VISIBLE_STATE_LABELS } = await import('./agents/goal-flywheel/types.js');
             const { runnable, skipped } = await listRunnableGoals({ now: Date.now() });
             const st = getSupervisor().status();
             appendLine(`${C_DIM}supervisor: owner=${st.owner} running=${st.running ? 'yes' : 'no'} tick=${st.tickIntervalMs}ms lease=${st.leaseTtlMs}ms dryRun=${st.dryRun ? 'yes' : 'no'} ticks=${st.ticks}${RESET}`);
@@ -1637,10 +1702,23 @@ async function processInputInner(input, comm) {
                 const sup = new ExecutionSupervisor({ runner: runner, maxPerTick: 1, log: (m) => appendLine(`${C_DIM}${m}${RESET}`) });
                 const rep = await sup.tickOnce();
                 appendLine(`${C_ACCENT}调度周期 #${rep.tick}${RESET}  认领 ${rep.claimed.length} · 执行 ${rep.executed.length}${rep.skipped.length ? ` · 跳过 ${rep.skipped.length}` : ''}`);
+                // 2026-09-25 (飞轮接线): 把飞轮的**判断**如实打出来 —— 为什么跑/为什么停, 用的是哪一类用户可见态
                 for (const s of rep.skipped.slice(0, 6))
                     appendLine(`  ${C_DIM}跳过 ${s.goalId}: ${s.reason}${RESET}`);
                 for (const e of rep.executed)
                     appendLine(`  ▶ ${e.goalId} → run=${e.runId || '-'} ${e.status || ''}${e.error ? ` (${e.error})` : ''}`);
+                for (const f of rep.flywheel) {
+                    const zh = USER_VISIBLE_STATE_LABELS[f.visibleState]?.zh || f.visibleState;
+                    appendLine(`  ${f.runnable ? C_DIM : C_WARN}飞轮 ${f.goalId}: ${f.decision}/${f.state} 无进展连续 ${f.noProgressStreak} 轮 · 用户可见态=${zh} · ${f.reason}${RESET}`);
+                }
+                for (const c of rep.closures) {
+                    appendLine(`  ${C_DIM}收尾 ${c.goalId}/${c.runId}: ${c.steps} 步 → ${c.decision} (memory ${c.memories} · skill 候选 ${c.candidates})${RESET}`);
+                    appendLine(`    ${C_DIM}用户汇报: ${c.reportPath}${RESET}`);
+                }
+                for (const b of rep.blocks)
+                    appendLine(`  ${C_WARN}阻塞 ${b.goalId}/${b.workId}: ${b.kind} → ${b.action} — ${b.note}${RESET}`);
+                for (const w of rep.workContracts)
+                    appendLine(`  ${C_DIM}工作合同已签发 ${w.goalId}: workId=${w.workId} 能力=${w.capability}${RESET}`);
                 return;
             }
             const rows = await wakeReport();
@@ -1648,8 +1726,12 @@ async function processInputInner(input, comm) {
                 appendLine(`${C_DIM}还没有目标。${RESET}`);
                 return;
             }
-            for (const r of rows.slice(0, 12))
-                appendLine(`  ${r.goalId}  [${r.status}]  唤醒: ${r.wake}${r.lease ? `  (lease ${r.lease})` : ''}`);
+            // 界面只上屏**用户可见态** (六类); 内部状态缩到 dim 尾巴里, 只作为排障线索
+            for (const r of rows.slice(0, 12)) {
+                const zh = USER_VISIBLE_STATE_LABELS[r.visible]?.zh || r.visible || r.status;
+                appendLine(`  ${r.goalId}  [${zh}]  唤醒: ${r.wake}${r.nextAction ? `  下一步: ${String(r.nextAction).slice(0, 60)}` : ''}${r.lease ? `  (lease ${r.lease})` : ''}`);
+                appendLine(`${C_DIM}    (内部: status=${r.status} visible=${r.visible})${RESET}`);
+            }
             if (runnable.length) {
                 appendLine(`${C_DIM}现在可推进:${RESET}`);
                 for (const g of runnable.slice(0, 5))
@@ -1678,46 +1760,99 @@ async function processInputInner(input, comm) {
         }
         return;
     }
-    // /model — 无参: 交互选择器 (ink 渲染, 复用 MentionPopup); 有参: 直接切换/测连通/看状态
+    // /model — 无参: 分步选择器 (供应商 → 凭证 → 模型 → 参数 → 作用域 → 测试 → 确认);
+    //   有参: 直接切换/测连通/看状态 (与 bolloon model 同一套语义)
     if (cmd === '/model' || cmd.startsWith('/model ')) {
         const modelArg = trimmed.slice('/model'.length).trim();
-        if (modelArg) {
-            try {
-                const { runModelCommand } = await import('./cli/setup-wizard.js');
-                // 会话内不提供隐藏输入 (避免 API key 留在会话回显/记录里) → 需要 key 时给出系统终端指引
-                const out = await runModelCommand(modelArg);
-                for (const line of String(out).split('\n'))
-                    appendLine(`${C_DIM}${line}${RESET}`);
-            }
-            catch (e) {
-                appendLine(`${C_ERROR}/model 失败: ${String(e?.message || e).slice(0, 150)}${RESET}`);
-            }
-            return;
+        if (!modelArg) {
+            appendLine(`${C_DIM}模型选择 (分步): 供应商 → 凭证 → 模型 → 生成参数 → 作用域 → 测试连接 → 确认切换${RESET}`);
         }
         try {
-            const { llmConfigStore, PROVIDER_INFO } = await import('./llm/config-store.js');
-            await llmConfigStore.initialize();
-            const config = await llmConfigStore.getConfig();
-            const items = Object.entries(config.providers).map(([name, p]) => ({
-                kind: 'command',
-                label: name,
-                hint: `${String(PROVIDER_INFO[name]?.name || '').padEnd(14)} ${p.apiKey ? '🔑' : p.requiresApiKey ? '⚠ 无key' : ''}  ${p.model || ''}`,
-                insert: name,
-            }));
-            globalThis.__inkOpenPicker?.(items, '选择模型供应商 (↑↓ 选择 · Enter 确认 · Esc 取消)', async (it) => {
+            const { runModelCommand, modelTtyIO } = await import('./cli/setup-wizard.js');
+            /**
+             * 把渲染层的选择器借给分步选择器用: 每次要一个选择时开窗, 拿到结果 (或用户 Esc) 就往下走。
+             * Esc 通过取消回调报回 null —— 没有这条通路时"按 Esc"会让调用方一直等。
+             *
+             * ⚠️ 这条 (`inkChoose`, Ink 画的小弹窗) 现在只是**非终端**的兜底 (管道/脚本)。
+             *    真终端走下面那条: 与 `bolloon model` **同一个** `tui-select` 全屏选择器
+             *    (固定高度视窗 + 跟随 + 折叠 + 搜索 + 光标高亮 + "还有 M 家")。
+             */
+            const inkChoose = (items, title) => new Promise((resolve) => {
+                const g = globalThis;
+                if (typeof g.__inkOpenPicker !== 'function') {
+                    resolve(null);
+                    return;
+                }
+                g.__inkOpenPicker(items.map((c) => ({ kind: 'command', label: c.label, hint: c.hint, insert: c.value })), title, (it) => resolve(it?.insert ?? it?.label ?? null), () => resolve(null));
+            });
+            // 真终端: 让出终端给**同一个**全屏选择器组件 (两个渲染器不能同时抢一个 tty), 用完挂回来。
+            const sharedPicker = await import('./cli/tui-select.js').then((m) => m.tuiCapable()).catch(() => false);
+            let out;
+            if (sharedPicker) {
+                suspendInk();
                 try {
-                    await llmConfigStore.setActiveProvider(it.label);
-                    const active = await llmConfigStore.getActiveProvider();
-                    appendLine(`${C_OK}✓ 已切换到 ${it.label} (${String(PROVIDER_INFO[it.label]?.name || '')})${RESET}`);
-                    appendLine(`${C_DIM}  当前模型: ${config.providers[it.label]?.model || '默认'}${RESET}`);
+                    const tio = modelTtyIO();
+                    out = await runModelCommand(modelArg, {
+                        ...tio,
+                        // 会话内**不提供**隐藏输入: API key 不许进会话回显/记录 (需要 key 时选择器给系统终端指引)
+                        askHidden: undefined,
+                        // `tio.live = true`: 每一步当场打在终端上 (选择器自己就是整屏渲染, 不需要再回放整段)
+                    });
                 }
-                catch (e) {
-                    appendLine(`${C_ERROR}✗ 切换失败: ${String(e.message || e).slice(0, 150)}${RESET}`);
+                finally {
+                    resumeInk();
                 }
-            });
+            }
+            else {
+                out = await runModelCommand(modelArg, { choose: inkChoose });
+            }
+            for (const line of String(out).split('\n'))
+                if (line.trim())
+                    appendLine(`${C_DIM}${line}${RESET}`);
+        }
+        catch (e) {
+            appendLine(`${C_ERROR}/model 失败: ${String(e?.message || e).slice(0, 150)}${RESET}`);
+        }
+        return;
+    }
+    // /copy — 把**最近一条回复** (或整段会话) 真写进系统剪贴板 (2026-09-27)
+    //   为什么要有: 面板是 Ink 画的整屏自绘帧, 终端里用鼠标框选会被"重画一帧"打断;
+    //   与其让用户撞运气, 不如给一条**不靠鼠标**的显式通路 (`/copy` / `/copy all` / `/copy 3`)。
+    if (cmd === '/copy' || cmd.startsWith('/copy ')) {
+        const arg = trimmed.slice('/copy'.length).trim().toLowerCase();
+        try {
+            const store = await import('./cli/stores.js');
+            const msgs = store.transcriptStore.get().filter((m) => String(m ?? '').trim());
+            let text = '';
+            let what = '';
+            if (arg === 'all') {
+                text = store.allMsgsText();
+                what = `整段会话 (${msgs.length} 条)`;
+            }
+            else if (/^\d+$/.test(arg)) {
+                const n = Math.max(1, Math.min(Number(arg), msgs.length));
+                text = msgs.slice(msgs.length - n).join('\n');
+                what = `最近 ${n} 条`;
+            }
+            else {
+                text = store.lastMsg();
+                what = '最近一条';
+            }
+            if (!String(text).trim()) {
+                appendLine(`${C_DIM}面板里还没有可复制的内容${RESET}`);
+                return;
+            }
+            const r = clipboardWrite(text);
+            if (r.ok) {
+                appendLine(`${C_ACCENT}✅ 已复制${what} → 系统剪贴板 (${r.tool} · ${r.chars} 字符)${RESET}`);
+            }
+            else {
+                appendLine(`${C_ERROR}✗ 复制失败 (${what}): ${r.error}${RESET}`);
+                appendLine(`${C_DIM}  兜底: 终端里用鼠标框选不会被自动重画打断 (上滚会自动暂停跟随)${RESET}`);
+            }
         }
         catch (e) {
-            appendLine(`${C_ERROR}/model 失败: ${String(e.message || e).slice(0, 150)}${RESET}`);
+            appendLine(`${C_ERROR}/copy 失败: ${String(e?.message || e).slice(0, 150)}${RESET}`);
         }
         return;
     }
@@ -2928,8 +3063,21 @@ async function processInputInner(input, comm) {
                 }
                 else if (e.type === 'status' && e.content) {
                     const content = String(e.content);
+                    // 2026-09-27 (回复流卫生): **内部运行日志不进对话回复流** ——
+                    //   CLI 交互面没有独立的状态区, 这条 onStream 就是"回复流", 于是
+                    //   `🔄 开始 ReAct 循环...` / `🧷 运行已登记 (...)` / `✅ 处理完成，共 N 次循环` /
+                    //   `🎯 目标仍在进行 (未判完成): …` 这类**给开发者看的运行过程**会和用户的结论
+                    //   混成一列消息 (leo 报的正是这个)。判据不按子串猜, 只认发送点的显式声明
+                    //   (`StreamEvent.internal`, 见 pi-sdk-types) —— 旧的子串过滤继续保留在下面兜底。
+                    //   搬走不是删掉: 同一行原文照落 logs/startup.log (目的地走已有的 startupLogPath()),
+                    //   `--verbose`/`BOLLOON_VERBOSE=1` 时原样上屏, 诊断能力一点不丢。
+                    if (isInternalRunLog(e)) {
+                        appendInternalRunLog(content, e.tool);
+                        if (isStartupVerbose())
+                            appendLine(`${C_DIM}${content}${RESET}`);
+                    }
                     // Reflection / 反思 / 💡 → 圆角思考框 (和回复一样走 renderMessageBox, 白字+亮边框)
-                    if (content.includes('Reflection') || content.includes('反思') || content.includes('💡')) {
+                    else if (content.includes('Reflection') || content.includes('反思') || content.includes('💡')) {
                         const body = content.replace(/^💡\s*/, '').slice(0, 1500);
                         if (body.trim())
                             appendLine(renderMessageBox({ title: '💡 反思', body, color: C_WARN }));
@@ -3112,7 +3260,53 @@ const AVAILABLE_TOOLS = [
     { name: 'update_check', description: '检查 npm 包更新', example: '--update-check' },
     { name: 'update_now', description: '立即更新到最新版本', example: '--update-now [package]' },
 ];
-async function runToolCommand(tool, args, outputJson, comm, model, prompt) {
+/**
+ * 给 `--delegate` 找长期目标上下文 (P5 验收修复)。
+ *
+ * `SubAgentManager.delegateTask` 只在拿到 `goalId` 时才签工作合同 (`issueWorkContractFor`:
+ * "没有长期目标就没有合同上下文"), 而合同是"回报必须带逐条证据"这道门的唯一凭据。
+ *
+ * ★ 之前 CLI 是唯一的生产派遣调用方, **不传 goalId** ⇒ 真路径上一条合同都不签:
+ *   运行时复现过"回一句『全部做完了』就把任务标成 completed, 父目标上什么都没留下"。
+ *
+ * 两种入口:
+ *   - `--goal <goalId>`: 用既有目标 (目标不存在 → 抛错, 让调用方如实报告"没签合同");
+ *   - 没给: 为这次委派**建一个目标** (`createdBy='cli:delegate'`) 并进"等外部回报"态 ——
+ *     委派总是有目标上下文, 合同门不再空转。
+ *
+ * 为什么是 `awaiting_external` + `autoContinue=false`: 这次委派的执行者是**子 Agent**, 不是本节点
+ *   harness。`awaiting_external` 会被 Supervisor 明确跳过 (`listRunnableGoals`: "等外部事件, 不重复
+ *   发送"), 因此不会出现"同一件事被 harness 和子 Agent 各跑一遍"; 同时"没拿到带证据的回报前不自动
+ *   继续"。
+ */
+async function ensureDelegateGoal(explicitGoalId, taskDesc, caps) {
+    const { createGoal, readGoal, setContinuation, updateGoal } = await import('./agents/goal-store.js');
+    if (explicitGoalId) {
+        const g = await readGoal(explicitGoalId);
+        if (!g)
+            throw new Error(`--goal ${explicitGoalId} 不存在 (不签合同)`);
+        return { goalId: g.goalId, note: `合同签在既有目标 ${g.goalId} (状态 ${g.status}) 上` };
+    }
+    const g = await createGoal({
+        objective: `【委派】${taskDesc}`,
+        successCriteria: [taskDesc],
+        createdBy: 'cli:delegate',
+    });
+    await updateGoal(g.goalId, { status: 'awaiting_external' });
+    await setContinuation(g.goalId, {
+        state: 'awaiting_external',
+        wakeReason: 'awaiting_external',
+        autoContinue: false,
+        needsExternal: `等子 Agent 「${caps.join('/')}」交回带逐条证据的回报 (回报核验不过不算完成)`,
+    });
+    return {
+        goalId: g.goalId,
+        note: `已为本次委派建目标 ${g.goalId} (状态=等外部回复: 等子 Agent 的带证据回报)`,
+    };
+}
+async function runToolCommand(tool, args, outputJson, comm, model, prompt, 
+/** `--goal <goalId>` (P5 验收修复: 给 `--delegate` 指目标上下文) */
+goalFlag) {
     const a = await getAgent();
     const startTime = Date.now();
     let response;
@@ -3572,18 +3766,39 @@ async function runToolCommand(tool, args, outputJson, comm, model, prompt) {
             case 'delegate': {
                 const [taskDesc, ...requiredCaps] = args;
                 if (!taskDesc) {
-                    response = '用法: --delegate <任务描述> [能力要求1] [能力要求2] ...';
+                    response = '用法: --delegate <任务描述> [能力要求1] [能力要求2] ... [--goal <goalId>]';
                     error = response;
                     break;
                 }
+                const caps = requiredCaps.length > 0 ? requiredCaps : ['general'];
                 const manager = await createSubAgentManager();
-                const a = await getAgent();
-                const { task, agent } = await manager.delegateTask('cli-user', taskDesc, requiredCaps.length > 0 ? requiredCaps : ['general']);
-                if (agent) {
-                    response = `✅ 任务已委派:\n  任务ID: ${task.id}\n  执行Agent: ${agent.name} (${agent.id})\n  状态: ${task.status}`;
+                // ★ 2026-09-25 (P5 验收修复): 派遣**必须**带 goalId。
+                //   `SubAgentManager` 只在拿到 goalId 时才签工作合同 (没有长期目标就没有合同上下文);
+                //   而在真实运行里复现过: 不签合同 ⇒ 回报核验这道门完全不生效 ——
+                //   一句"全部做完了"就能把任务标成 completed, 父 Goal 上也留不下"等回报"的痕迹。
+                //   显式 `--goal <goalId>` (校验目标存在) 优先; 没给就为这次委派**建一个目标**,
+                //   合同门在生产路径上不再空转 (目标进"等外部回报"态, 见 ensureDelegateGoal)。
+                let goalId = '';
+                let goalNote = '';
+                try {
+                    const g = await ensureDelegateGoal(goalFlag || '', taskDesc, caps);
+                    goalId = g.goalId;
+                    goalNote = g.note;
+                }
+                catch (err) {
+                    goalNote = `目标上下文准备失败 → 本次不签工作合同 (合同门不生效): ${String(err?.message || err).slice(0, 160)}`;
+                }
+                const { task, agent, workContract } = await manager.delegateTask('cli-user', taskDesc, caps, 'normal', undefined, goalId ? { goalId, successCriteria: [taskDesc] } : undefined);
+                const head = agent
+                    ? `✅ 任务已委派:\n  任务ID: ${task.id}\n  执行Agent: ${agent.name} (${agent.id})\n  状态: ${task.status}`
+                    : `⚠️ 未找到合适的Agent，任务已创建:\n  任务ID: ${task.id}\n  状态: ${task.status}`;
+                if (workContract) {
+                    response = `${head}\n  ${goalNote}\n  工作合同: ${workContract.workId} (目标 ${goalId})\n`
+                        + `  完成判据 ${workContract.successCriteria.length} 条 · 必带证据 ${workContract.requiredEvidence.length} 条\n`
+                        + `  ⚠️ 回报必须按判据逐条给证据: 一句"全部做完了"**不会**被接受为完成`;
                 }
                 else {
-                    response = `⚠️ 未找到合适的Agent，任务已创建:\n  任务ID: ${task.id}\n  状态: ${task.status}`;
+                    response = `${head}\n  ⚠️ 未签工作合同: ${goalNote || '没有目标上下文'} —— 无合同的回报不做证据核验`;
                 }
                 break;
             }
@@ -3985,7 +4200,7 @@ async function runNonInteractive(args, comm) {
             outputBuffer += params.join(' ') + '\n';
         };
         if (tool) {
-            await runToolCommand(tool, toolArgs, false, comm, args.model, prompt);
+            await runToolCommand(tool, toolArgs, false, comm, args.model, prompt, args.goal);
         }
         else if (prompt) {
             const a = await getAgent();
@@ -4025,7 +4240,7 @@ async function runNonInteractive(args, comm) {
         return;
     }
     if (tool) {
-        await runToolCommand(tool, toolArgs, !!json, comm, args.model, prompt);
+        await runToolCommand(tool, toolArgs, !!json, comm, args.model, prompt, args.goal);
     }
     else if (prompt) {
         const startTime = Date.now();
@@ -4186,6 +4401,10 @@ function parseArgs() {
                 }
                 result.toolArgs = delArgs;
                 break;
+            // ★ 2026-09-25 (P5 验收修复): 给 --delegate 指定长期目标 (有 goalId 才签工作合同)
+            case '--goal':
+                result.goal = args[++i];
+                break;
             case '--engine':
             case '-e':
                 result.engine = args[++i];
@@ -4389,7 +4608,9 @@ function printHelp() {
   # SubAgent 管理
   --agents                   列出所有 SubAgent
   --register-agent <name> [cap1] [cap2]...  注册新 SubAgent
-  --delegate <任务描述> [能力要求...]  委派任务给最佳 Agent
+  --delegate <任务描述> [能力要求...] [--goal <goalId>]
+                              委派任务给最佳 Agent (签工作合同: 回报必须带逐条证据;
+                              --goal 不给则为本次委派建一个目标)
 
   # 全局共享上下文
   --context                  显示全局共享上下文摘要
@@ -4502,6 +4723,29 @@ async function main() {
             printHelp();
             process.exit(0);
         }
+        // 2026-09-26: 启动期日志闸门 —— 在**任何 bootstrap 之前**装上, 覆盖三个启动面:
+        //   `cli-interactive` (CLI 交互启动, stdout 归 Ink, 信号行改道 stderr) / `web` (dashboard) / 其它 `plain`。
+        //   默认: 加载日志不上控制台 + 全部落日志文件; `--verbose` / `BOLLOON_VERBOSE=1`: 一行不改地全量回流;
+        //   带「失败/未就绪/超时/⚠」等信号的行任何模式下都可见 (leo: 错误不许被吞)。
+        //   不装闸门的三类: `--json` (stdout 是机器读的数据本体)、一次性工具调用 (`--prompt`/`--tool`/`--read` …)、
+        //   命令式诊断 (`--setup-*` / `--supervise*`, 它们的输出就是交付物)。
+        const isOneShotTool = !!(args.tool || args.prompt);
+        const isCommandLike = !!(args.supervise || args.setupStatus || args.setupResume || args.setupRepair
+            || args.setupReconfigure || args.setupTest);
+        if (!args.json && !isOneShotTool && !isCommandLike) {
+            _startupLogGate = installStartupLogGate({
+                mode: args.web ? 'web' : 'cli-interactive',
+                args: process.argv.slice(2),
+            });
+            // 闸门自己的失败必须可见 (否则「日志写不进去」会成为新的静默缺陷)
+            if (_startupLogGate.stats.fileError) {
+                process.stderr.write(`${_startupLogGate.stats.fileError}\n`);
+            }
+            // 诊断模式提示: 告诉用户「现在全量输出」+ 静默时的日志落哪 (默认模式下这一行不出现)
+            if (isStartupVerbose(process.argv.slice(2))) {
+                process.stderr.write(`[log-gate] 诊断模式 (--verbose / ${VERBOSE_ENV}=1): 启动日志全量输出, 同时落盘 ${startupLogPath()}\n`);
+            }
+        }
         // 启动时后台检查更新 (不阻塞主流程)。
         // 2026-09-19 行为变更: **默认只通知, 不自动安装** —— 发现新版本会打印一行提示 +
         //   "bolloon update plan / now"。要恢复自动安装需显式 config.json `autoInstall: true`
@@ -4593,54 +4837,75 @@ async function main() {
         };
         const isCLIInteractive = mode === 'cli' && !isNonInteractive;
         if (isCLIInteractive) {
-            console.log = () => { };
-            console.info = () => { };
-            // 2026-08-07: 只吞 SDK 结构化日志 (2026-...T 前缀直接写 stdout 的), 其余 (Ink ANSI 渲染) 走原始 write
-            //   不能整体 no-op — Ink 渲染依赖 write callback, 且 pty/管道缓冲满时 no-op 会掩盖真实写状态
-            process.stdout.write = ((chunk, ...rest) => {
-                const s = String(chunk);
-                if (/^\d{4}-\d{2}-\d{2}T/.test(s))
-                    return true; // SDK 结构化日志 → 吞
-                return originalStdoutWrite(chunk, ...rest);
-            });
+            // 2026-09-26: console.log/info 与 stdout 的静默已由 `src/cli/log-gate.ts` 统一负责
+            //   (mode='cli-interactive': 加载日志丢弃并写文件, 信号行改道 stderr, Ink 的 ANSI 原样放行)。
+            //   这里只留「交互模式不打扰用户」的那一件与日志无关的事: 静音 auto-update 通知。
             // 2026-08-07: 交互模式静音 auto-update 后台通知 (stderr), 避免 "🔍 检查更新" 污染 TUI
             void import('./utils/auto-update.js').then(({ setNotifyQuiet }) => setNotifyQuiet(true)).catch(() => { });
         }
         // 2026-09-13: 首次运行引导 — 没有可用模型供应商 / 还没有用户身份时, 先走初始化向导
         //   (放在 CLI 启动前: 用户先回答"你是谁 / 用哪个模型", 再进 TUI 面板)
         if (isCLIInteractive) {
+            // 面板优先口径 (2026-09-27): 这一程后面打的所有启动期进度/降级行都走 `bootNotice()`
+            //   —— 面板第一帧之前不上屏, 但"失败/降级/需人介入"折进面板告警 (两条口径同时成立)。
+            //   `--verbose` / `BOLLOON_STARTUP_PREAMBLE=1` 时这个开关是 false ⇒ 逐字照旧打屏。
+            startupPanelFirst = !startupPreambleVisible();
             // 2026-09-16 (M4 启动硬门禁): 先把初始化事实读出来 —— 未就绪就**先修**, 修不好就非零退出。
             //   旧行为是"向导失败也只 warn, 照常进对话", 结果是半成品配置能进运行态 (看起来启动成功、实际不可执行)。
+            //
+            // 2026-09-27 (leo 口径): **打完 `bolloon --cli` 就该直接看到面板** ——
+            //   下面这一整段 (门禁报告 / 向导续跑前言 / `✅ 初始化完成`) 属于"启动前的日志", 默认**一个字节都不上屏**:
+            //     · `describeSetup(ev)` 改走 `noticePreamble()` → 默认进缓冲 (照落启动日志), verbose/`BOLLOON_STARTUP_PREAMBLE=1` 时逐字回来;
+            //     · 就绪度折成**面板一行** (`就绪: basic ✓ · … · 详情: bolloon setup status`, 在 startCLI 里 appendLine);
+            //     · 失败 / 需人介入折成**面板告警行** (`alertsFromSetup`) —— 不许被吞, 但也不许刷屏。
+            //   兜底: 只要这一程**走不到面板** (非零退出) 或**要人当场回答** (向导提问前), 缓冲先 flush 到 stderr。
             const w = (m) => process.stderr.write(m.endsWith('\n') ? m : m + '\n');
             let gateEv = null;
             try {
                 const { refreshSetupState, describeSetup } = await import('./setup/setup-store.js');
                 gateEv = await refreshSetupState({ light: true });
+                // 面板一行就绪度 + 告警 (先登记, 面板渲染时取走)
+                setStartupReadiness(readinessLine(gateEv.state?.readiness || {}));
+                for (const a of alertsFromSetup(gateEv)) {
+                    pushStartupAlert(a);
+                    noticePreamble(a);
+                }
                 if (gateEv.gate !== 'ready') {
-                    w(describeSetup(gateEv));
+                    noticePreamble(describeSetup(gateEv));
                     if (process.env.BOLLOON_SKIP_SETUP === '1') {
-                        w('⚠ BOLLOON_SKIP_SETUP=1 → 诊断模式: 可以看状态/修配置, 但 agent 执行被门禁拦住 (不能绕过)');
+                        noticePreamble('⚠ BOLLOON_SKIP_SETUP=1 → 诊断模式: 可以看状态/修配置, 但 agent 执行被门禁拦住 (不能绕过)');
                     }
                     else {
                         const { runSetupWizard } = await import('./cli/setup-wizard.js');
-                        await runSetupWizard({ interactive: true });
+                        // quietStartup: 向导的续跑前言默认不上屏 (它自己会在"要人回答/有失败"时先 flush)
+                        await runSetupWizard({ interactive: true, quietStartup: true });
                         const after = await refreshSetupState({});
+                        setStartupReadiness(readinessLine(after.state?.readiness || {}));
+                        for (const a of alertsFromSetup(after)) {
+                            pushStartupAlert(a);
+                            noticePreamble(a);
+                        }
                         if (after.gate !== 'ready') {
-                            w(describeSetup(after));
+                            // 走不到面板 → 前言必须先落屏 (否则就是被吞)
+                            noticePreamble(describeSetup(after));
+                            flushStartupNotices();
                             w('⛔ 初始化未完成 → 退出 (不会以"看起来能跑"的状态进入对话)');
                             process.exit(1);
                         }
-                        w('✅ 初始化完成, 进入正常模式');
+                        noticePreamble('✅ 初始化完成, 进入正常模式');
                     }
                 }
             }
             catch (e) {
-                // 评估/向导自身异常: fail-closed —— 不假装就绪
-                w(`⛔ 初始化流程失败 (fail-closed): ${String(e?.message || e).slice(0, 200)}`);
-                w(`   当前状态评估: ${gateEv ? gateEv.gate : '未知 (评估都没跑通)'}`);
-                w('   排查: `bolloon setup --status` (或删掉 ~/.bolloon/setup-state.json 后重跑 setup)');
+                // 评估/向导自身异常: fail-closed —— 不假装就绪, 且缓冲**必须**落屏 (这就要退出了, 没有面板接着)
+                noticePreamble(`⛔ 初始化流程失败 (fail-closed): ${String(e?.message || e).slice(0, 200)}`, { visible: true });
+                noticePreamble(`   当前状态评估: ${gateEv ? gateEv.gate : '未知 (评估都没跑通)'}`, { visible: true });
+                noticePreamble(`   排查: \`bolloon setup status\` (或删掉 ~/.bolloon/setup-state.json 后重跑 setup)`, { visible: true });
+                flushStartupNotices();
                 process.exit(1);
             }
+            if (startupPreambleVisible())
+                w(preambleHintLine());
         }
         if (isNonInteractive) {
             console.error = () => { };
@@ -4667,8 +4932,20 @@ async function main() {
                                     hasKimi ? 'Kimi' :
                                         hasGlm ? 'GLM' :
                                             hasQwen ? 'Qwen' : null;
+        // 2026-09-26: 启动装配统一从「有效模型配置」来 (Session > Global > 供应商默认 > 环境变量)。
+        //   旧写法按"环境变量里有哪些 key"挑供应商, 与 Web 启动(读配置文件)给出不同结果 ——
+        //   同一个人配了 deepseek 配置文件、环境里又留着 OPENAI_API_KEY, 换个入口就换模型。
         if (llmProvider) {
-            initMinimax({ provider: llmProvider.toLowerCase() });
+            try {
+                const { applyEffectiveToRuntime } = await import('./llm/model-selection.js');
+                const eff = await applyEffectiveToRuntime();
+                bootNotice('info', `模型: ${eff.provider}/${eff.model} (来源: ${eff.source})`);
+            }
+            catch (e) {
+                // 装配失败不静默: 退回按环境变量初始化 (至少让用户看到原因)
+                bootNotice('warn', `按有效配置装配模型失败 (${String(e?.message || e).slice(0, 120)}), 退回环境变量猜测`);
+                initMinimax({ provider: llmProvider.toLowerCase() });
+            }
         }
         else {
             if (isNonInteractive) {
@@ -4688,11 +4965,11 @@ async function main() {
                 if (typeof checkKuboSetup === 'function') {
                     const setup = await checkKuboSetup(true, true);
                     kuboReady = !!(setup?.ready && setup?.daemonRunning);
-                    s.info(kuboReady ? 'IPFS 本地 Kubo 就绪 → IPNS 发布/解析可用' : 'Kubo 不可用, IPFS 降级本地模式');
+                    bootNotice('info', kuboReady ? 'IPFS 本地 Kubo 就绪 → IPNS 发布/解析可用' : 'Kubo 不可用, IPFS 降级本地模式');
                 }
             }
             catch (e) {
-                s.warn(`Kubo 自动安装失败 (非致命): ${String(e?.message || e).slice(0, 120)}`);
+                bootNotice('warn', `Kubo 自动安装失败 (非致命): ${String(e?.message || e).slice(0, 120)}`);
             }
             publishDID(name, keypair).then(({ cid, ipnsName }) => {
                 if (cid)
@@ -4714,7 +4991,7 @@ async function main() {
                         agentIdentity.p2pChannel = 'bolloon-agent-harness';
                     }
                 }).catch(err => {
-                    s.warn(`P2P Web 模式启动失败: ${err.message}`);
+                    bootNotice('warn', `P2P Web 模式启动失败: ${err.message}`);
                 });
             }
             else if (isCLIInteractive) {
@@ -4722,7 +4999,7 @@ async function main() {
                 // startCLI 收 Promise, 内部空安全 (P2P 功能就绪前自动降级, 一般 1-3s 内可用)
                 commReady = withTimeout(bootstrapP2P(verifier), 20_000, 'P2P 网络初始化')
                     .catch((err) => {
-                    s.warn(`P2P 初始化超时/失败, 降级无 P2P 模式: ${err.message}`);
+                    bootNotice('warn', `P2P 初始化超时/失败, 降级无 P2P 模式: ${err.message}`);
                     return null;
                 });
                 void commReady.then((c) => {
@@ -4739,7 +5016,7 @@ async function main() {
                 // 2026-08-07: 弱网下 hyperswarm DHT start/joinTopic 可能无限挂起 → 20s 超时门, 超时降级无 P2P 模式
                 comm = await withTimeout(bootstrapP2P(verifier), 20_000, 'P2P 网络初始化')
                     .catch((err) => {
-                    s.warn(`P2P 初始化超时/失败, 降级无 P2P 模式: ${err.message}`);
+                    bootNotice('warn', `P2P 初始化超时/失败, 降级无 P2P 模式: ${err.message}`);
                     return null;
                 });
                 if (comm) {
@@ -4752,37 +5029,37 @@ async function main() {
             }
         }
         catch (err) {
-            s.warn(`P2P 初始化失败: ${err.message}`);
-            s.warn('将使用无 P2P 模式运行');
+            bootNotice('warn', `P2P 初始化失败: ${err.message}`);
+            bootNotice('warn', '将使用无 P2P 模式运行');
         }
         if (isCLIInteractive) {
             // 2026-09-08 加速启动: iroh + Bolloon bootstrap 也全部后台, 不阻塞 UI 首帧
             void withTimeout(bootstrapIroh(keypair, name), 15_000, 'iroh P2P 初始化')
-                .catch((err) => s.warn(`iroh 初始化超时, 继续使用 Hyperswarm P2P: ${err.message}`));
+                .catch((err) => bootNotice('warn', `iroh 初始化超时, 继续使用 Hyperswarm P2P: ${err.message}`));
             void (async () => {
                 try {
                     const { bootstrapBolloon } = await import('./pi-ecosystem-judgment/human-value-pipeline.js');
                     const bs = await withTimeout(bootstrapBolloon({ cwd: process.cwd() }), 20_000, 'Bolloon 上下文扫描');
-                    s.info(`Bootstrap 完成 (${bs.durationMs}ms, ${bs.errors.length} 个非致命错误)`);
+                    bootNotice('info', `Bootstrap 完成 (${bs.durationMs}ms, ${bs.errors.length} 个非致命错误)`);
                 }
                 catch (err) {
-                    s.warn(`Bootstrap 失败 (非致命, 主流程继续): ${err.message}`);
+                    bootNotice('warn', `Bootstrap 失败 (非致命, 主流程继续): ${err.message}`);
                 }
             })();
         }
         else {
             await withTimeout(bootstrapIroh(keypair, name), 15_000, 'iroh P2P 初始化')
-                .catch((err) => s.warn(`iroh 初始化超时, 继续使用 Hyperswarm P2P: ${err.message}`));
+                .catch((err) => bootNotice('warn', `iroh 初始化超时, 继续使用 Hyperswarm P2P: ${err.message}`));
             // Bolloon Bootstrap: 启动扫描 + Context 收集 + 挂定时任务
             // 失败静默 (主流程不被阻塞)
             try {
                 const { bootstrapBolloon } = await import('./pi-ecosystem-judgment/human-value-pipeline.js');
-                s.info('正在 bootstrap bolloon 上下文...');
+                bootNotice('info', '正在 bootstrap bolloon 上下文...');
                 const bs = await withTimeout(bootstrapBolloon({ cwd: process.cwd() }), 20_000, 'Bolloon 上下文扫描');
-                s.info(`Bootstrap 完成 (${bs.durationMs}ms, ${bs.errors.length} 个非致命错误)`);
+                bootNotice('info', `Bootstrap 完成 (${bs.durationMs}ms, ${bs.errors.length} 个非致命错误)`);
             }
             catch (err) {
-                s.warn(`Bootstrap 失败 (非致命, 主流程继续): ${err.message}`);
+                bootNotice('warn', `Bootstrap 失败 (非致命, 主流程继续): ${err.message}`);
             }
         }
         if (mode === 'web') {