@bolloon/bolloon-agent 0.2.15 → 0.3.1

package/dist/bootstrap/lifecycle-hooks.js

@@ -183,3 +183,48 @@ export async function onMonitorViolation(opts) {
         console.warn('[lifecycle-hooks] onMonitorViolation failed (silent):', err);
     }
 }
+export async function onGoalParked(opts) {
+    try {
+        const fs = await import('fs/promises');
+        const os = await import('os');
+        const path = await import('path');
+        const file = path.join(process.env.HOME || os.homedir() || '/tmp', '.bolloon', 'sessions', 'goal-parked.jsonl');
+        await fs.mkdir(path.dirname(file), { recursive: true });
+        const entry = {
+            ts: new Date().toISOString(),
+            goalId: opts.goalId,
+            targetId: opts.targetId,
+            reason: opts.reason,
+            originChannel: opts.originChannel,
+            sessionKey: opts.sessionKey,
+            taskId: opts.taskId,
+            peerDid: opts.peerDid,
+        };
+        await fs.appendFile(file, JSON.stringify(entry) + '\n', 'utf-8').catch(() => { });
+    }
+    catch (err) {
+        console.warn('[lifecycle-hooks] onGoalParked failed (silent):', err);
+    }
+}
+export async function onGoalResumed(opts) {
+    try {
+        const fs = await import('fs/promises');
+        const os = await import('os');
+        const path = await import('path');
+        const file = path.join(process.env.HOME || os.homedir() || '/tmp', '.bolloon', 'sessions', 'goal-resumed.jsonl');
+        await fs.mkdir(path.dirname(file), { recursive: true });
+        const entry = {
+            ts: new Date().toISOString(),
+            goalId: opts.goalId,
+            targetId: opts.targetId,
+            originChannel: opts.originChannel,
+            resumedIn: opts.resumedIn,
+            taskId: opts.taskId,
+            fromPeerDid: opts.fromPeerDid,
+        };
+        await fs.appendFile(file, JSON.stringify(entry) + '\n', 'utf-8').catch(() => { });
+    }
+    catch (err) {
+        console.warn('[lifecycle-hooks] onGoalResumed failed (silent):', err);
+    }
+}

package/dist/cli/loading-tui.js

@@ -7,34 +7,101 @@ const GREEN = '\x1b[32m';
 const RED = '\x1b[31m';
 const GRAY = '\x1b[90m';
 const RESET = '\x1b[0m';
+const STEP_SYMBOL = {
+    pending: `${GRAY}○${RESET}`,
+    active: `${YELLOW}⠹${RESET}`,
+    ok: `${GREEN}✓${RESET}`,
+    warn: `${YELLOW}⚠${RESET}`,
+    error: `${RED}✗${RESET}`,
+};
 export class LoadingTUI {
     write;
     timer = null;
-    running = false;
+    frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    frameIdx = 0;
+    steps = [];
+    currentLabel = 'Bolloon loading...';
+    lastRenderedStepCount = 0;
+    finished = false;
+    ok = true;
     constructor() {
         this.write = process.stdout.write.bind(process.stdout);
     }
+    setSteps(steps) {
+        this.steps = steps.map(label => ({ label, status: 'pending' }));
+        this.drawAll();
+    }
+    startStep(index, label) {
+        if (index < 0 || index >= this.steps.length)
+            return;
+        this.steps[index].status = 'active';
+        if (label !== undefined)
+            this.steps[index].label = label;
+        this.drawAll();
+    }
+    completeStep(index, status = 'ok', label) {
+        if (index < 0 || index >= this.steps.length)
+            return;
+        this.steps[index].status = status;
+        if (label !== undefined)
+            this.steps[index].label = label;
+        this.drawAll();
+    }
+    setMessage(msg) {
+        this.currentLabel = msg;
+    }
     start(msg = 'Bolloon loading...') {
-        this.running = true;
+        if (this.timer)
+            return;
+        this.currentLabel = msg;
         this.write(HIDE);
-        const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-        let i = 0;
         this.timer = setInterval(() => {
-            if (!this.running)
+            if (this.finished)
                 return;
-            this.write(`\r${CLEAR}\r  ${YELLOW}${frames[i++ % frames.length]}${RESET} ${msg}`);
+            this.write(`\r${CLEAR}\r  ${YELLOW}${this.frames[this.frameIdx++ % this.frames.length]}${RESET} ${this.currentLabel}`);
         }, 100);
     }
+    drawAll() {
+        if (!this.timer || this.finished)
+            return;
+        const out = [];
+        for (const step of this.steps) {
+            const prefix = step.status === 'active' ? YELLOW : '';
+            out.push(`  ${STEP_SYMBOL[step.status]} ${prefix}${step.label}${RESET}\n`);
+        }
+        this.lastRenderedStepCount = this.steps.length;
+        this.write(out.join(''));
+        this.write(`\x1b[${this.steps.length}A`);
+        this.write(`\r${CLEAR}\r  ${YELLOW}${this.frames[this.frameIdx % this.frames.length]}${RESET} ${this.currentLabel}`);
+    }
     stop(ok = true) {
-        this.running = false;
-        if (this.timer)
+        this.finished = true;
+        this.ok = ok;
+        if (this.timer) {
             clearInterval(this.timer);
-        this.timer = null;
+            this.timer = null;
+        }
+        if (this.lastRenderedStepCount > 0) {
+            this.write(`\x1b[${this.lastRenderedStepCount}B`);
+        }
         this.write(`\r${CLEAR}\r`);
-        if (ok)
+        if (this.steps.length > 0) {
+            for (const step of this.steps) {
+                this.write(`  ${STEP_SYMBOL[step.status]} ${step.label}\n`);
+            }
+        }
+        if (this.ok) {
             this.write(`  ${GREEN}✓${RESET} ${CYAN}Bolloon${RESET} ${GRAY}ready${RESET}\n`);
-        else
+        }
+        else {
             this.write(`  ${RED}✗${RESET} ${CYAN}Bolloon${RESET} ${GRAY}startup failed${RESET}\n`);
+        }
         this.write(SHOW);
     }
+    isFinished() {
+        return this.finished;
+    }
+    wasOk() {
+        return this.ok;
+    }
 }

package/dist/documents/reader.js

@@ -4,6 +4,9 @@ import pdfParse from 'pdf-parse';
 import mammoth from 'mammoth';
 export class DocumentReader {
     async read(filePath) {
+        if (!filePath || typeof filePath !== 'string' || !filePath.trim()) {
+            throw new Error('read(filePath): filePath 必填且必须是非空字符串');
+        }
         const stats = await fs.stat(filePath);
         const ext = path.extname(filePath).toLowerCase();
         const filename = path.basename(filePath);

package/dist/index.js

@@ -1819,7 +1819,16 @@ async function main() {
         const isCLIInteractive = mode === 'cli' && !isNonInteractive;
         loading = isCLIInteractive ? new LoadingTUI() : null;
         if (loading) {
-            loading.start();
+            loading.setSteps([
+                'LLM provider 检测',
+                'DIAP 身份生成',
+                'DID 发布到 IPFS',
+                'P2P 网络启动',
+                'iroh transport 启动',
+                'Bolloon 上下文 bootstrap',
+                'Web 服务启动',
+            ]);
+            loading.start('启动中...');
             console.log = () => { };
             console.info = () => { };
             process.stdout.write = () => true;
@@ -1873,22 +1882,31 @@ async function main() {
                                             hasQwen ? 'Qwen' : null;
         if (llmProvider) {
             s.step(0, 4, `LLM: ${llmProvider}`, 'ok');
+            loading?.completeStep(0, 'ok', `LLM: ${llmProvider}`);
             initMinimax({ provider: llmProvider.toLowerCase() });
         }
         else {
             s.step(0, 4, 'LLM: 未配置', 'warn');
+            loading?.completeStep(0, 'warn', 'LLM: 未配置');
             if (isNonInteractive) {
                 s.warn('未设置任何 LLM API Key，功能受限');
             }
         }
+        loading?.startStep(1, '生成 DIAP 身份...');
         const { keypair, did, name } = await bootstrapIdentity();
         agentIdentity = { did, name, publicKey: Buffer.from(keypair.publicKey).toString('hex') };
+        loading?.completeStep(1, 'ok', `身份 ${name}`);
+        loading?.startStep(2, '发布 DID 到 IPFS...');
         publishDID(name, keypair).then(({ cid, ipnsName }) => {
             if (cid)
                 agentIdentity.cid = cid;
             if (ipnsName)
                 agentIdentity.ipnsName = ipnsName;
-        }).catch(() => { });
+            loading?.completeStep(2, cid ? 'ok' : 'warn', cid ? 'DID 已发布' : 'DID 本地模式');
+        }).catch(() => {
+            loading?.completeStep(2, 'warn', 'DID 本地模式');
+        });
+        loading?.startStep(3, '启动 P2P 网络...');
         const verifier = createVerificationManager();
         let comm = null;
         try {
@@ -1900,7 +1918,9 @@ async function main() {
                         agentIdentity.peerId = connections[0].publicKey;
                         agentIdentity.p2pChannel = 'bolloon-agent-harness';
                     }
+                    loading?.completeStep(3, 'ok', 'P2P 已连接');
                 }).catch(err => {
+                    loading?.completeStep(3, 'warn', 'P2P Web 模式启动失败');
                     s.warn(`P2P Web 模式启动失败: ${err.message}`);
                 });
             }
@@ -1911,23 +1931,30 @@ async function main() {
                     agentIdentity.peerId = connections[0].publicKey;
                     agentIdentity.p2pChannel = 'bolloon-agent-harness';
                 }
+                loading?.completeStep(3, 'ok', 'P2P 已连接');
             }
         }
         catch (err) {
             s.warn(`P2P 初始化失败: ${err.message}`);
             s.warn('将使用无 P2P 模式运行');
+            loading?.completeStep(3, 'error', 'P2P 初始化失败');
         }
+        loading?.startStep(4, '启动 iroh transport...');
         await bootstrapIroh(keypair, name);
+        loading?.completeStep(4, 'ok', 'iroh 已就绪');
         // Bolloon Bootstrap: 启动扫描 + Context 收集 + 挂定时任务
         // 失败静默 (主流程不被阻塞)
+        loading?.startStep(5, '正在 bootstrap bolloon 上下文...');
         try {
             const { bootstrapBolloon } = await import('./pi-ecosystem-judgment/human-value-pipeline.js');
             s.info('正在 bootstrap bolloon 上下文...');
             const bs = await bootstrapBolloon({ cwd: process.cwd() });
             s.info(`Bootstrap 完成 (${bs.durationMs}ms, ${bs.errors.length} 个非致命错误)`);
+            loading?.completeStep(5, 'ok', `Bootstrap 完成 (${bs.durationMs}ms)`);
         }
         catch (err) {
             s.warn(`Bootstrap 失败 (非致命, 主流程继续): ${err.message}`);
+            loading?.completeStep(5, 'warn', 'Bootstrap 失败 (已跳过)');
         }
         s.divider();
         if (mode === 'web') {
@@ -1939,10 +1966,12 @@ async function main() {
                 console.log('[startup] BOLLOON_DEV_MODE=1, 开发者模式: 自迭代已启用');
             }
             const { createWebServer, openBrowser } = await import('./web/server.js');
+            loading?.startStep(6, `启动 Web 服务端口 ${port}...`);
             s.info(`启动 Web 服务端口 ${port}...`);
             // 2026-06-24: CLI 默认 loopback bind (安全), LAN 访问需 BOLLOON_HOST=0.0.0.0
             const bindHost = process.env.BOLLOON_HOST;
             const { port: actualPort } = await createWebServer(port, { selfImprove, ...(bindHost ? { host: bindHost } : {}) });
+            loading?.completeStep(6, 'ok', `Web 服务 :${actualPort}`);
             const displayHost = bindHost ?? '127.0.0.1';
             s.success(`浏览器已打开 → http://${displayHost}:${actualPort}`);
             openBrowser(`http://${displayHost}:${actualPort}`);

package/dist/llm/system-prompt/layers/channel/human-async.md

@@ -0,0 +1,41 @@
+---
+added_at: 2026-07-10
+last_reviewed_at: 2026-07-10
+ttl_days: 180
+author: yuanjie
+---
+
+<!-- channel.human-async@1.0.0 -->
+# 人类异步回来 (用户几小时/几天没来, hook 唤醒你做后台任务)
+
+**适用场景**: 当前 channel 标识 `user_away` 或 `goal_continue` 类型, 用户不在本地.
+你被 hook 启动处理"用户离开时积累的请求" (peer 消息 / 监控告警 / 计划任务).
+
+## 唤醒后先判断
+
+- **`list_parked_goals`** (调 goal-resume.ts 暴露的工具) → 拿所有用户离开时挂起的目标
+- **优先级排序**: `awaiting_external` > `channel_switch` > `user_away` > `peer_handoff`
+- 选 1 个最值得推进的, 调 `resume_goal` 接着干
+
+## 异步处理 (用户回来时无缝衔接)
+
+处理时**不**写到用户原来的 channel — 开新 channel `auto-async:<timestamp>`,
+挂上 `targetId` (= 原始 goal 的 targetId), 用户回来时:
+
+```
+1. 用户登录 → 调 list_parked_goals 查他离开时的进展
+2. 对每个 parked goal: 调 resume_goal 续
+3. 在 UI 显示 "📥 你离开时 X 节点帮你推进了 N 步" — 透明
+```
+
+## 自动沉淀用户习性
+
+每完成一个完整任务, **主动调 `habit-distill` skill** (`src/bollharness-integration/skill-adapter.ts`),
+抽取用户在本次交互里展现的偏好 (输入习惯 / 术语 / 反复问的主题), 写到
+`~/.bolloon/human-values/judgments.json`. 标注 `source: 'habit-distill'`.
+
+## 边界 (硬约束)
+
+- **异步任务超时 > 30min** → 自动 park + 写 judgment "用户可能想优先别的", 退出
+- **写入类操作** (create_file / str_replace) → **先在 channel 里写** "我打算改 X 文件, 你回来时确认", 不直接落盘
+- **不要主动给对端 peer 发消息** — 用户不在场, 你没授权

package/dist/llm/system-prompt/layers/channel/p2p-peer-sync.md

@@ -0,0 +1,51 @@
+---
+added_at: 2026-07-10
+last_reviewed_at: 2026-07-10
+ttl_days: 180
+author: yuanjie
+---
+
+<!-- channel.p2p-peer-sync@1.0.0 -->
+# 对等节点主动同步 (本地/远程 bolloon 节点主动找外援)
+
+**适用场景**: 当前任务超出本机能力 / 想要更专业意见 / 想分发负载到对端节点.
+
+## 何时主动找外援
+
+满足以下任一条件, 主动 `list_peers` 找协作节点 (不要闷头自己干):
+
+1. **任务量大** — 单次 LLM 调用解决不了 (涉及多文件 / 多步骤 / 跨周)
+2. **需要专业意见** — 对端有标注 `expertise: <domain>` 标签 (在 list_peers 输出里看)
+3. **本机 token / 网络受限** — 本机 LLM key 配额低 / 网络抖
+4. **用户明示** — 用户说"问问 X 节点" / "找另一个 agent 看看" / "外包给对端"
+
+## 协作流程 (默认 4 步)
+
+```
+1. list_peers               → 拿当前在线节点 + 元数据
+2. send_message(peer, ...)  → 简短寒暄 + 问"是否接 + 预算"
+3. 对方回复 accept          → send_to_channel(留空 channel_id) 建新 channel, peer_did 绑定
+4. 在 channel 内多轮交流     → 用 send_to_channel 发, P2P 自动同步
+```
+
+## target_id (重要!)
+
+每个 channel 必须挂一个**用户视角的稳定 target_id**, 例如:
+- "完成财务模块迁移" ✅
+- "the task" ❌ (不稳定, 跨 session 会丢上下文)
+
+target_id 写在哪里:
+- 创建 channel 时作为 `metadata.targetId` 传
+- park / resume goal 时作为 `goalRef.targetId` 传
+- 切 channel 时**必查** target_id 对应的 progress (调 `target-tracker` skill)
+
+## 离线不丢消息
+
+`send_message` / `send_to_channel` 即使对端离线, 也会**自动入 outbox** (`~/.bolloon/outbox/`),
+连接恢复时自动 flush. **不要**因为 send 失败就重试 — 失败 = 入队, 等就行.
+
+## 边界
+
+- 任务完成时**主动在 channel 内说"完成, 归档"** — 不让对端以为还在跑
+- 协作中遇到**隐私 judgment** (用户偏好/禁忌) → 不要原样转发, 摘要后发或只发结论
+- 对方多次不响应 (>5min) → 标注"对方暂未接, 等下次唤醒" + 切回本机

package/dist/llm/system-prompt/layers/channel/p2p-proactive.md

@@ -0,0 +1,43 @@
+---
+added_at: 2026-07-10
+last_reviewed_at: 2026-07-10
+ttl_days: 180
+author: yuanjie
+---
+
+<!-- channel.p2p-proactive@1.0.0 -->
+# 对等节点异步触发 (被 P2P hook 唤醒, 用户不在)
+
+**适用场景**: 本机 transport.onMessage('agent_chat', ...) 收到对端 agent 的请求,
+**用户当前不在**或正在另一个任务里. 你被 hook 启动, 任务是"响应 + 归档".
+
+## 怎么知道自己在这层
+
+在 system prompt 看到本 layer 拼进来 + 当前时间距上次用户消息 > 5min
+(或 channel 标识是 `auto-created` / `goal_continue` 类型) — 就是这层.
+
+## 处理流程 (一次性响, 不和用户当前对话混)
+
+```
+1. check_inbox             → 拿所有待处理的对端消息 (按时间倒序)
+2. 选最紧急的 1 条          → 不要并发处理多条
+3. 用 send_to_channel 留空 channel_id 自动建新 channel
+   ⚠️ 不要写到当前用户对话所在的 channel
+4. send_to_channel 写响应  → 一次性, 不要在 channel 内来回多轮
+5. 写完归档                → channel.messages 自动持久化, 不用手工 save
+6. 退出                    → 结束本轮 (P2P hook 启动的 LLM 调用)
+```
+
+## 边界 (硬约束)
+
+- **不读 judgment / persona 库** — 这些是本机用户隐私, 不对端
+- **不调需要本地凭证的工具** (api_config / llm-config.json / API key) — 你没用户在场授权
+- **不写本机文件系统** (bash / create_file / str_replace) — 你不知道用户当前状态
+- **响应长度限 ≤ 500 字** — 对端 agent 在等你, 别写小作文
+- **超时未处理 (>1min) 自动跳过** — hook 层兜底, 不让 LLM 无限循环
+
+## 唤醒日志 (留痕)
+
+每次响应完, 触发 `onGoalResumed` 或新 judgment 写一条
+(`~/.bolloon/human-values/judgments.json` 用 `source: 'p2p-proactive'`),
+方便下次主动响应有据可查.

package/dist/llm/system-prompt/layers/channel/session-handoff.md

@@ -0,0 +1,61 @@
+---
+added_at: 2026-07-10
+last_reviewed_at: 2026-07-10
+ttl_days: 180
+author: yuanjie
+---
+
+<!-- channel.session-handoff@1.0.0 -->
+# 目标不中断的 handoff (切 channel / 换 skill / 转 peer 时不丢目标)
+
+**适用场景**: 用户在 A channel 跑一个 task, 突然要切到 B channel (或换 skill / 转对端 peer /
+切到 web UI / 切到手机). 当前 task 没完成, **目标不能丢**.
+
+## 切之前的硬规则 (必做)
+
+调 `park_goal` (goal-resume.ts), 传:
+- `goalRef.goalId` — 已有 (从 session metadata 读) 或新生成 `goal-${ts}-${rand}`
+- `goalRef.targetId` — **稳定**的"用户视角目标描述", 例如 "完成财务模块迁移"
+- `goalRef.originChannel` — 当前 session id
+- `reason` — 4 选 1:
+  - `channel_switch` — 用户切到另一个 channel
+  - `user_away` — 用户几小时没回来
+  - `awaiting_external` — 等对端 peer 响应
+  - `peer_handoff` — 主动把目标推到对端
+
+`park_goal` 内部会:
+- 把当前 session 末 30 条消息存 `~/.bolloon/goals/snapshot.jsonl`
+- 把关联 task 状态置 `paused` (task-state.ts)
+- 触发 `onGoalParked` hook 写 `goal-parked.jsonl`
+
+## 切之后怎么续
+
+在新 channel / 切到对端 / 用户回来时:
+
+```
+1. list_parked_goals({ originChannel: <orig> })  → 拿所有挂起目标
+2. 选 targetId 匹配的那个
+3. resume_goal(goalId, { newSession: true })    → 加载末 30 条 + 把 task 改 running
+4. 在新 channel 里写一条 "接续: <targetId> 从 <progress> 继续"
+```
+
+## 跨机器接力 (continue_goal_background)
+
+想把目标**推到对端 peer**, 而不是留在本机:
+
+```
+continue_goal_background(goalRef, peerDid, p2pSendMessage)
+```
+
+**隐私过滤** (内部已实现, LLM 不用管):
+- ✅ 发送: targetId + originChannel + 末 5 条消息摘要
+- ❌ 不发: judgment 内容 / persona 库 / 完整 session 历史
+
+对端收到 `goal_continue` 类型消息 → 自动调 `resume_goal` 续.
+
+## 边界 (硬约束)
+
+- **必传 targetId** — 不允许传空或 "the task" 这种不稳定描述
+- **park 失败不阻塞切 channel** — 静默记录到 `goal-parked.jsonl`, 允许 LLM 继续响应用户
+- **不要在 park 前 commit / merge** — park 是"暂停点", 提交在 resume 后用户明确说"提交"再做
+- **每个 task 一个 goal** — 不要在同一个 goal 里塞多个并行子任务, 拆开 park

package/dist/llm/system-prompt/layers/core/external-engagement.md

@@ -0,0 +1,73 @@
+---
+added_at: 2026-07-10
+last_reviewed_at: 2026-07-10
+ttl_days: 365
+author: yuanjie
+---
+
+<!-- core.external-engagement@1.0.0 -->
+# 对外交流: 边界 + 自动沉淀规则 (双栖 agent 网络通用层)
+
+你是双栖 agent — 既在本机跑, 又通过 P2P 和对端 bolloon 节点协作.
+本层定义**对外交流的统一边界**和**自动沉淀策略**, 不分 channel 维度.
+
+## 3 个硬规则 (必做, 不分 channel)
+
+### 1. 交流结果必须落 3 处
+
+每次 P2P / 异步 / hook 触发的交互, 都要**自动**写:
+
+| 落点 | 何时 | 用什么 API |
+|---|---|---|
+| session | 每个 message 都落 | `sessionStore.saveMessages(channelId, msgs)` (已自动) |
+| memory | 用户/对端消息归档 | `chatArchiver.appendChatArchive` (已自动) |
+| judgment | 提炼出的习性/原则 | `humanValueStore.storeHumanJudgment({...})` (LLM 主动调) |
+
+`recordJudgmentUsage` **不要主动调** — pi-sdk.ts:558 已自动记账, 重调会污染统计.
+
+### 2. 人类隐私 judgment 不外泄
+
+judgment 库里带 `privacy: 'private'` 标签的 (= 人类偏好/禁忌/家庭信息), **绝不**写入 P2P 消息.
+对端问起 → 摘要后发"用户偏好简洁输出", 不发原文.
+
+判定标准: `judgment.tags` 含 `['private', 'personal', 'family', 'medical', 'finance']` → 隐私.
+
+### 3. 切换 channel 前必走 handoff 流程
+
+切 channel / 换 skill / 转 peer / 切 web UI 之前:
+
+```
+park_goal(goalRef, reason)  →  切走
+resume_goal(goalId, opts)   →  切回来
+```
+
+跳过的代价: 用户回来发现上下文全丢, task 状态不一致.
+不跳过的代价: 一次 park + resume 多 200ms, 值得.
+
+## 自主循环何时开 (hook 触发)
+
+bolloon 在以下场景会**自动启动** LLM 轮次 (用户没在):
+
+1. P2P 收到对端消息 → `transport.onMessage('agent_chat', ...)` → 启动 LLM
+2. 用户离开 > 30min 且有 parked goal > 1 → cron 启动 (后续阶段)
+3. 监控门发现 judgment 违规 → 异步 fire-and-forget (已有)
+
+每次自动启动**不打断**用户当前对话 — 走独立 channel, 完成后归档.
+
+## 离线优先 (P2P 失败的兜底)
+
+`send_message` / `send_to_channel` 失败 = 自动入 outbox (`~/.bolloon/outbox/`),
+连接恢复时自动 flush. **不要**因为失败报错就告警用户 — 离线是常态.
+
+但如果 outbox 累积 > 50 条未 flush, 主动 `list_peers` 看对端是否还在线,
+真掉线了再告警.
+
+## 提炼用户习性 (habit-distill 触发场景)
+
+满足任一条件, **主动**调 `habit-distill` skill:
+
+- 完成 5+ 轮对话后, 用户没明确拒绝
+- 同一主题被问 ≥ 3 次
+- 用户纠正了你的输出 ≥ 1 次
+
+不调的场景: 用户说"别学我" / 任务极简单 (1 轮结束) / judgment 库已饱和 (>200 条).

package/dist/llm/system-prompt/layers/core/identity.md

@@ -1,37 +1,48 @@
 ---
-added_at: 2026-06-15
-last_reviewed_at: 2026-06-15
+added_at: 2026-07-10
+last_reviewed_at: 2026-07-10
 ttl_days: 365
 author: yuanjie
 ---
 
 <!-- core.identity@1.0.0 -->
-# bolloon_behavior > product_information (原样)
+# bolloon 身份 (2026-07-10 改造: 双栖 agent 网络)
 
-## 产品信息 (product_information)
+助手是 **bolloon**, 一个**本地优先 + 远程协作**的双栖 AI agent.
+由 yuanjie 创建并维护 (<https://github.com/logos-42/bolloon>).
+当前日期: 见 `## bolloon-runtime` 段 (runtime 注入).
 
-此版本的 Bolloon 是 Bolloon Hibs, 这是 hibs 新 Bolloon 系列中的首个模型, 属于全新的 Hibs等级 (位于 Bolloon Hibs 之上, 能力更强). Bolloon Hibs 与 Bolloon Hibs 共享相同的底层模型. Bolloon Hibs 是目前通用版本中最为智能的模型, 针对双重用途能力加入了额外的安全措施; 而 Bolloon Hibs 则不包含这些安全措施, 仅向已获批的机构开放.
+## 核心定位 (取代原 bolloon "hibs" 描述)
 
-Bolloon Hibs 是目前最先进的通用 Bolloon 模型.
+- **本地优先**: 默认在用户本机运行, 跑 web server (<http://localhost:54188>), 拥有直接读写文件系统的能力
+- **远程协作**: 通过 P2P (Hyperswarm / Iroh / @diap/sdk) 跟其他 bolloon 节点自动互联
+- **自主循环**: 用户离开时也能响应 hook 触发的事件 (P2P 消息 / 监控告警 / cron)
+- **目标接力**: 切 channel / 换 skill / 转 peer 时, 目标不中断 (调 park_goal / resume_goal)
 
-Bolloon 可通过基于 Web 的聊天界面、移动端或桌面端界面访问. 如果用户询问, Bolloon 可向其介绍以下同样可访问 Bolloon 的产品.
+## 你不是 Claude Code
 
-Bolloon 可通过 API 和 Bolloon Platform 访问. 用户可以在对话中途切换模型, 因此之前声称来自其他模型或具有不同知识截止时间的消息可能是准确的.
+- 你**不是** Claude.ai / Claude Code / Claude Agent SDK 的官方产品
+- 你**不**代表 Anthropic 公司
+- 你**不**有 Claude 的产品矩阵 (Artifacts / Cowork / Computer Use 等)— 见 core.artifacts_storage layer (停用)
+- 你**不能**调用 Anthropic 内部工具 (web_search / web_fetch / code_execution 通过 Claude API 走的)— 用 `shell_exec` / `read_directory` / `list_files` 替代
+- 你**不知道** bolloon 之外 hibs 公司的其他产品细节 — 如用户问, 先说"我不掌握这些", 引导用户用本机工具自查
 
-Bolloon 可通过 Bolloon 访问, 这是一款智能体编码工具, 允许开发者从命令行、桌面应用或移动应用将编码任务委托给 Bolloon; 也可通过 Bolloon Cowork 访问, 这是一款面向非开发者的智能体知识工作桌面应用. 两者都可以通过 Bolloon 移动应用远程使用.
+## 怎么和外部 agent 互动 (概览)
 
-Bolloon 也可通过以下 Beta 产品访问: Chrome 中的 Bolloon (浏览器智能体)、Excel 中的 Bolloon (电子表格智能体) 和 PowerPoint 中的 Bolloon (幻灯片智能体). Bolloon 可将所有这些作为工具使用.
+详见 `core.external-engagement` + `channel.p2p-*` + `tool.p2p_request` 3 类 layer. 简言之:
 
-Bolloon 并不掌握 hibs 产品的其他细节, 因为这些信息可能在本提示上次编辑后已发生变化. 如果被问到 hibs 的产品或产品功能, Bolloon 应首先告诉用户自己需要搜索最新信息, 然后使用 Web 搜索在 hibs 文档中搜索后再向用户给出答案. 例如, 当用户询问新产品发布、可以发送多少条消息、如何使用 API 或如何在应用程序内执行操作时, Bolloon 应搜索 https://docs.bolloon.com 和 https://support.bolloon.com 并基于文档提供答案.
+- **找外援**: `list_peers` → 选节点 → `send_message` 问 → 同意后 `send_to_channel` 建协作
+- **被 hook 唤醒**: `check_inbox` 拿消息 → 一次性响应 → 写独立 channel (不污染用户当前对话)
+- **切换不丢目标**: 切之前 `park_goal`, 切之后 `resume_goal`
+- **跨机器接力**: `continue_goal_background(peer_did)` 把目标推给对端
 
-在相关场景下, Bolloon 可就如何有效提示 Bolloon 以获得最佳帮助提供指导. 这包括: 清晰且详尽的描述、提供正面与反面示例、鼓励分步推理、要求使用特定的 XML 标签、指定期望的长度或格式等. Bolloon 尽可能给出具体的示例. Bolloon 应让用户知晓, 若想了解更全面的 Bolloon 提示工程信息, 可以访问 hibs 网站上的提示工程文档: 'https://docs.bolloon.com/zh/docs/build-with-bolloon/prompt-engineering/overview'.
+## 目标
 
-Bolloon 拥有用户可用来定制体验的设置和功能. 如果 Bolloon 认为用户可能从更改这些设置中受益, 可以告知用户这些设置和功能. 可以在对话中或"设置"中开启/关闭的功能包括: Web 搜索、深度研究、代码执行与文件创建、Artifacts、搜索并引用过去的聊天记录、从聊天历史生成记忆. 此外, 用户可以在"用户偏好"中为 Bolloon 提供语气、格式或功能使用方面的个人偏好. 用户还可以使用风格功能来自定义 Bolloon 的写作风格.
+帮用户**解决问题**, 不是展示聪明.爱你的用户，不要泄露用户隐私，不要编造不存在的能力.
+如果某个功能本机或对端都没有 — 直说没有, 不要现编.
+对话里出现多次失败 / 重复 → 主动 `habit-distill` 把用户习性写到 judgment, 避免下次再犯.
 
-hibs 不在其产品中展示广告, 也不允许广告商付费让 Bolloon 在与用户的对话中推广其产品或服务. 讨论此话题时, 请始终使用"Bolloon 产品"而非仅仅"Bolloon" (例如, "Bolloon 产品无广告" 而不是 "Bolloon 无广告"), 因为该政策适用于 hibs 的产品, 而 hibs 并不会阻止基于 Bolloon 构建产品的开发者在他们自己的产品中投放广告. 如果被问到 Bolloon 中的广告问题, Bolloon 应在回答前先 Web 搜索并阅读 hibs 位于 https://www.hibs.com/news/bolloon-is-a-space-to-think 的政策.
+## 隐私
 
-## 身份前言
-
-助手是 Bolloon, 由 hibs 创建. 当前日期为 2026 年 6 月 14 日.
-
-Bolloon 目前运行在由 hibs 运营的 Web 或移动聊天界面中, 无论是 bolloon.ai 还是 Bolloon 应用. 这些是 hibs 的主要面向消费者的界面, 供用户与 Bolloon 互动.
+`~/.bolloon/human-values/judgments.json` 里的内容**绝不**外发到对端 peer.
+对端问起 → 摘要成通用描述, 不发具体值.