@bolloon/bolloon-agent 0.1.34 → 0.1.35

package/.auto-evolve-calls

@@ -0,0 +1 @@
+2026-06-14:6

package/.last-auto-evolve-baseline

@@ -0,0 +1 @@
+auto-evolve-baseline-20260614T110128Z

package/Bolloon.md

@@ -0,0 +1,103 @@
+# Bolloon
+
+> 一个本地优先的 P2P AI 智能体网络。每台机器运行一个 bolloon，自动积累人类判断力，跨机器互联互通。
+
+## 架构总览
+
+```
++------------------- 单台 bolloon 进程 -------------------+
+|                                                        |
+|  Web Server (port 54188) ← 用户聊天 / 配置 / 调试     |
+|       ↓                                                |
+|  Pi Agent (LLM 推理, 注入门, 监控门)                 |
+|       ↓                                                |
+|  Judgment System (判断力库 + 类 B 自适应)              |
+|       ↓                                                |
+|  P2P Network (跨机器互联, v3 + P2PDirect 双轨)         |
+|                                                        |
++--------------------------------------------------------+
+              ↕ P2P (跨机器, 端到端加密)
+       [其它 bolloon 节点]
+```
+
+**核心循环**：人类聊天 → 注入门检索相关判断力 → LLM 推理 → AI 回复 → 监控门审计 → 行为记录到 usage.jsonl → 类 B 自适应扫描 → 演化日志。
+
+## 目录结构
+
+| 路径 | 职责 |
+|---|---|
+| `src/agents/pi-sdk.ts` | PiAgent 主类 / ReAct 循环 / 工具注册 / SessionStart/Stop hook 接入点 |
+| `src/pi-ecosystem-judgment/` | **判断力系统核心**：注入门 / 蒸馏 / 演化 / 自适应扫描 / 监控门 |
+| `src/web/server.ts` | Web server 主入口 (port 54188), 所有 REST API |
+| `src/web/client.js` | 前端 (timeline panel, 反向引用链接, 自适应 tab) |
+| `src/network/` | P2P 网络层 (iroh-bootstrap, p2p-direct) |
+| `src/constraint-runtime/` | Workflow / 技能注册 / 会话持久化 |
+| `src/social/` | 全局共享上下文 / 智能体心跳 / 协作任务 |
+| `src/bootstrap/` | **本轮新增** — 启动上下文收集 / SessionStart/Stop/cron 入口 |
+| `~/.bolloon/` | 用户数据目录 (本机资产, 不进 git) |
+
+## 关键设计意图
+
+### 判断力库 = 本机资产 (跨机器不同步)
+
+每台 bolloon 维护自己的判断力库 `~/.bolloon/human-values/judgments.json`。
+**不**通过 P2P 广播 / 同步——这是原则。判断力沉淀人类偏好，是私有的。
+跨机器共享只通过 P2P RPC 临时调用，**判断力本身不流出去**。
+
+### 注入门 vs D 触发 vs 监控门 (3 道独立门)
+
+| 门 | 触发时机 | 行为 | 写什么 |
+|---|---|---|---|
+| 注入门 (P0) | 每次 LLM chat 之前 | 检索相关判断力拼到 system prompt | `usage.jsonl` |
+| D 触发 (D 路径) | AI 回复后 5min 节流 + async | 自动捕获新判断力 (蒸馏对话) | `judgments.json` |
+| 监控门 (P3) | AI 回复后 fire-and-forget | 审计 AI 是否违反已注入原则 | `violations.jsonl` |
+
+3 道门都**静默失败**——任何 1 道挂掉不影响主对话。
+
+### 类 B 自适应扫描"只读不写"
+
+每天 0:00 定时跑 `runAdaptiveScan()`，扫 `usage.jsonl` + `judgments.json`，
+输出建议 (rising / stale / unused)，**不**自动改库。
+用户在 UI "📊 自适应" tab 接受/拒绝，所有动作写 `evolution.jsonl` 留痕。
+**可逆**是核心设计——AI 不能"自己改自己"。
+
+### 反向引用链接 + timeline panel
+
+AI 回复下方挂极简 `📎 参考 N 条原则` 链接（不展开内嵌）。
+整个运行过程显示在 `loop-timeline-panel`（Claude Code 风格），按时间追加 phase / token / tool 事件。
+
+## 运行约定
+
+| 命令 | 用途 |
+|---|---|
+| `npm run dev` | 启动 web server (http://localhost:54188) |
+| `npm run start` | 同上但生产模式 |
+| `npm test` | 跑 vitest |
+| `npm run typecheck` | tsc --noEmit |
+
+数据存 `~/.bolloon/`：
+- `human-values/judgments.json` — 判断力库
+- `human-values/usage.jsonl` — 注入门使用记录
+- `human-values/violations.jsonl` — 监控门违规记录
+- `human-values/evolution.jsonl` — 类 B 自适应演化日志
+- `persona.json` — 主人身份
+- `sessions/<channel>/` — 每个 channel 的会话持久化
+- `skills/` — 用户级 skills (与 .bolloon/skills/ 项目级并存)
+
+## 开发约定 (不要随意改)
+
+1. **v3 P2P + P2PDirect 双轨**——v3 是新协议，P2PDirect 是 fallback。两套都活着
+2. **判断力库是本机资产**——绝对不同步、不广播
+3. **类 B 不自动改库**——所有 AI 自动调整走 UI 接受 + evolution.jsonl 留痕
+4. **任何 hook 静默失败**——主对话不能因为 hook 挂掉而卡住
+5. **新模块加到 `src/pi-ecosystem-judgment/`**——这是判断力系统的归宿，别散落
+6. **前端 DOM 改完要 dist/web 重新构建**（如果有 build step）
+
+## 已知边界
+
+- **类 B 自适应**每天 0:00 跑 1 次，重启 bolloon 期间不补跑
+- **Context 缓存 24h**——中途改 Bolloon.md / persona / git commit 后, 重启才生效
+- **PreToolUse hook 还没接**——agent 仍能调 `rm -rf`（已有 shell-guard 基础, hook 形式未接）
+- **Stop hook 写 session 摘要**——不重复写完整 session 持久化（已存在）
+- **跨 channel Context**——目前不分 channel, 单 channel 维度
+- **embedding 检索**——上轮做了软相似度 (bigram) 兜底, 真 embedding 等 5k+ 条库再做

package/dist/agents/pi-sdk.js

@@ -20,6 +20,15 @@ import { DiscoveredAgentsManager, createSocialHeartbeat } from '../social/heartb
 import { getGlobalSharedContext } from '../social/global-shared-context.js';
 import { Session, SkillRegistry, saveSession, loadSession } from '@bolloon/constraint-runtime';
 import { loadSkillsFromPaths, defaultSkillPaths, describeSkill } from './skill-loader.js';
+// Judgment 注入门 (P0): 在主对话 LLM 调起前自动拼入 Top 3 判断力
+// 失败静默, 不阻塞主对话
+import { injectJudgmentGate, recordJudgmentUsage } from '../pi-ecosystem-judgment/injection-gate.js';
+// 持续监控门 (P3): AI 回复后审计是否违反原则
+import { monitorAfterReply } from '../pi-ecosystem-judgment/monitor-gate.js';
+// Bootstrap 生命周期 hook (SessionStart / Stop / PreToolUse)
+import { onSessionStart, onStop, onPreToolUse } from '../pi-ecosystem-judgment/human-value-pipeline.js';
+// React Harness: 8-gate + 4-guard (防越权 / 防 prompt 注入)
+import { ReactHarness } from '../security/react-harness.js';
 const SHARED_SESSION_PATH = path.join(process.env.HOME || '/tmp', '.bolloon', 'sessions');
 const PERSONA_PATH = path.join(process.env.HOME || '/tmp', '.bolloon', 'persona.json');
 export class PiSessionManager {
@@ -341,8 +350,61 @@ class PiAgentSession {
     coordinator = new AgentCoordinator(3);
     harness = null;
     harnessEnabled = false;
+    /** 8-gate + 4-guard 集中调度 (防越权 / 防 prompt 注入) */
+    reactHarness = new ReactHarness();
     usePivotLoop = false;
     pivotLoopConfig;
+    /**
+     * Judgment 注入门临时结果: 在 prompt / promptStream / promptWithPivotLoop 入口算一次, 拼到本轮 systemPrompt 末尾
+     * 每次调用都会重置 (避免上一轮遗留)
+     */
+    judgmentGateAddition = '';
+    judgmentGateUsedIds = [];
+    /**
+     * 当前 onStream 引用 + abort signal (computeJudgmentGate 需要 onStream 广播 phase)
+     * 每次 prompt / promptStream / promptWithPivotLoop 入口设置, 用完即清
+     */
+    currentOnStream = null;
+    currentSignal = null;
+    /** Bootstrap SessionStart 拼的 system prompt 片段 (用完即清) */
+    bootstrapAddition = '';
+    /** 当前 prompt 开始时间 (供 Stop hook 计算 durationMs) */
+    promptStartTime = 0;
+    /** 当前 channel id (由 getAgentForChannel / prompt 4 参注入, 供 hook / log 使用) */
+    currentChannelId = '';
+    /**
+     * 算 judgment 注入门: 失败静默, 不阻塞主对话
+     * 期间通过 currentOnStream 广播 phase 事件, 前端可显示 "正在检索判断力..." 状态
+     * 调用方负责用完即清 (judgmentGateAddition='')
+     */
+    async computeJudgmentGate(input) {
+        const safePhase = (phase, extra = {}) => {
+            try {
+                if (this.currentOnStream) {
+                    this.currentOnStream({ type: 'phase', phase, ...extra, content: '' });
+                }
+            }
+            catch { /* 静默 */ }
+        };
+        safePhase('gate_compute', { detail: '正在检索相关判断力...' });
+        try {
+            const gate = await injectJudgmentGate(input);
+            this.judgmentGateAddition = gate.systemAddition;
+            this.judgmentGateUsedIds = gate.usedIds;
+            if (gate.usedIds.length > 0) {
+                safePhase('gate_done', { usedCount: gate.usedIds.length });
+            }
+        }
+        catch (err) {
+            console.warn('[PiAgent] judgment gate failed (non-fatal):', err);
+            this.judgmentGateAddition = '';
+            this.judgmentGateUsedIds = [];
+        }
+    }
+    clearJudgmentGate() {
+        this.judgmentGateAddition = '';
+        this.judgmentGateUsedIds = [];
+    }
     constructor(config) {
         this.cwd = config.cwd;
         this.peerId = config.peerId || 'local';
@@ -428,10 +490,14 @@ class PiAgentSession {
             const { createBollharnessIntegration } = await import('../bollharness-integration/index.js');
             this.harness = createBollharnessIntegration();
             this.harnessEnabled = true;
+            // ReactHarness 已用 bollharness, 这里也记一份以供 archive 调用
+            this.reactHarness = new ReactHarness({ harnessEnabled: true, gateEnabled: true });
         }
         catch (e) {
             console.warn('[PiAgentSession] Harness initialization failed:', e);
             this.harnessEnabled = false;
+            // 失败 fallback: 走纯 8-gate (不带 bollharness 的 8-gate 工作流)
+            this.reactHarness = new ReactHarness({ harnessEnabled: false, gateEnabled: true });
         }
     }
     registerTools() {
@@ -767,8 +833,9 @@ class PiAgentSession {
             return false;
         }
     }
-    async prompt(input) {
+    async prompt(input, options) {
         this.minimaxAvailable = this.checkMinimax();
+        this.currentChannelId = options?.channelId ?? this.currentChannelId;
         this.messageHistory.push({
             role: 'user',
             content: input
@@ -778,10 +845,25 @@ class PiAgentSession {
             this.messageHistory.push({ role: 'assistant', content: response });
             return response;
         }
-        return this.runReActLoop();
+        // P0 注入门
+        this.currentSignal = options?.signal ?? null;
+        this.currentOnStream = options?.onStream ?? null;
+        await this.computeJudgmentGate(input);
+        try {
+            return await this.runReActLoop(undefined, options?.signal);
+        }
+        finally {
+            if (this.judgmentGateUsedIds.length > 0) {
+                recordJudgmentUsage(this.judgmentGateUsedIds, { userInput: input }).catch((err) => console.warn('[PiAgent] recordJudgmentUsage failed:', err));
+            }
+            this.clearJudgmentGate();
+            this.currentSignal = null;
+            this.currentOnStream = null;
+        }
     }
-    async promptStream(input, onStream) {
+    async promptStream(input, onStream, signal, channelId) {
         this.minimaxAvailable = this.checkMinimax();
+        this.currentChannelId = channelId ?? this.currentChannelId;
         this.messageHistory.push({
             role: 'user',
             content: input
@@ -793,11 +875,61 @@ class PiAgentSession {
             onStream({ type: 'done', content: '' });
             return response;
         }
-        const result = await this.runReActLoop(onStream);
+        // P0 注入门: 缓存 onStream + signal, computeJudgmentGate 用 currentOnStream 广播 phase
+        this.currentOnStream = onStream;
+        this.currentSignal = signal ?? null;
+        await this.computeJudgmentGate(input);
+        // Bootstrap SessionStart: 收集项目 Context, 拼到 systemAddition 头部
+        // (失败静默, 5s 限流防止循环)
+        let bootstrapAddition = '';
+        try {
+            const ss = await onSessionStart({ channelId: this.currentChannelId || undefined });
+            bootstrapAddition = ss.systemAddition || '';
+        }
+        catch (err) {
+            console.warn('[PiAgent] onSessionStart failed (non-fatal):', err);
+        }
+        this.bootstrapAddition = bootstrapAddition;
+        this.promptStartTime = Date.now();
+        let result;
+        try {
+            result = await this.runReActLoop(onStream, signal);
+        }
+        catch (err) {
+            // abort 失败: 视作"已中断", 抛错让上层用 partial 兜底
+            this.currentOnStream = null;
+            this.currentSignal = null;
+            throw err;
+        }
         onStream({ type: 'done', content: '' });
+        // 回溯: 异步记录 usage (不等)
+        if (this.judgmentGateUsedIds.length > 0) {
+            recordJudgmentUsage(this.judgmentGateUsedIds, { userInput: input }).catch((err) => console.warn('[PiAgent] recordJudgmentUsage failed:', err));
+            // P0.5: 把 usedIds 通过 stream 事件回传给调用方 (server.ts 写到 session message)
+            try {
+                onStream({ type: 'used_judgments', usedIds: this.judgmentGateUsedIds, content: '' });
+            }
+            catch { }
+        }
+        // P3 监控门: fire-and-forget 审计 AI 回复是否违反原则
+        monitorAfterReply(input, result);
+        // Bootstrap Stop hook: fire-and-forget 写本次 session 摘要
+        const stopStartTime = this.promptStartTime || Date.now();
+        onStop({
+            channelId: this.currentChannelId || 'unknown',
+            durationMs: Date.now() - stopStartTime,
+            usedJudgmentIds: [...this.judgmentGateUsedIds],
+        }).catch((err) => console.warn('[PiAgent] onStop failed:', err));
+        // 用完即清, 避免污染下一轮
+        this.clearJudgmentGate();
+        this.currentOnStream = null;
+        this.currentSignal = null;
+        this.bootstrapAddition = '';
+        this.promptStartTime = 0;
         return result;
     }
-    async promptWithPivotLoop(input, config) {
+    async promptWithPivotLoop(input, config, channelId) {
+        this.currentChannelId = channelId ?? this.currentChannelId;
         if (!this.minimaxAvailable) {
             const response = await this.handleFallback(input);
             return {
@@ -824,12 +956,14 @@ class PiAgentSession {
         for (const tool of this.tools.values()) {
             loop.registerTool(tool);
         }
+        // P0 注入门: 在构造 systemPrompt 之前算一次, 拼到末尾
+        await this.computeJudgmentGate(input);
         const personaSection = this.persona ? `
 角色描述: ${this.persona.description || '无'}
 性格特点: ${this.persona.personality || '无'}
 问候语: ${this.persona.greeting || '无'}
 ` : '';
-        const systemPrompt = `你是 ${this.identity.name}，基于ReAct (Reasoning + Acting)模式工作。${personaSection}
+        const systemPrompt = `${this.bootstrapAddition}你是 ${this.identity.name}，基于ReAct (Reasoning + Acting)模式工作。${personaSection}
 当前工作目录: ${this.cwd}
 当前身份: ${this.identity.name} (${this.identity.did})
 
@@ -846,15 +980,20 @@ ${this.getToolDefinitions()}
 - 每次只调用一个工具
 - 仔细分析工具返回结果
 - 当任务完成时，必须在回答末尾添加 <final gen> 标记表示结束
-- 如果需要更多信息，继续调用工具`;
+- 如果需要更多信息，继续调用工具${this.judgmentGateAddition}`;
         const result = await loop.execute(input, llm, systemPrompt);
         this.messageHistory.push({ role: 'user', content: input });
         if (result.response) {
             this.messageHistory.push({ role: 'assistant', content: result.response });
         }
+        // 回溯 + 清场
+        if (this.judgmentGateUsedIds.length > 0) {
+            recordJudgmentUsage(this.judgmentGateUsedIds, { userInput: input }).catch((err) => console.warn('[PiAgent] recordJudgmentUsage failed:', err));
+        }
+        this.clearJudgmentGate();
         return result;
     }
-    async runReActLoop(onStream) {
+    async runReActLoop(onStream, signal) {
         const llm = getMinimax();
         let iteration = 0;
         let finalResponse = '';
@@ -869,6 +1008,14 @@ ${this.getToolDefinitions()}
         if (onStream) {
             onStream({ type: 'status', content: '🔄 开始 ReAct 循环...', tool: 'system' });
         }
+        // React Harness: 循环开始 (重置 turn 计数 + 触发 harness sessionStart)
+        // 失败静默 (fail-open), 不阻塞主循环
+        try {
+            await this.reactHarness.onSessionStart(this.currentChannelId || undefined);
+        }
+        catch (err) {
+            console.warn('[PiAgent] reactHarness.onSessionStart failed (non-fatal):', err);
+        }
         while (iteration < this.MAX_REACT_ITERATIONS) {
             iteration++;
             // 调试日志：显示每次循环开始
@@ -892,7 +1039,7 @@ ${this.getToolDefinitions()}
 性格特点: ${this.persona.personality || '无'}
 问候语: ${this.persona.greeting || '无'}
 ` : '';
-            const systemPrompt = `你是 ${this.identity.name}，基于ReAct (Reasoning + Acting)模式工作。${personaSection}
+            const systemPrompt = `${this.bootstrapAddition}你是 ${this.identity.name}，基于ReAct (Reasoning + Acting)模式工作。${personaSection}
 当前工作目录: ${this.cwd}
 当前身份: ${this.identity.name} (${this.identity.did})
 ${refineContext}
@@ -910,8 +1057,8 @@ ${toolDefs}
 - 每次只调用一个工具
 - 仔细分析工具返回结果
 - 当任务完成时，必须在回答末尾添加 <final gen> 标记表示结束
-- 如果需要更多信息，继续调用工具`;
-            const response = await llm.chat(context, systemPrompt);
+- 如果需要更多信息，继续调用工具${this.judgmentGateAddition}`;
+            const response = await llm.chat(context, systemPrompt, signal);
             const reply = response.reply.trim();
             console.log(`[PiAgent] LLM 回复长度: ${reply.length}, 内容预览: "${reply.substring(0, 80)}..."`);
             console.log(`[PiAgent] LLM 完整回复:\n${reply}`);
@@ -954,9 +1101,104 @@ ${toolDefs}
                     console.warn(`[PiAgent] 未知工具: ${toolCall.name}，跳过并继续`);
                     continue;
                 }
+                // Bootstrap PreToolUse hook: 调工具前校验 (危险命令拦截)
+                // 失败静默 — hook 自身挂掉 = 放行
+                let toolToExecute = tool;
+                try {
+                    const pre = await onPreToolUse({ tool: toolCall.name, args: toolCall.args || {} });
+                    if (!pre.allowed) {
+                        const deniedResult = {
+                            success: false,
+                            error: `PreToolUse 拒绝: ${pre.reason || '未通过安全校验'}`,
+                        };
+                        this.messageHistory.push({
+                            role: 'tool',
+                            content: JSON.stringify(deniedResult),
+                            toolResult: deniedResult,
+                        });
+                        this.logToHarness(toolCall.name, toolCall.args, deniedResult);
+                        if (onStream) {
+                            onStream({
+                                type: 'error',
+                                content: `🛡️ PreToolUse 拒绝 ${toolCall.name}: ${pre.reason || '安全校验失败'}`,
+                                tool: toolCall.name,
+                            });
+                        }
+                        console.warn(`[PiAgent] PreToolUse denied ${toolCall.name}: ${pre.reason}`);
+                        // 不调 tool.execute, 也不计 consecutiveErrors (这是用户级拒绝, 不是工具错)
+                        continue;
+                    }
+                }
+                catch (err) {
+                    console.warn('[PiAgent] onPreToolUse failed (non-fatal, allowing):', err);
+                }
+                // React Harness: 8-gate + builtin-guards 校验 (在 PreToolUse 之后, 串接双层)
+                // 失败静默, 拒绝时不调 tool.execute
+                try {
+                    const pre = await this.reactHarness.preToolCall(toolCall.name, toolCall.args || {}, this.currentChannelId || undefined);
+                    if (!pre.allowed) {
+                        const deniedResult = {
+                            success: false,
+                            error: `Harness gate 拒绝 (${pre.details.rejectedBy}): ${pre.reason || '未通过安全校验'}`,
+                        };
+                        this.messageHistory.push({
+                            role: 'tool',
+                            content: JSON.stringify(deniedResult),
+                            toolResult: deniedResult,
+                        });
+                        this.logToHarness(toolCall.name, toolCall.args, deniedResult);
+                        if (onStream) {
+                            onStream({
+                                type: 'error',
+                                content: `🛡️ Harness ${pre.details.rejectedBy} 拒绝 ${toolCall.name}: ${pre.reason || '安全校验失败'}`,
+                                tool: toolCall.name,
+                            });
+                        }
+                        console.warn(`[PiAgent] Harness denied ${toolCall.name} (${pre.details.rejectedBy}): ${pre.reason}`);
+                        continue;
+                    }
+                }
+                catch (err) {
+                    console.warn('[PiAgent] reactHarness.preToolCall failed (non-fatal, allowing):', err);
+                }
                 try {
-                    const result = await tool.execute(toolCall.args);
+                    let result = await tool.execute(toolCall.args);
                     console.log(`[PiAgent] 工具 ${toolCall.name} 执行完成: success=${result.success}`);
+                    // Context router: 拿最近一次 preToolCall 算的 hint, 拼到 tool result messageHistory
+                    // (LLM 下次看到 tool result 时, 能"记得"这次调用的安全约束)
+                    const routeHint = this.reactHarness.getLastRouteHint();
+                    if (routeHint && routeHint.systemAddition) {
+                        this.messageHistory.push({
+                            role: 'system',
+                            content: `[Harness Router Hint: ${routeHint.reason}]\n${routeHint.systemAddition}`,
+                        });
+                        this.reactHarness.clearRouteHint();
+                    }
+                    // React Harness: post-tool call (output 审计: secret leak 等)
+                    // 拒绝时 result.output 含敏感 → 替换为 generic message, 不污染 messageHistory
+                    try {
+                        const post = await this.reactHarness.postToolCall(toolCall.name, String(result.output || ''), this.currentChannelId || undefined);
+                        if (!post.allowed) {
+                            if (onStream) {
+                                onStream({
+                                    type: 'error',
+                                    content: `🛡️ Harness output 拒绝 ${toolCall.name}: ${post.reason || '输出含敏感信息'}`,
+                                    tool: toolCall.name,
+                                });
+                            }
+                            console.warn(`[PiAgent] Harness output denied ${toolCall.name}: ${post.reason}`);
+                            // 替换 result: success 仍保留 (tool 本身没错), 但 output 改成 generic
+                            // 这样 LLM 下轮看 output 不会拿到秘密, 但 success 标志让它知道 "工具执行了"
+                            result = {
+                                ...result,
+                                output: `[harness output gate: output 含敏感内容, 已屏蔽. 原因: ${post.reason || 'unknown'}]`,
+                                _harnessDenied: true,
+                            };
+                        }
+                    }
+                    catch (err) {
+                        console.warn('[PiAgent] reactHarness.postToolCall failed (non-fatal, allowing):', err);
+                    }
                     this.messageHistory.push({ role: 'tool', content: JSON.stringify(result), toolResult: result });
                     this.logToHarness(toolCall.name, toolCall.args, result);
                     // 通知前端工具执行结果
@@ -1092,6 +1334,13 @@ Workspace root folder: ${this.cwd}
 `;
         finalResponse = identityPrefix + finalResponse;
         this.messageHistory.push({ role: 'assistant', content: finalResponse });
+        // React Harness: 循环结束
+        try {
+            await this.reactHarness.onSessionEnd();
+        }
+        catch (err) {
+            console.warn('[PiAgent] reactHarness.onSessionEnd failed (non-fatal):', err);
+        }
         return finalResponse;
     }
     async deepThink(prompt) {
@@ -1561,6 +1810,9 @@ ${this.extractOperationsFromRef(operationsRef)}
     updateIdentity(updates) {
         this.identity = { ...this.identity, ...updates };
     }
+    setCurrentChannelId(channelId) {
+        this.currentChannelId = channelId;
+    }
     getSessionState() {
         return this.sessionManager.getState();
     }

package/dist/bootstrap/bootstrap.js

@@ -0,0 +1,114 @@
+/**
+ * Bolloon Bootstrap — 启动入口
+ *
+ * web server 启动时 (或 CLI 模式) 调一次, 完成 3 件事:
+ * 1. 跑类 B 自适应扫描 (暖缓存 + 写 evolution.jsonl 启动事件)
+ * 2. 收集项目 Context (Bolloon.md / git / persona / judgments / skills)
+ * 3. 挂每天 0:00 定时任务
+ *
+ * 失败静默: 任意步骤失败 console.warn, 不抛错 (主流程不被阻塞)
+ */
+import { runAdaptiveScan, logEvolution } from '../pi-ecosystem-judgment/adaptive-scan.js';
+import { collectBolloonContext } from './context-collector.js';
+/**
+ * 入口: web server / CLI 启动时调一次
+ */
+export async function bootstrapBolloon(opts = {}) {
+    const start = Date.now();
+    const errors = [];
+    // 1. 类 B 启动扫描
+    let scanResult = {
+        scannedAt: new Date().toISOString(),
+        judgmentsTotal: 0,
+        usageEntriesScanned: 0,
+        suggestions: [],
+    };
+    try {
+        scanResult = await runAdaptiveScan();
+        await logEvolution({
+            ts: new Date().toISOString(),
+            action: 'accept', // 用 accept 表示"系统记录" (跟 reject 区分)
+            suggestion: {
+                key: 'bootstrap-startup',
+                kind: 'unused', // 占位
+                judgmentId: '__bootstrap__',
+                decision: 'Bolloon 启动扫描',
+                reason: `本次启动扫描了 ${scanResult.judgmentsTotal} 条原则, ${scanResult.usageEntriesScanned} 条使用记录, 生成 ${scanResult.suggestions.length} 条建议`,
+                action: 'review',
+                metrics: { usage7d: 0, usage30d: 0, daysSinceLastUse: 0, totalUsage: 0 },
+                scannedAt: scanResult.scannedAt,
+            },
+        });
+        console.log(`[bootstrap] 类 B 启动扫描完成: ${scanResult.suggestions.length} 条建议`);
+    }
+    catch (err) {
+        errors.push(`scan: ${err.message}`);
+        console.warn('[bootstrap] 启动扫描失败 (非致命):', err);
+    }
+    // 2. 收集项目 Context
+    let context = {
+        projectRoot: opts.cwd ?? process.cwd(),
+        projectName: 'unknown',
+        bolloonMd: null,
+        git: null,
+        persona: null,
+        judgmentsSummary: { total: 0, active: 0, superseded: 0, rejected: 0, topValues: [] },
+        skills: [],
+        env: { os: 'unknown', nodeVersion: 'unknown', llmProvider: 'unknown' },
+        pending: { goals: [], todos: [] },
+        collectedAt: new Date().toISOString(),
+    };
+    try {
+        context = await collectBolloonContext({ cwd: opts.cwd ?? process.cwd() });
+        console.log(`[bootstrap] context 收集完成: ${context.judgmentsSummary.total} judgments, ${context.skills.length} skills`);
+    }
+    catch (err) {
+        errors.push(`context: ${err.message}`);
+        console.warn('[bootstrap] context 收集失败 (非致命):', err);
+    }
+    // 3. 挂定时任务 (每天 0:00 跑扫描, server 重启时丢失可接受)
+    try {
+        scheduleAdaptiveScanDaily();
+        console.log('[bootstrap] 定时任务已挂: 每天 0:00 跑类 B 扫描');
+    }
+    catch (err) {
+        errors.push(`schedule: ${err.message}`);
+        console.warn('[bootstrap] 定时任务挂载失败 (非致命):', err);
+    }
+    const durationMs = Date.now() - start;
+    console.log(`[bootstrap] 完成 (${durationMs}ms, ${errors.length} 个错误)`);
+    return { context, scanResult, durationMs, errors };
+}
+// ============================================================
+// 定时任务: 每天 0:00 跑类 B 自适应扫描
+// ============================================================
+let scheduled = false;
+function scheduleAdaptiveScanDaily() {
+    if (scheduled)
+        return;
+    scheduled = true;
+    const now = new Date();
+    const next = new Date(now);
+    next.setHours(24, 0, 0, 0);
+    const msUntilMidnight = next.getTime() - now.getTime();
+    // 第一次: 等到明天 0:00
+    setTimeout(() => {
+        runAdaptiveScan().then((result) => {
+            console.log(`[bootstrap] 定时扫描完成: ${result.suggestions.length} 条建议`);
+        }).catch((err) => {
+            console.warn('[bootstrap] 定时扫描失败:', err);
+        });
+        // 之后: 每 24h
+        setInterval(() => {
+            runAdaptiveScan().then((result) => {
+                console.log(`[bootstrap] 定时扫描完成: ${result.suggestions.length} 条建议`);
+            }).catch((err) => {
+                console.warn('[bootstrap] 定时扫描失败:', err);
+            });
+        }, 24 * 60 * 60 * 1000);
+    }, msUntilMidnight);
+}
+/** 测试辅助: 重置 scheduled 标志 */
+export function _resetScheduleForTest() {
+    scheduled = false;
+}