@bolloon/bolloon-agent 0.6.1 → 0.6.3

package/dist/agents/pi-sdk.js

@@ -17,13 +17,15 @@ import { createRunContext } from './run-context.js';
 import { createPrivateActor } from '../kernel/channel-actor.js';
 // K10 ①: 运行生命周期写入经内核端口 (与 kernel/control.ts 的控制面分开 —— 一个回答"谁命令我停",
 //   一个回答"我这一轮发生了什么"; 失败语义也不同: 控制面被拒 → 409, 事实写不进 → 响亮失败)
-import { submitRunLifecycle, assertLifecycleOk } from '../kernel/run-lifecycle.js';
+import { submitRunLifecycle, assertLifecycleOk, pickRunIdForResume } from '../kernel/run-lifecycle.js';
 // K10 ④: 通信发送入口经内核端口 (上层不再直接对某条传输说话; 换传输只改这一处注入)
 import { submitTransport, transportPeersSync } from '../kernel/transport.js';
 // K10 ①: run 状态迁移经内核**控制面**端口 (它本来就管"谁命令这条 run 改状态": 带 origin 审计 + 拒绝归一化)
 import { submitRunControl } from '../kernel/control.js';
 // K10 ②: 回合的模型经**内核运行时**只读取租约 (传输仍是 Pi 客户端 ⇒ 行为不变; 取不到如实回落)
 import { ModelRuntime, snapshotFromSelection } from '../kernel/model-runtime.js';
+// K10 余项: 会话生命周期的**规则**归内核 (落盘映射 · key 校验 · 读回过滤/水合 · 运行种子合并顺序), I/O 留本类经端口注入
+import { submitSessionOp, assertSessionOk, composeRunSeed, filterSessionMessages, hydrateSessionMessages, } from '../kernel/session-lifecycle.js';
 import { renderDelegateNotices, pushNotice, renderNoticeBlock } from './background-notices.js';
 import { runWithWriteOrigin } from './skill-ledger.js';
 import { createHash } from 'node:crypto';
@@ -31,7 +33,12 @@ import { shouldReviewTask, runExperienceReview } from './experience-review.js';
 import { decideLessonSink, skillsFromDirs, logLessonSuggestions, routeLessonToSkill } from './lesson-to-skill.js';
 import { managedServices } from './managed-services.js';
 import { renderToolListWithParams } from './tool-subset.js';
-import { codeWriteTarget, decideTypecheck, formatTypecheckResult } from './code-write-gate.js';
+// K10 余项: 收尾自检的**规则**归内核 (`kernel/code-write-gate.ts`) —— 原来是 agents 侧的一个模块
+import { codeWriteTarget } from '../kernel/code-write-gate.js';
+// K10 余项: 收尾自检的**编排与政策**也归内核 (该不该跑 · 系统自检也过门 · 被拒不执行且可见 · 失败不影响回合)
+import { runTurnEndSelfCheck } from '../kernel/turn-selfcheck.js';
+// K10 余项: 恢复一次运行的**编排与政策**也归内核 (漂移上报口径 · 只在漂了/核对不了时装 · 恢复态一定被清)
+import { resumeRunViaKernel } from '../kernel/run-resume.js';
 // 2026-10-01: 身份解析必须**静态导入** —— 之前在函数体里用 require(), 而打包后是 ESM ⇒
 //   require 是 undefined ⇒ 抛错被 catch 静默吞掉 ⇒ "自愈"根本没跑, DID 一直是空的 ✗。
 import { loadOrCreateAgentIdentity } from './agent-identity.js';
@@ -453,7 +460,9 @@ export class PiAgentSession {
      *   · K5 Channel Actor 完成后改为 `createRunContext({ runId: request.resumeRunId })`, 届时删除 `currentRunId` 字段本体。
      */
     seedRunContext(extra = {}) {
-        return createRunContext({ runId: this.actor.state.activeRun, ...extra });
+        // **K10 余项**: 合并顺序 (活跃运行打底 · extra 覆盖) 是内核规则 —— 与 `seed-run` 端口共用 `composeRunSeed`
+        //   "活跃运行"这一处读取仍**只在本方法体内** (K2 播种的唯一读点, 有门钉住); 合并顺序由内核给。
+        return createRunContext(composeRunSeed(this.actor.state.activeRun, extra));
     }
     /**
      * **K5 迁移中**: 本会话所属 channel 的 Actor (由 session factory 在创建时绑定)。
@@ -709,7 +718,7 @@ export class PiAgentSession {
             if (this.actor) {
                 const n = await this.actor.hydrateHistory({
                     load: () => this._sessionStore.loadMessages(sessionKey),
-                    filter: (loaded) => this._filterToMessage(loaded),
+                    filter: (loaded) => filterSessionMessages(loaded),
                     maxMessages,
                 });
                 if (n > 0)
@@ -721,7 +730,7 @@ export class PiAgentSession {
                 console.log(`[PiAgent] hydrate: 没有 ${sessionKey} 的历史`);
                 return;
             }
-            const hydrated = this._filterToMessage(loaded).slice(-maxMessages);
+            const hydrated = hydrateSessionMessages(loaded, maxMessages);
             if (hydrated.length > 0) {
                 this.replaceHistory(hydrated);
                 console.log(`[PiAgent] 从 ${sessionKey} 回灌 ${hydrated.length} 条历史`);
@@ -742,20 +751,24 @@ export class PiAgentSession {
      * 公开方法 — claude code / 外部 harness 在每次 prompt 完成后调一下,
      *   即可获得"重启 / 跨进程接续"的语义.
      */
+    /**
+     * **K10 余项**: 取数拍 (Actor 快照, 走邮箱 ⇒ 与 append 串行) 与真写入仍是本类的;
+     *   而「消息 → 持久形态」的**映射规则**与 key 校验搬进内核 (`submitSessionOp` 的 `save-session`)。
+     *   写不进 ⇒ 响亮失败 (`assertSessionOk`), 不静默继续。
+     */
     async saveCurrentSession(key) {
-        // **K5 第 4 步**: 取数拍走 Actor 的快照 (走邮箱 ⇒ 与 append 串行, 不会抓到"边写边读"的半截状态);
-        //   未绑定 actor 的会话走原路径 (行为不变)。
-        const source = this.actor ? await this.actor.historySnapshot() : this.actor.state.messageHistory;
-        const persisted = source.map((m) => ({
-            role: m.role,
-            content: m.content,
-            toolCall: m.toolCall,
-            toolResult: m.toolResult,
-            toolCallId: m.toolCallId,
-            timestamp: Date.now(),
-            source: 'pi-session',
-        }));
-        await this._sessionStore.saveMessages(key, persisted);
+        const out = await submitSessionOp({ op: 'save-session', origin: 'pi-session', key }, this.sessionPorts());
+        assertSessionOk(out);
+    }
+    /** K10 余项: 会话生命周期端口实现 —— I/O 留本类, 规则在内核 (`kernel/session-lifecycle.ts`) */
+    sessionPorts() {
+        return {
+            historySnapshot: () => (this.actor ? this.actor.historySnapshot() : this.actor.state.messageHistory),
+            saveMessages: (key, messages) => this._sessionStore.saveMessages(key, messages),
+            loadMessages: (key) => this._sessionStore.loadMessages(key),
+            // 注意: **故意不提供** `activeRunId` / `newRunContext` —— "活跃运行"的读取必须只有一处 (K2 播种唯一读点, 门钉住),
+            //   本类走的是**同步** `seedRunContext` + 内核的 `composeRunSeed`。异步 `seed-run` 端口留给别的调用方 (其语义由内核门覆盖)。
+        };
     }
     /**
      * 2026-06-30: 从 disk 拉历史覆盖当前 messageHistory.
@@ -773,47 +786,12 @@ export class PiAgentSession {
      * 返回 Message[] 数组 (空数组表示无历史).
      */
     async peekSessionHistory(key, maxMessages = 30) {
-        try {
-            const loaded = await this._sessionStore.loadMessages(key);
-            if (!loaded)
-                return [];
-            return this._filterToMessage(loaded).slice(-maxMessages);
-        }
-        catch {
-            return [];
-        }
-    }
-    /** hydrateMessageHistory 用的过滤逻辑 — 提到外面复用 */
-    _filterToMessage(loaded) {
-        const hydrated = [];
-        const VALID_ROLES = new Set(['user', 'assistant', 'tool', 'system']);
-        for (const m of loaded) {
-            // role 必须合法 (拒绝旧 schema {type:'user'} 没 role 字段的)
-            if (!VALID_ROLES.has(m.role))
-                continue;
-            // 跳过污染消息
-            if (typeof m.content === 'string' && m.content.startsWith('[AI 服务调用失败]'))
-                continue;
-            if (typeof m.content === 'string' && m.content.startsWith('[错误:'))
-                continue;
-            // 注意: '!m.content' 会跳过 content='' 的 tool call 消息 (assistant role + toolCall 字段),
-            //   这种是合法的 (LLM 输出只有 tool call, 没有正文) — 必须保留.
-            //   这里只跳过"无内容 + 也没 tool call/tool result"的废消息.
-            if (!m.content && !m.toolCall && !m.toolResult)
-                continue;
-            // 跳过空 tool role (tool result 占位但没有任何内容)
-            if (m.role === 'tool' && !m.toolResult)
-                continue;
-            hydrated.push({
-                role: m.role,
-                content: m.content ?? '',
-                toolCall: m.toolCall,
-                toolResult: m.toolResult,
-                toolCallId: m.toolCallId,
-            });
-        }
-        return hydrated;
+        // **K10 余项**: 读回过滤/水合规则归内核; 读失败 ⇒ 空数组, 但**原因进内核审计** (不再完全静默)
+        const out = await submitSessionOp({ op: 'peek-history', origin: 'pi-session', key, maxMessages }, this.sessionPorts());
+        return out.ok ? out.result : [];
     }
+    // **K10 余项 (减法)**: 原来的 `_filterToMessage` (合法 role 白名单 · 剔污染消息 · 保留"只有 tool call 无正文"的合法消息)
+    //   已整条搬进内核 `kernel/session-lifecycle.ts` 的 `filterSessionMessages` —— 规则一处一份, 这里不再留副本。
     /** 暴露 store 给测试 / 高级集成用. */
     get sessionStoreInstance() {
         return this._sessionStore;
@@ -1121,7 +1099,14 @@ export class PiAgentSession {
                     return `[初始化未就绪] ${why}\n${hint}`;
                 }
             }
-            catch { /* 门禁自身异常 → 按"不能判定"处理会阻塞一切; 这里只在能读到状态时才拦 */ }
+            catch (err) {
+                // fail-closed: 门禁异常不能绕过初始化，否则会出现"身份未就绪但 Agent 已调用工具"。
+                const why = `初始化门禁读取失败: ${String(err?.message ?? err).slice(0, 240)}`;
+                this.pushHistory({ role: 'user', content: input });
+                this.pushHistory({ role: 'assistant', content: `[初始化未就绪] ${why}\n请运行 bolloon setup status；修复后再重试。` });
+                console.warn(`[PiAgent] 拒绝执行: ${why}`);
+                return `[初始化未就绪] ${why}\n请运行 bolloon setup status；修复后再重试。`;
+            }
         }
         this.minimaxAvailable = this.checkMinimax();
         this.actor.state.channelId = options?.channelId ?? this.actor.state.channelId;
@@ -1286,8 +1271,10 @@ export class PiAgentSession {
                                 .catch(() => { });
                         }
                         catch { /* 落日志失败不影响主流程 */ }
+                        // 2026-10-02 (leo: 「cli 的 UI 需要有渲染过滤」): 这条是**内部运行日志** (复盘过程), 不是用户要看的结论
+                        //   ⇒ 不再进用户可见对话流; 走 console (由 CLI 的渲染过滤只落盘, `--verbose` 下照原样上屏)。
                         try {
-                            this.runCtx.eventSink?.({ type: 'status', content: `📚 复盘: ${m}`, tool: 'system' });
+                            console.log(`📚 复盘: ${m}`);
                         }
                         catch { /* 上屏失败不打断 */ }
                     };
@@ -2088,7 +2075,8 @@ ${await this.renderActivePlansSection()}
      * 而 Supervisor / 控制面要在运行结束后才知道"刚才跑的是哪条 run" (否则会拿旧 run 做决策)。
      */
     getLastRunId() {
-        return this.lastRunId || this.actor.state.activeRun;
+        // K10 余项: 取值优先级 (显式 lastRunId 优先 · 回落活跃运行) 是**内核规则**
+        return pickRunIdForResume(this.lastRunId, this.actor.state.activeRun);
     }
     /**
      * 2026-09-16 (M2): 从 checkpoint 恢复一次运行 —— **不是**重发原 prompt。
@@ -2101,49 +2089,32 @@ ${await this.renderActivePlansSection()}
      * 并把结论放进返回值 (`modelDrift`) 让调用方能上报; 一致时也有一句明确结论。
      * 判断失败 (读不到 Run 等) 不阻塞恢复。
      */
+    /**
+     * **K10 余项**: 编排与政策归内核 (`kernel/run-resume.ts`) —— 这里只做七件事:
+     *   核对漂移 · 准备 · 按需装配 · 落恢复态 · 驱动同一 runId 继续 · 清态 · 日志。
+     *   语义 (漂移上报口径 · 只在漂了/核对不了时装 · 装配失败不阻塞 · 恢复态一定被清) 由内核拥有。
+     */
     async resumeRun(runId) {
-        let modelDrift;
-        let modelApplied;
-        try {
-            const { detectRunConfigDrift } = await import('../llm/model-selection.js');
-            modelDrift = (await detectRunConfigDrift(runId)) || undefined;
-            if (modelDrift?.drifted) {
-                console.warn('[pi-sdk] 恢复时模型配置已偏离 Run 快照:', modelDrift.message);
-            }
-            else if (modelDrift) {
-                console.log('[pi-sdk] 恢复前核对:', modelDrift.message);
-            }
-        }
-        catch { /* 核对本身失败不阻塞恢复 */ }
-        const prep = await prepareResume(runId);
-        if (!prep.ok || !prep.plan)
-            return { ok: false, reason: prep.reason, ...(modelDrift ? { modelDrift } : {}) };
-        // 2026-09-26 (P6 × P7): 恢复一个在跑的 Run, 用的是**它自己那份快照**, 不是盘上现在的全局默认 ——
-        //   否则这次恢复就是"带着漂移继续跑", 之后再存快照会把漂移固化成历史。
-        //   只在"漂了"或"核对不了"时重装 (一致时运行时本来就是对的, 重装是白跑一趟)。
-        //   装配只有一处实现: `applyRunModelConfigToRuntime` → `installRuntime` (这里不自己 initMinimax)。
-        if (modelDrift && (modelDrift.drifted || !modelDrift.verified)) {
-            try {
+        const out = await resumeRunViaKernel(runId, {
+            detectDrift: async (id) => {
+                const { detectRunConfigDrift } = await import('../llm/model-selection.js');
+                return ((await detectRunConfigDrift(id)) || undefined);
+            },
+            prepareResume: (id) => prepareResume(id),
+            applySnapshot: async (snapshot) => {
                 const { applyRunModelConfigToRuntime } = await import('../llm/model-selection.js');
-                modelApplied = await applyRunModelConfigToRuntime(modelDrift.snapshot);
-                console.log(`[pi-sdk] 已按 Run 快照装配运行时: ${modelApplied.provider}/${modelApplied.model} (configHash ${String(modelApplied.configHash).slice(0, 12)})`);
-            }
-            catch (e) {
-                // 装配失败不阻塞恢复 (如实说; 调用方可以从返回值里看出没装成)
-                console.warn('[pi-sdk] 按 Run 快照装配运行时失败, 保持当前运行时:', String(e?.message || e).slice(0, 160));
-            }
-        }
-        this.resumeRunId = runId;
-        this.resumePlan = prep.plan;
-        this.actor.state.goalBinding = prep.plan.goalId || this.actor.state.goalBinding;
-        try {
-            const reply = await this.prompt(buildResumeInstruction(prep.plan), {});
-            return { ok: true, reply, ...(modelDrift ? { modelDrift } : {}), ...(modelApplied ? { modelApplied } : {}) };
-        }
-        finally {
-            this.resumeRunId = '';
-            this.resumePlan = null;
-        }
+                return (await applyRunModelConfigToRuntime(snapshot));
+            },
+            applyPlan: (plan) => {
+                this.resumeRunId = runId;
+                this.resumePlan = plan;
+                this.actor.state.goalBinding = plan.goalId || this.actor.state.goalBinding;
+            },
+            continueRun: (plan) => this.prompt(buildResumeInstruction(plan), {}),
+            clearPlan: () => { this.resumeRunId = ''; this.resumePlan = null; },
+            log: (level, body) => (level === 'warn' ? console.warn('[pi-sdk] ' + body) : console.log('[pi-sdk] ' + body)),
+        });
+        return out;
     }
     /**
      * 2026-10-02 (K7): 把**本会话的 Harness 判定**包成 skill 门, 供 `BollharnessIntegration.setSkillGuard` 注入。
@@ -2198,46 +2169,24 @@ ${await this.renderActivePlansSection()}
      * (`usePivotLoop: true`, `promptWithPivotLoop` 提前 return) ⇒ 这条"系统自检过门"在**生产根本没触发过**。
      * 抽成方法后两条 loop 路径都调它 (一次一轮, 由 `typecheckRanThisTurn` 保证)。
      */
+    /**
+     * **K10 余项**: 编排与政策归内核 (`kernel/turn-selfcheck.ts`) —— 这里只做三件事: 取工具 · 问门 · 上报。
+     *   语义 (该不该跑 · 系统自检也过门 · 被拒不执行且可见 · 失败不影响回合) 由内核拥有, 换入口不必各写一份。
+     *   状态维护 (一轮只跑一次 / 清空本回合触达) 跟内核的 `decided` 走: 与迁移前逐条一致。
+     */
     async runTurnEndTypecheck() {
-        // 2026-10-01: **本回合改过 TS ⇒ 收尾自动类型检查** (一轮一次) —— 复用已有的 tsc_check 工具
-        if (decideTypecheck(this.tsTouchedThisTurn, this.typecheckRanThisTurn)) {
+        const out = await runTurnEndSelfCheck({ touched: this.tsTouchedThisTurn, ranThisTurn: this.typecheckRanThisTurn }, {
+            getTool: (name) => this.tools.get(name),
+            askGate: async (req) => this.piHarness().beforeToolCall({
+                tool: req.tool,
+                args: req.args,
+                ctx: this.harnessCtx(),
+                permissionMode: this.currentPermissionMode,
+            }),
+            emit: (evt) => this.runCtx.eventSink?.({ type: 'status', content: evt.content, tool: 'system' }),
+        });
+        if (out.decided) {
             this.typecheckRanThisTurn = true;
-            try {
-                const tscTool = this.tools.get('tsc_check');
-                if (tscTool?.execute) {
-                    // 2026-10-02 (K7): **系统自检也过门** —— 统一成"任何工具执行都走同一扇 Harness 门"。
-                    //   这里不是模型发起的工具调用 (args 恒空, 是本回合改过 TS 后的收尾自检), 所以**更**不能例外:
-                    //   例外一旦靠"没人知道它绕过"活着, 门就不再是唯一的执行咽喉。
-                    //   语义: 被拒或门抛错 ⇒ **不执行** (fail-closed), 且**可见**地报出来 (拒绝不许静默)。
-                    let tscAllowed = true;
-                    let tscWhy = '';
-                    try {
-                        const d = await this.piHarness().beforeToolCall({
-                            tool: 'tsc_check',
-                            args: {},
-                            ctx: this.harnessCtx(),
-                            permissionMode: this.currentPermissionMode,
-                        });
-                        tscAllowed = d.allow;
-                        tscWhy = d.reason || d.rejectedBy || '';
-                    }
-                    catch (gateErr) {
-                        tscAllowed = false;
-                        tscWhy = `harness-error: ${String(gateErr?.message || gateErr)}`;
-                    }
-                    if (!tscAllowed) {
-                        this.runCtx.eventSink?.({ type: 'status', content: `🔎 类型检查被门拒绝, 未执行: ${tscWhy.slice(0, 120)}`, tool: 'system' });
-                    }
-                    else {
-                        const r = await tscTool.execute({});
-                        const line = formatTypecheckResult(r?.success !== false && !/error TS\d+/.test(String(r?.output || '')), String(r?.output || ''));
-                        this.runCtx.eventSink?.({ type: 'status', content: `🔎 ${line}`, tool: 'system' });
-                    }
-                }
-            }
-            catch (e) {
-                this.runCtx.eventSink?.({ type: 'status', content: `🔎 类型检查没能跑起来: ${String(e?.message || e).slice(0, 100)} (改动已落盘, 记得自己跑一次)`, tool: 'system' });
-            }
             this.tsTouchedThisTurn = [];
         }
     }

package/dist/agents/task-group.js

@@ -384,8 +384,12 @@ export function buildPostMessage(input) {
     }
     return { ok: true, text: [...base, `verdict=${v}`].join(' ') };
 }
-/** 唯一发送出口: 隐私闸 → groupSend。任何路径都不写本地副本 (本地副本 = 假痕迹) */
-export async function sendTrailMessage(groupId, text, from) {
+/**
+ * 2026-10-02: 富字段版 (leo: 「@成员 / 回复某条 / 图片音频 / 建分支」)。
+ *   **text 与 mentions 都过隐私闸** —— @ 的内容可能被写成 DID/地址形态, 一样不许出网。
+ *   附件只带 CID (字节在内容寻址层), CID 本身不是隐私形态。
+ */
+export async function sendTrailMessage(groupId, text, from, rich = {}) {
     const gate = requirePublicText(text);
     if (!gate.ok) {
         return {
@@ -398,10 +402,23 @@ export async function sendTrailMessage(groupId, text, from) {
     if (!g.ok) {
         return { ok: false, sent: false, text, error: `发送者标记命中隐私红线: ${g.violations.map((v) => v.rule).join(', ')}`, violations: g.violations, localFallback: false };
     }
-    const r = await groupSend(groupId, text, from);
+    const mentionList = Array.isArray(rich.mentions) ? rich.mentions.map((x) => String(x ?? '').trim()).filter(Boolean) : [];
+    for (const m of mentionList) {
+        const mg = requirePublicText(m);
+        if (!mg.ok) {
+            return { ok: false, sent: false, text, error: `@ 的内容命中隐私红线, 拒绝发送: ${mg.violations.map((v) => v.rule).join(', ')}`, violations: mg.violations, localFallback: false };
+        }
+    }
+    const r = await groupSend(groupId, text, from, {
+        ...(mentionList.length ? { mentions: mentionList } : {}),
+        ...(rich.replyTo ? { replyTo: rich.replyTo } : {}),
+        ...(rich.attachments?.length ? { attachments: rich.attachments } : {}),
+        ...(rich.branch ? { branch: rich.branch } : {}),
+        ...(rich.kind ? { kind: rich.kind } : {}),
+    });
     if (!r.ok)
         return { ok: false, sent: false, text, error: r.error || '群消息没发出去', localFallback: false };
-    return { ok: true, sent: true, text, localFallback: false };
+    return { ok: true, sent: true, text, ...(r.id ? { id: r.id } : {}), localFallback: false };
 }
 /** 解析一行群消息 (不是本模块发的 / 格式不认识 → null, 不猜) */
 export function parseTrailLine(text) {

package/dist/cli/log-gate.js

@@ -116,6 +116,54 @@ const OPTIONAL_BOOT_TASK = /(?:本地\s*IPNS\s*发布失败|IPNS\s*发布失败[
 //   `[info]` 里的 info 还会被 ANSI 染色 ⇒ 两条都让旧规则漏网, 于是
 //   `2026-09-30T10:22:44.768Z [info]:   结果: ❌ 失败 (30004ms)` 照样上屏 (leo 报过多次)。
 const SDK_DIAG_LINE = /^(?:\[[^\]]*\]\s*)?\d{4}-\d{2}-\d{2}T[\d:.]+Z?\s*\[(?:\x1b\[[0-9;]*m)*(?:info|debug)(?:\x1b\[[0-9;]*m)*\]:/i;
+/**
+ * **对话流渲染过滤** (2026-10-02, leo: 「cli 的 UI 需要有渲染过滤」)。
+ *
+ * 真机污染样本 (用户贴的原文): `⚠ [identity] channel=… · 查到=yes · …` ·
+ *   `[pi-ai timing] total=1143ms …` · `📚 复盘: 开始(换了任务 ⇒ 立刻复盘)` ·
+ *   `✗ [session-note] 已更新: …` · `[PiAgent] reviewFinal …` (含**被截断的 prompt 片段**)。
+ *
+ * 口径与启动期门同一套: **按行首模块标签锚定**, 不做宽泛匹配 (免得吞掉用户内容) ——
+ *   只认实测过的这些内部模块; **带 `⚠/✗` 字样也不例外** (它们是内部诊断, 不是"需人介入")。
+ * 去处: 仍**一字不漏落日志文件**; `BOLLOON_VERBOSE=1` 照原样上屏 ⇒ 诊断能力一点不丢。
+ * 这是把「要不要占屏」和「要不要留痕」分开, 不是把问题藏起来。
+ */
+// 允许标签前有一个**严重度字形** (`⚠ [identity] …` / `✗ [session-note] …` 真机就是这样) —— 只放这几个字形, 不做通配
+const INTERNAL_CHATTER_TAG = /^[ \t]{0,8}[⚠✗✓!·]?[ \t]*\[(?:pi-ai(?:\s+timing)?|identity|session-note|react-harness|DocumentStore|DocumentReceiver|kv-server|loadSkills|v3-manifest|v3-async|supervisor-host|tool-telemetry|runs|abort|broadcast)\b[^\]\n]*\]/i;
+/**
+ * 没有 ASCII 标签、但实测属于内部运行日志的行 (2026-10-02 leo 追加: 「✅ 最终回复 (质量 8.5/10) ·
+ * 🔄 循环 N/10 这类也去掉」)。
+ *
+ * 定位: 这批本来是**发送点自己声明** `internal: true` (见 `reply-hygiene.ts` / pivot loop 的遥测),
+ *   这里是**兜底** —— 历史/未标的同族事件、以及包一层后丢了标记的副本, 也要在同一处收口。
+ *   所以它**只认实测过的具体形状** (不做通配), 且与正向声明共用同一个判据函数。
+ */
+const INTERNAL_CHATTER_LINE = [
+    /^\s*📚\s*复盘[:：]/,
+    /^\s*\[PiAgent\]\s*reviewFinal\b/,
+    /^\s*\[PiAgent\]\s*推理适配器\s*=/,
+    /^\s*[✅✓]\s*(?:检测到)?最终回复/,
+    /^\s*🔄\s*循环\s*\d+\s*[/／]\s*\d+/,
+    /^\s*🔍\s*任务复杂度[:：]/,
+    /^\s*⚙️?\s*动态配置[:：]/,
+    /^\s*⏹️?\s*pivot loop/,
+    /^\s*📋\s*参数/,
+];
+/**
+ * 循环过渡噪音: **行首锚定**, 不算任意子串 —— 老黑名单用的是 `content.includes('继续循环')`,
+ *   那会把像"好的, 继续总结一下"这种正经状态行一起吞掉 (误吞比漏吞更糟, 见本文件头)。
+ *   实测的真身形状: `工具执行完成继续循环` · `继续总结上一段` 这类**以它开头**的推进过程行。
+ */
+const INTERNAL_CHATTER_SUBSTR = [/^\s*工具执行完成\s*继续循环/, /^\s*继续(?:循环|总结)/];
+/** 这一行是不是**内部诊断** (只该进日志, 不该进对话流) */
+export function isInternalChatter(line) {
+    if (!line)
+        return false;
+    const l = String(line).replace(/\x1b\[[0-9;]*m/g, '');
+    return INTERNAL_CHATTER_TAG.test(l)
+        || INTERNAL_CHATTER_LINE.some((re) => re.test(l))
+        || INTERNAL_CHATTER_SUBSTR.some((re) => re.test(l));
+}
 /** 这一行是不是「错误 / 降级 / 需人介入」—— 是则任何模式下都不许被静默 */
 export function carriesHumanSignal(line) {
     if (!line)
@@ -228,7 +276,7 @@ export function installStartupLogGate(opts = {}) {
     const rerouteSignals = mode === 'cli-interactive';
     const writeFile = opts.writeFile !== false;
     const stats = {
-        suppressed: 0, forwarded: 0, signalKept: 0, fileLines: 0, fileError: null,
+        suppressed: 0, forwarded: 0, signalKept: 0, internalSuppressed: 0, fileLines: 0, fileError: null,
     };
     const filtering = !verbose && !disabled;
     // ---- 日志文件 (append; 每 chunk 一次 appendFileSync, 保证进程被强杀也不丢) ----
@@ -351,7 +399,11 @@ export function installStartupLogGate(opts = {}) {
             const toFile = [];
             for (const line of text.split('\n')) {
                 toFile.push(line);
-                if (carriesHumanSignal(line)) {
+                // 2026-10-02: **内部诊断行优先判** —— 只落盘, 一律不进对话流 (即便带 ⚠/✗ 字样也不会被当成"需人介入")
+                if (isInternalChatter(line)) {
+                    stats.internalSuppressed++;
+                }
+                else if (carriesHumanSignal(line)) {
                     // 需人介入的信息必须可见: 交互 CLI 的 stdout 归 Ink, 所以走 stderr
                     stats.signalKept++;
                     origStderr(line + '\n');
@@ -366,9 +418,21 @@ export function installStartupLogGate(opts = {}) {
     function makeConsoleError() {
         return (...args) => {
             const text = formatConsoleArgs(args);
-            writeLines(text.split('\n'));
+            // 2026-10-02: error 里混进的**内部诊断行**同样只落盘 (`✗ [session-note] 已更新: …` 就是这么漏进对话流的);
+            //   真正的错误 (没有内部标签) 照旧一行不吞 —— 文件那份**全留**(留痕), 只有 stderr 这份过渲染过滤。
+            const lines = text.split('\n');
+            const passToScreen = lines.filter((l) => {
+                if (isInternalChatter(l)) {
+                    stats.internalSuppressed++;
+                    return false;
+                }
+                return true;
+            });
+            writeLines(lines);
+            if (passToScreen.length === 0)
+                return;
             stats.forwarded++;
-            origStderr(text + '\n');
+            origStderr(passToScreen.join('\n') + '\n');
         };
     }
     let stopped = false;

package/dist/cli/mention-data.js

@@ -48,7 +48,7 @@ const CLI_COMMANDS = [
     { kind: 'command', label: 'cron', hint: '定时任务', insert: 'cron' },
     { kind: 'command', label: 'dq', hint: '队列 (dequeue)', insert: 'dq' },
     { kind: 'command', label: 'goals', hint: '目标', insert: 'goals' },
-    { kind: 'command', label: 'group', hint: 'OrbitDB 群聊 (new/join/send/log/members)', insert: 'group' },
+    { kind: 'command', label: 'group', hint: 'OrbitDB 群聊 (new/join/send/log/members/invite/kick/link/privacy/status)', insert: 'group' },
     { kind: 'command', label: 'judgments', hint: '判断记录', insert: 'judgments' },
     { kind: 'command', label: 'net', hint: 'Agent 网络 (join/status/ctx)', insert: 'net' },
     { kind: 'command', label: 'p2p', hint: 'P2P 节点 / 连接', insert: 'p2p' },