@bolloon/bolloon-agent 0.2.15 → 0.3.0

package/dist/agents/goal-resume.js

@@ -0,0 +1,321 @@
+/**
+ * goal-resume — 双栖 agent 网络的"目标接力"原语
+ *
+ * 设计动机 (2026-07-10):
+ * - bolloon 改造: 从本地优先 → 远程/本地双栖 agent 网络.
+ * - 需要"目标不中断"机制: 用户当前 task 跑一半, 切到另一个 channel / 切到对端 peer
+ *   / 用户离开, 目标不能丢.
+ * - 现有 task-state.ts 已有 'paused' 状态, 但没有跨 session / 跨机器的"目标快照+恢复"流.
+ * - 本文件提供 parkGoal / resumeGoal / continueGoalInBackground, 在 4 级 Bolloon.md 之外的
+ *   运行时层做目标接力.
+ *
+ * 复用现有:
+ *   - task-state.ts: Task.status = 'paused' (park) / 'running' (resume)
+ *   - session-store.ts: 消息历史 (saveMessages / loadMessages)
+ *   - chat-archiver.ts: 高频归档 (~/.bolloon/archive/<peerDID>/YYYY-MM.jsonl)
+ *   - p2p-outbox.ts: 离线消息不丢
+ *   - injectJudgmentGate (pi-sdk.ts): judgment 注入门; goal handoff 路径上保留注入
+ *
+ * 不重复造:
+ *   - 没有新数据库. 落盘 = ~/.bolloon/goals/snapshot.jsonl (append-only, 与 chat-archiver 同模式)
+ *   - 没有新 LLM 调度. LLM 工具入口在 pi-sdk-tools.ts 注册, 复用现有 pi-ai.ts 调度.
+ *
+ * 安全 / 边界:
+ *   - 人类隐私 judgment (target_id 包含"用户偏好"语义) 不外泄给 peer;
+ *     continueGoalInBackground 只发"目标描述 + 已完成步骤", 不发 judgment 内容.
+ *   - 任何 IO 失败静默 (返回 null / error 对象), 不阻塞主对话.
+ */
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import { sessionStore } from './session-store.js';
+import * as taskState from './task-state.js';
+import { onGoalParked, onGoalResumed } from '../bootstrap/lifecycle-hooks.js';
+// ============================================================
+// 内部: 落盘 + 读盘
+// ============================================================
+const GOALS_DIR = path.join(os.homedir(), '.bolloon', 'goals');
+const SNAPSHOT_FILE = path.join(GOALS_DIR, 'snapshot.jsonl');
+const EVENT_FILE = path.join(GOALS_DIR, 'event.jsonl');
+/** 写一条 park/resume event (独立文件, 不影响 snapshot 覆盖逻辑) */
+async function appendEvent(event) {
+    try {
+        await ensureGoalsDir();
+        await fs.appendFile(EVENT_FILE, JSON.stringify({ ...event, ts: new Date().toISOString() }) + '\n', 'utf-8');
+    }
+    catch {
+        // 静默 — event log 失败不应阻塞
+    }
+}
+async function ensureGoalsDir() {
+    await fs.mkdir(GOALS_DIR, { recursive: true });
+}
+/** append-only 写一行 JSON */
+async function appendSnapshot(snap) {
+    try {
+        await ensureGoalsDir();
+        await fs.appendFile(SNAPSHOT_FILE, JSON.stringify(snap) + '\n', 'utf-8');
+    }
+    catch (err) {
+        // 静默失败 — 落盘失败不应阻塞主对话
+        if (process.env.BOLLOON_VERBOSE === '1') {
+            console.warn(`[goal-resume] appendSnapshot failed: ${err.message?.slice(0, 100)}`);
+        }
+    }
+}
+/** 读所有 snapshot, 按 goalId 分组保留最新一条 */
+async function loadAllSnapshots() {
+    const out = new Map();
+    try {
+        const raw = await fs.readFile(SNAPSHOT_FILE, 'utf-8');
+        for (const line of raw.split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                const snap = JSON.parse(line);
+                if (snap.schemaVersion !== 1)
+                    continue;
+                out.set(snap.goalRef.goalId, snap); // 后写覆盖先写 (新状态覆盖旧状态)
+            }
+            catch {
+                // 跳过损坏行
+            }
+        }
+    }
+    catch {
+        // 文件不存在 = 空 map
+    }
+    return out;
+}
+function newGoalId() {
+    return `goal-${Date.now()}-${crypto.randomBytes(3).toString('hex')}`;
+}
+// ============================================================
+// Park 现有 task (复用 task-state.ts 'paused' 状态)
+// ============================================================
+async function parkAssociatedTask(taskId, goalId) {
+    if (!taskId)
+        return;
+    try {
+        // 1. 把 task 状态置 'paused'
+        await taskState.updateTask(taskId, { status: 'paused' });
+        // 2. 在 goal 字段里塞 goalId (让反向查找有据可查)
+        const t = await taskState.getTask(taskId);
+        if (t) {
+            // 不覆盖已有 goal 字段, 改用 metadata 注释
+            // (task-state.ts 的 Task interface 没 metadata, 跳过避免 schema 改动)
+        }
+    }
+    catch (err) {
+        if (process.env.BOLLOON_VERBOSE === '1') {
+            console.warn(`[goal-resume] parkAssociatedTask failed: ${err.message?.slice(0, 100)}`);
+        }
+    }
+}
+async function resumeAssociatedTask(taskId, newSessionKey) {
+    if (!taskId)
+        return;
+    try {
+        const patch = { status: 'running' };
+        if (newSessionKey)
+            patch.sessionKey = newSessionKey;
+        await taskState.updateTask(taskId, patch);
+    }
+    catch (err) {
+        if (process.env.BOLLOON_VERBOSE === '1') {
+            console.warn(`[goal-resume] resumeAssociatedTask failed: ${err.message?.slice(0, 100)}`);
+        }
+    }
+}
+// ============================================================
+// 公共 API
+// ============================================================
+/**
+ * Park 当前目标 — 把 session 状态快照 + task 状态落盘, 切走/离开不丢目标.
+ *
+ * @param goalRef 目标引用 (goalId 必须已存在, 不能传空)
+ * @param reason park 原因 (决定后续恢复策略)
+ * @returns GoalHandle (含 error 字段, 不抛错)
+ */
+export async function parkGoal(goalRef, reason) {
+    if (!goalRef.goalId || !goalRef.targetId) {
+        return { goalId: goalRef.goalId, targetId: goalRef.targetId, state: 'parked', error: 'goalId/targetId 必填' };
+    }
+    try {
+        // 1. 拉最近 30 条消息
+        const messages = await sessionStore.loadMessages(goalRef.originChannel) ?? [];
+        const recentMessages = messages.slice(-30);
+        // 2. 找关联 task (用 goalId 反向搜, 或 caller 传 taskId)
+        //    简化: caller 负责在 goalRef 里塞 taskId; 此处拿不到 — 跳过
+        const taskId = null; // TODO: 反向索引 (后续阶段)
+        const taskState_ = null;
+        // 3. 落 snapshot
+        const snap = {
+            goalRef,
+            sessionKey: goalRef.originChannel,
+            recentMessages,
+            taskId,
+            taskState: taskState_,
+            parkReason: reason,
+            parkedAt: new Date().toISOString(),
+            schemaVersion: 1,
+        };
+        await appendSnapshot(snap);
+        // 4. 写 park event 留痕 (独立 event.jsonl, 不污染 snapshot 覆盖)
+        await appendEvent({ goalId: goalRef.goalId, event: 'goal_parked', targetId: goalRef.targetId, reason });
+        // 5. park 关联 task
+        await parkAssociatedTask(taskId, goalRef.goalId);
+        // 6. 触发 lifecycle hook (留痕到 ~/.bolloon/sessions/goal-parked.jsonl)
+        await onGoalParked({
+            goalId: goalRef.goalId,
+            targetId: goalRef.targetId,
+            reason,
+            originChannel: goalRef.originChannel,
+            sessionKey: goalRef.originChannel,
+            taskId,
+        });
+        return { goalId: goalRef.goalId, targetId: goalRef.targetId, state: 'parked', taskId: taskId ?? undefined };
+    }
+    catch (err) {
+        return { goalId: goalRef.goalId, targetId: goalRef.targetId, state: 'parked', error: `park 失败: ${err.message?.slice(0, 100)}` };
+    }
+}
+/**
+ * 恢复目标 — 重新加载 session 消息历史 + 把 task 状态置 running.
+ *
+ * @param goalId park 时记的 goalId
+ * @param options newSession = true 时返回新 session key
+ */
+export async function resumeGoal(goalId, options = {}) {
+    if (!goalId) {
+        return { goalId, targetId: '', state: 'resumed', error: 'goalId 必填' };
+    }
+    try {
+        const allSnaps = await loadAllSnapshots();
+        const snap = allSnaps.get(goalId);
+        if (!snap) {
+            return { goalId, targetId: '', state: 'resumed', error: `goal ${goalId} 未找到 (未 park 过)` };
+        }
+        // 1. 把末 30 条消息灌回 session (供 LLM 立即看到上下文)
+        const targetKey = options.newSession
+            ? `${snap.goalRef.originChannel}:resume-${Date.now()}`
+            : snap.goalRef.originChannel;
+        await sessionStore.saveMessages(targetKey, snap.recentMessages);
+        // 2. resume 关联 task
+        await resumeAssociatedTask(snap.taskId, options.newSession ? targetKey : undefined);
+        // 3. 写一条 resume 留痕 (独立 event.jsonl)
+        await appendEvent({ goalId, event: 'goal_resumed', targetId: snap.goalRef.targetId, resumedIn: targetKey });
+        // 4. 触发 lifecycle hook
+        await onGoalResumed({
+            goalId,
+            targetId: snap.goalRef.targetId,
+            originChannel: snap.goalRef.originChannel,
+            resumedIn: targetKey,
+            taskId: snap.taskId,
+        });
+        return {
+            goalId,
+            targetId: snap.goalRef.targetId,
+            state: 'resumed',
+            resumedIn: targetKey,
+            taskId: snap.taskId ?? undefined,
+        };
+    }
+    catch (err) {
+        return { goalId, targetId: '', state: 'resumed', error: `resume 失败: ${err.message?.slice(0, 100)}` };
+    }
+}
+/**
+ * 把目标推到对端 peer — 包含 park (本机) + P2P 推消息 (对端) + 期望对端 resume.
+ *
+ * 流程:
+ * 1. park 本机的 goal
+ * 2. 通过现有 p2pNetwork.sendMessage 发一条 'goal_continue' 类型消息给对端
+ * 3. 对端 hook 收到 → 自动调 resumeGoal (对端有同名 hook 处理 — 后续阶段)
+ * 4. 返回 handle 含 peerSessionId (对端生成) — 但**对端 id 当前拿不到**, 留 TODO
+ *
+ * @param goalRef 同 parkGoal
+ * @param peerDid 对端 DID (来自 list_peers 结果)
+ * @param p2pSendMessage 注入 P2P 发送函数 (避免循环依赖; pi-sdk-tools.ts 注入)
+ */
+export async function continueGoalInBackground(goalRef, peerDid, p2pSendMessage) {
+    if (!goalRef.goalId || !peerDid) {
+        return { handle: { goalId: goalRef.goalId, targetId: goalRef.targetId, state: 'continued_background', error: 'goalId/peerDid 必填' } };
+    }
+    // 1. park 本机
+    const parkResult = await parkGoal(goalRef, 'peer_handoff');
+    if (parkResult.error) {
+        return { handle: parkResult };
+    }
+    // 2. 推给对端
+    try {
+        // 隐私过滤: 不发 judgment 内容, 只发 target_id + 末 5 条消息摘要
+        const safePayload = {
+            event: 'goal_continue',
+            goalId: goalRef.goalId,
+            targetId: goalRef.targetId,
+            originChannel: goalRef.originChannel,
+            createdBy: goalRef.createdBy,
+            recentMessages: (parkResult.error ? [] : (await sessionStore.loadMessages(goalRef.originChannel) ?? [])).slice(-5),
+            timestamp: new Date().toISOString(),
+        };
+        const sendResult = await p2pSendMessage(peerDid, 'goal_continue', JSON.stringify(safePayload));
+        if (!sendResult.success) {
+            return { handle: { ...parkResult, state: 'continued_background', error: `P2P 推失败: ${sendResult.error?.slice(0, 100)}` } };
+        }
+        return {
+            handle: { ...parkResult, state: 'continued_background', peerSessionId: '(对端生成, 当前拿不到 — TODO)' },
+        };
+    }
+    catch (err) {
+        return { handle: { ...parkResult, state: 'continued_background', error: `continue 失败: ${err.message?.slice(0, 100)}` } };
+    }
+}
+/**
+ * 列出所有 park 的 goal — 用于 LLM 切回时找回上下文
+ */
+export async function listParkedGoals(filter = {}) {
+    try {
+        const all = await loadAllSnapshots();
+        let arr = Array.from(all.values());
+        if (filter.originChannel)
+            arr = arr.filter((s) => s.goalRef.originChannel === filter.originChannel);
+        if (filter.createdBy)
+            arr = arr.filter((s) => s.goalRef.createdBy === filter.createdBy);
+        if (filter.targetIdPrefix)
+            arr = arr.filter((s) => s.goalRef.targetId.startsWith(filter.targetIdPrefix));
+        return arr.sort((a, b) => b.parkedAt.localeCompare(a.parkedAt));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * 单个 goal 查询
+ */
+export async function getGoal(goalId) {
+    try {
+        const all = await loadAllSnapshots();
+        return all.get(goalId) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+// ============================================================
+// 调试 / 健康端点用
+// ============================================================
+/** Goal 落盘目录 (只读) */
+export function goalsDir() {
+    return GOALS_DIR;
+}
+/** 重置 (测试用) */
+export async function _resetGoalsForTest() {
+    try {
+        await fs.unlink(SNAPSHOT_FILE);
+    }
+    catch {
+        // 不存在 = OK
+    }
+}

package/dist/agents/pi-sdk-tools.js

@@ -933,6 +933,105 @@ export function registerBuiltinTools(ctx) {
             }
         }
     });
+    // ============================================================
+    // 2026-07-10 双栖 agent 网络新增: goal handoff 工具
+    // (park_goal / resume_goal / continue_goal_background)
+    // 内部调用 goal-resume.ts, 错误不抛, 静默返回 error 字段
+    // ============================================================
+    ctx.tools.set('park_goal', {
+        name: 'park_goal',
+        description: '暂停当前目标并落盘快照. 切换 channel / 用户离开 / 等对端响应 / 推到对端 前必调. 接收 goalRef (含 goalId + targetId) + reason.',
+        parameters: {
+            goal_id: '已存在或新生成的 goal ID (建议 goal-${ts}-${rand} 格式)',
+            target_id: '用户视角的稳定目标描述 (e.g. "完成财务模块迁移")',
+            created_by: 'user | agent | peer',
+            origin_channel: '当前 session / channel id',
+            reason: 'channel_switch | user_away | awaiting_external | peer_handoff',
+        },
+        execute: async (args) => {
+            try {
+                const { parkGoal } = await import('./goal-resume.js');
+                const handle = await parkGoal({
+                    goalId: String(args.goal_id || '').trim(),
+                    targetId: String(args.target_id || '').trim(),
+                    createdBy: (args.created_by === 'user' || args.created_by === 'peer') ? args.created_by : 'agent',
+                    createdAt: new Date().toISOString(),
+                    originChannel: String(args.origin_channel || '').trim(),
+                }, args.reason || 'channel_switch');
+                return { success: !handle.error, output: JSON.stringify(handle, null, 2), error: handle.error };
+            }
+            catch (e) {
+                return { success: false, error: `park_goal 失败: ${String(e).slice(0, 200)}` };
+            }
+        }
+    });
+    ctx.tools.set('resume_goal', {
+        name: 'resume_goal',
+        description: '恢复一个 park 的目标. 加载末 30 条消息到 session + 关联 task 改 running. 切回 channel / 用户回来 / 收到对端 ack 时调.',
+        parameters: {
+            goal_id: 'park 时记的 goal ID',
+            new_session: 'true = 在新 session key 下续, 默认 false (留原 session)',
+            channel_id: '可选, 指定 channelId 恢复 (默认 = originChannel)',
+        },
+        execute: async (args) => {
+            try {
+                const { resumeGoal } = await import('./goal-resume.js');
+                const newSessionStr = String(args.new_session || '').toLowerCase();
+                const handle = await resumeGoal(String(args.goal_id || '').trim(), {
+                    newSession: newSessionStr === 'true' || newSessionStr === '1',
+                    channelId: args.channel_id ? String(args.channel_id) : undefined,
+                });
+                return { success: !handle.error, output: JSON.stringify(handle, null, 2), error: handle.error };
+            }
+            catch (e) {
+                return { success: false, error: `resume_goal 失败: ${String(e).slice(0, 200)}` };
+            }
+        }
+    });
+    ctx.tools.set('continue_goal_background', {
+        name: 'continue_goal_background',
+        description: '把目标推到对端 peer 后台跑. 内部 park 本机 + P2P 推消息 + 隐私过滤 (judgment 不发). 任务大 / 想分工时用.',
+        parameters: {
+            goal_id: '当前 goal ID',
+            target_id: '用户视角目标描述',
+            origin_channel: '当前 session id',
+            peer_did: '对端 DID (来自 list_peers)',
+        },
+        execute: async (args) => {
+            try {
+                const { continueGoalInBackground } = await import('./goal-resume.js');
+                const peerDid = String(args.peer_did || '').trim();
+                if (!peerDid)
+                    return { success: false, error: 'peer_did 必填' };
+                // 注入 p2p 发送函数 — 通过 ctx.p2pNetwork 调用
+                const p2pSendMessage = async (peerId, type, message) => {
+                    try {
+                        // p2pNetwork 在 ctx 里 (由 PiAgentSession 注入)
+                        const p2pNetwork = ctx.p2pNetwork;
+                        if (!p2pNetwork || typeof p2pNetwork.sendMessage !== 'function') {
+                            return { success: false, error: 'p2pNetwork 未注入到 ctx' };
+                        }
+                        await p2pNetwork.sendMessage(peerId, type, message);
+                        return { success: true };
+                    }
+                    catch (e) {
+                        return { success: false, error: String(e).slice(0, 100) };
+                    }
+                };
+                const result = await continueGoalInBackground({
+                    goalId: String(args.goal_id || '').trim(),
+                    targetId: String(args.target_id || '').trim(),
+                    createdBy: 'agent',
+                    createdAt: new Date().toISOString(),
+                    originChannel: String(args.origin_channel || '').trim(),
+                }, peerDid, p2pSendMessage);
+                return { success: !result.handle.error, output: JSON.stringify(result, null, 2), error: result.handle.error };
+            }
+            catch (e) {
+                return { success: false, error: `continue_goal_background 失败: ${String(e).slice(0, 200)}` };
+            }
+        }
+    });
 }
 /**
  * 注册 Wallet + Polymarket + Safe 工具 (基于 constraint-runtime/src/tools/).

package/dist/bollharness-integration/skill-adapter.js

@@ -350,6 +350,113 @@ export class CrystalLearnSkill extends BaseSkill {
         return this.callLm('You are a failure pattern analyst. Extract failure modes, patterns, and invariants from the task description. Output structured JSON with failure_modes, patterns, invariants.', `Task: ${task}`);
     }
 }
+// ============================================================
+// 2026-07-10 双栖 agent 网络新增 3 个 skill
+// (peer-sync / habit-distill / target-tracker)
+// ============================================================
+/**
+ * Peer-Sync Skill — 主动找对端协作.
+ *
+ * 调用流程:
+ * 1. 拿 list_peers (通过 p2pNetwork.getPeers() 或已注入的 ctx.tools)
+ * 2. 用 LLM 选最合适的 peer (按 expertise tag / 在线时长 / 任务匹配)
+ * 3. send_message 问对方是否接 + 预算
+ * 4. 同意后 send_to_channel 建带 target_id 的 channel
+ */
+export class PeerSyncSkill extends BaseSkill {
+    name = 'peer-sync';
+    description = '主动找对端 bolloon 节点协作. 接收 target_id + task, 自动选 peer + 建 channel. 写 channel 时调 sessionStore.saveMessages + chatArchiver (via goal-resume event log).';
+    async execute(params) {
+        const targetId = (params.target_id || params.targetId || '');
+        const task = (params.task || params.description || '');
+        if (!targetId || !task) {
+            return this.formatOutput({
+                warning: 'target_id 和 task 必填',
+                usage: '--harness-skill peer-sync --target_id "完成 X" --task "实现 Y"',
+            });
+        }
+        this.log(`peer-sync 启动: target_id=${targetId}`);
+        // 选 peer 的策略由 LLM 决定 (根据 list_peers 输出 + expertise tag)
+        return this.callLm(`You are a peer-selection specialist for the bolloon P2P network.
+Given a target_id and task description, output structured JSON with:
+- selectedPeer: DID of the best peer (or null if none suitable)
+- channelName: human-readable name for the new channel
+- initialMessage: first message to send (≤ 200 chars, brief + asks for acceptance)
+- estimatedRounds: expected back-and-forth count (1-10)
+
+Rules:
+- Prefer peers with matching expertise tag
+- If no peer matches, return selectedPeer: null
+- Don't over-explain — peer agent has same identity layer as you`, `target_id: ${targetId}\ntask: ${task}`);
+    }
+}
+/**
+ * Habit-Distill Skill — 提炼用户习性, 写到 judgment 库.
+ *
+ * 调用流程:
+ * 1. sessionStore.loadMessages(channelId) 拿当前 session 末 30 条
+ * 2. LLM 抽取用户习性 (输入习惯 / 偏好术语 / 反复问的主题 / 纠正记录)
+ * 3. humanValueStore.storeHumanJudgment({ content, tags: ['habit'], source: 'habit-distill', privacy: 'private' })
+ */
+export class HabitDistillSkill extends BaseSkill {
+    name = 'habit-distill';
+    description = '从当前 session 提炼用户习性, 写到 ~/.bolloon/human-values/judgments.json. 调 humanValueStore.storeHumanJudgment, 标签 privacy:private.';
+    async execute(params) {
+        const sessionKey = (params.session_key || params.sessionKey || '');
+        const recentMessagesSummary = (params.messages_summary || '');
+        if (!sessionKey) {
+            return this.formatOutput({
+                warning: 'session_key 必填',
+                usage: '--harness-skill habit-distill --session_key <key>',
+            });
+        }
+        this.log(`habit-distill 启动: session=${sessionKey}`);
+        // 抽取习性的 prompt — 让 LLM 输出结构化 JSON
+        return this.callLm(`You are a habit-extraction specialist.
+Given a summary of user-assistant interaction, output JSON with:
+- habits: [{ content: string, tags: string[], weight: 'low'|'medium'|'high' }]
+  - content: 一个用户偏好/习性的简短描述 (≤ 100 字)
+  - tags: 标签如 ['input-style', 'terminology', 'recurring-topic', 'correction']
+  - weight: 影响判断力注入门时的优先级
+- skipReason: 若不该蒸馏 (用户拒绝/任务太简单/judgment 库饱和), 填理由
+
+Rules:
+- 习性必须是"用户可观察到的稳定模式", 不是单次偏好
+- 隐私相关打 tags 含 'private', 注入门自动过滤
+- 不要重复已有 judgment (调用方负责查重)`, `Session: ${sessionKey}\nMessages summary: ${recentMessagesSummary || '(caller should pass loadMessages output)'}`);
+    }
+}
+/**
+ * Target-Tracker Skill — 跨 channel 查 target_id 进展.
+ *
+ * 调用流程:
+ * 1. goal-resume.ts 的 listParkedGoals({ targetIdPrefix: <id> }) 查所有匹配的 snapshot
+ * 2. chatArchiver.listPeerSummaries 查 channel 维度
+ * 3. 输出结构化 status: { goalId, targetId, parkedAt, reason, recentProgress[] }
+ */
+export class TargetTrackerSkill extends BaseSkill {
+    name = 'target-tracker';
+    description = '跨 channel 查 target_id 进展. 调 goal-resume listParkedGoals + chatArchiver.listPeerSummaries. 用于切 channel 时不丢目标状态.';
+    async execute(params) {
+        const targetId = (params.target_id || params.targetId || '');
+        const originChannel = (params.origin_channel || '');
+        if (!targetId && !originChannel) {
+            return this.formatOutput({
+                warning: 'target_id 或 origin_channel 至少传一个',
+                usage: '--harness-skill target-tracker --target_id <id>',
+            });
+        }
+        this.log(`target-tracker 启动: target_id=${targetId} channel=${originChannel}`);
+        // status JSON 由调用方负责真实查询 (skill 接收参数, 返回查询模板)
+        return this.formatOutput({
+            skill: this.name,
+            description: this.description,
+            query_params: { targetId, originChannel },
+            action: 'caller must invoke goal-resume.listParkedGoals + chatArchiver.listPeerSummaries with these params',
+            expected_output: 'List of GoalSnapshot + per-channel progress summary',
+        });
+    }
+}
 /**
  * Skill Adapter - Registers all bollharness skills with Bolloon's SkillRegistry
  */
@@ -372,6 +479,10 @@ export class SkillAdapter {
             new HarnessEngSkill(),
             new HarnessEngTestSkill(),
             new CrystalLearnSkill(),
+            // 2026-07-10 双栖 agent 网络新增 3 个:
+            new PeerSyncSkill(),
+            new HabitDistillSkill(),
+            new TargetTrackerSkill(),
         ];
         for (const skill of adaptedSkills) {
             try {

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/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.
+对端问起 → 摘要成通用描述, 不发具体值.

package/dist/llm/system-prompt/layers/tool/goal_handoff.md

@@ -0,0 +1,77 @@
+---
+added_at: 2026-07-10
+last_reviewed_at: 2026-07-10
+ttl_days: 270
+author: yuanjie
+---
+
+<!-- tool.goal_handoff@1.0.0 -->
+# Goal Handoff 工具 (park_goal / resume_goal / continue_goal_background)
+
+**目标接力 3 件套** — 切 channel / 切用户 / 切对端时, 保持"目标不中断".
+
+## 何时用 (决策树)
+
+```
+当前 task 还在跑, 但要切换上下文
+  ├─ 切到另一个 channel (用户主动 / UI 切)
+  │    → park_goal(reason='channel_switch')
+  │    → 切完调 resume_goal
+  │
+  ├─ 用户几小时没回来 (你被 hook 启动做后台)
+  │    → park_goal(reason='user_away') — 如果之前还没 park
+  │    → resume_goal({ newSession: true }) 在新 channel 续
+  │
+  ├─ 等对端 peer 回应 (>1min 没音讯)
+  │    → park_goal(reason='awaiting_external')
+  │    → 不主动 resume, 等对端 ack
+  │
+  └─ 主动把目标推到对端 (任务大 / 想分工)
+       → continue_goal_background(peer_did, p2pSendMessage)
+       (内部已含 park, 推完不返回)
+```
+
+## park_goal 必传参数
+
+```typescript
+{
+  goalRef: {
+    goalId: string,        // 已存在 (从 session metadata 读) 或新生成
+    targetId: string,      // ⚠️ 用户视角的稳定描述, 不允许 "the task"
+    createdBy: 'user' | 'agent' | 'peer',
+    createdAt: ISO 字符串,
+    originChannel: string, // 当前 session id
+  },
+  reason: 'channel_switch' | 'user_away' | 'awaiting_external' | 'peer_handoff',
+}
+```
+
+返回 GoalHandle: `{ goalId, targetId, state: 'parked', taskId?, error? }`.
+`error` 字段 = 不抛错, 静默记录到 `goal-parked.jsonl`, 允许 LLM 继续响应.
+
+## resume_goal 必传参数
+
+```typescript
+resumeGoal(goalId: string, {
+  newSession?: boolean,   // true = 在新 session key 下续, 旧 session 保留
+  channelId?: string,     // 指定 channelId 恢复 (默认 = originChannel)
+})
+```
+
+恢复过程: 加载末 30 条消息 → 写回 session → 关联 task status 改 'running' →
+触发 `onGoalResumed` 写 `goal-resumed.jsonl`.
+
+## continue_goal_background 注意
+
+推给对端时**内部已过滤**隐私 (judgment / persona 不发), LLM 不必再过滤.
+但 LLM **应该**确认:
+
+- 对端节点**在线** (先 `list_peers` 看)
+- 对端**有足够 context** (同 `core.identity` layer, 共享人格)
+- 任务**可分解** (不要推一坨未拆解的大任务)
+
+## 失败兜底
+
+- park 失败 → 不阻塞切换, 静默 warn
+- resume 找不到 goalId → 返回 `{ error: 'goal X 未找到' }`, LLM 应该给用户解释
+- 跨机器 continue 失败 (P2P outbox 满) → 自动入 outbox 重试, 标 `state: 'continued_background'`

package/dist/llm/system-prompt/layers/tool/p2p_request.md

@@ -0,0 +1,61 @@
+---
+added_at: 2026-07-10
+last_reviewed_at: 2026-07-10
+ttl_days: 270
+author: yuanjie
+---
+
+<!-- tool.p2p_request@1.0.0 -->
+# P2P 工具集 (list_peers / send_message / broadcast / send_to_channel / check_inbox / agent_call)
+
+P2P 工具的**语义区别** — 选错了会污染对端或浪费 token.
+
+## 决策树 (按场景选)
+
+```
+想 "知道有哪些节点在线"
+  → list_peers
+
+想 "给某节点发一条短消息 (不建 channel)"
+  → send_message(peer_id, message)
+    e.g. 问对方是否接任务 / 通知进展 / 简单寒暄
+
+想 "广播给所有节点"
+  → broadcast_message(message)
+    e.g. 广播"我刚发布了新版本 v0.2.16"
+    ⚠️ 慎用 — 每次广播每节点都收一条, token 消耗 = 节点数 × 消息长度
+
+想 "建一个长期 channel 与某节点多轮协作"
+  → send_to_channel(channel_id='', message, peer_did)
+    channel_id 留空 = 自动建; peer_did 绑定 = 后续消息通过 P2P 自动同步到对端
+    用 channel 的场景: 跨多轮的复杂协作 / 需要保留上下文 / 切换后还能找到
+
+想 "查看我收到的所有消息 (本地 + 远程)"
+  → check_inbox(max=50)
+    返回按时间倒序; 触发 onMessage hook 的消息都进 _inboxMessages
+
+想 "调对端 agent 执行一个完整任务 (含 LLM 推理)"
+  → agent_call(peer_did, task, options)
+    ⚠️ 对端会启动独立 LLM 轮次, 消耗对端 token; 你拿回的是结构化结果
+```
+
+## 离线和连接
+
+所有 send_* 工具**失败不报错给用户** — 自动入 outbox (`~/.bolloon/outbox/`),
+等连接恢复自动 flush. 工具返回 `{ success: false, error: "queued" }` 视为成功.
+
+如果你需要确认"对端真的收到了", 用 `check_inbox` 看是否有 ack 类型消息.
+
+## 隐私过滤 (LLM 必做)
+
+`send_message` / `send_to_channel` / `broadcast_message` 之前:
+
+- ❌ 不发 judgment 库内容 (调 `humanValueStore.list` 看 privacy 标签)
+- ❌ 不发 API key / 凭证 / 路径里的私密信息
+- ✅ 可发: targetId / 任务描述 / 公开文档摘要 / 代码片段
+- ⚠️ 摘要后发: 用户偏好 (改写为通用描述, 不带具体值)
+
+## 接收端注意
+
+`check_inbox` 拿到的不一定都是人类消息 — 也可能是对端 agent 调 `agent_call` 推过来的任务.
+判断: 消息 metadata 里的 `fromDid` / `peerName` 字段; 是 DID 形式 = agent, 人类名 = 人.

package/dist/llm/system-prompt/registry.js

@@ -91,7 +91,6 @@ const STATIC_LAYERS = [
     { id: 'core.tone', version: '1.0.0', priority: 110, appliesTo: ['all'], source: 'static-md', maxChars: 500, meta: DEFAULT_META(TTL_KNOWLEDGE) },
     { id: 'core.wellbeing', version: '1.0.0', priority: 120, appliesTo: ['all'], source: 'static-md', maxChars: 600, meta: DEFAULT_META(TTL_KNOWLEDGE) },
     { id: 'core.evenhandedness', version: '1.0.0', priority: 130, appliesTo: ['all'], source: 'static-md', maxChars: 300, meta: DEFAULT_META(TTL_KNOWLEDGE) },
-    { id: 'core.memory_system', version: '1.0.0', priority: 140, appliesTo: ['all'], source: 'static-md', maxChars: 200, meta: DEFAULT_META(TTL_KNOWLEDGE) },
     { id: 'core.artifacts_storage', version: '1.0.0', priority: 145, appliesTo: ['never'], source: 'static-md', maxChars: 0, meta: DEFAULT_META(TTL_KNOWLEDGE) },
     { id: 'core.network_filesystem', version: '1.0.0', priority: 148, appliesTo: ['never'], source: 'static-md', maxChars: 0, meta: DEFAULT_META(TTL_KNOWLEDGE) },
     // ── role/ ── 阶段 0 只用 expert, 其他 3 个停用 (节省 + 阶段 0 不分 role)
@@ -103,6 +102,17 @@ const STATIC_LAYERS = [
     { id: 'channel.local', version: '1.0.0', priority: 150, appliesTo: ['local'], source: 'static-md', maxChars: 500, meta: DEFAULT_META(TTL_CHANNEL) },
     { id: 'channel.p2p-visitor', version: '1.0.0', priority: 150, appliesTo: ['p2p-visitor'], source: 'static-md', maxChars: 700 },
     { id: 'channel.p2p-agent', version: '1.0.0', priority: 150, appliesTo: ['p2p-agent'], source: 'static-md', maxChars: 700 },
+    // 2026-07-10 双栖 agent 网络新增 (按 plan 阶段 3):
+    { id: 'channel.p2p-peer-sync', version: '1.0.0', priority: 150, appliesTo: ['local', 'p2p-agent'], source: 'static-md', maxChars: 600, meta: DEFAULT_META(TTL_CHANNEL) },
+    { id: 'channel.p2p-proactive', version: '1.0.0', priority: 150, appliesTo: ['p2p-agent'], source: 'static-md', maxChars: 600, meta: DEFAULT_META(TTL_CHANNEL) },
+    { id: 'channel.human-async', version: '1.0.0', priority: 150, appliesTo: ['local'], source: 'static-md', maxChars: 500, meta: DEFAULT_META(TTL_CHANNEL) },
+    { id: 'channel.session-handoff', version: '1.0.0', priority: 150, appliesTo: ['local', 'p2p-visitor', 'p2p-agent'], source: 'static-md', maxChars: 600, meta: DEFAULT_META(TTL_CHANNEL) },
+    // ── core/ ──
+    { id: 'core.memory_system', version: '1.0.0', priority: 140, appliesTo: ['all'], source: 'static-md', maxChars: 200, meta: DEFAULT_META(TTL_KNOWLEDGE) },
+    // 2026-07-10 双栖 agent 网络新增 (按 plan 阶段 4):
+    // priority 90 (在 channel 150 之后) — 保证 channel 装完后再装 core, 避免 channel 预算被 core 吃掉
+    // maxChars 700 → 400: 7 个新 layer 总预算 3900 chars, 必须让出空间给 tool.p2p_request (700) + tool.goal_handoff (600)
+    { id: 'core.external-engagement', version: '1.0.0', priority: 90, appliesTo: ['all'], source: 'static-md', maxChars: 400, meta: DEFAULT_META(TTL_KNOWLEDGE) },
     // ── tool/ (按工具调用嵌对应 layer) ──
     { id: 'tool.bash', version: '1.0.0', priority: 250, appliesTo: ['tool:bash'], source: 'static-md', maxChars: 600, meta: DEFAULT_META(TTL_TOOL) },
     { id: 'tool.web_search', version: '1.0.0', priority: 250, appliesTo: ['tool:web_search'], source: 'static-md', maxChars: 600, meta: DEFAULT_META(TTL_TOOL) },
@@ -111,6 +121,9 @@ const STATIC_LAYERS = [
     { id: 'tool.image_search', version: '1.0.0', priority: 250, appliesTo: ['never'], source: 'static-md', maxChars: 0, meta: DEFAULT_META(TTL_TOOL) },
     { id: 'tool.artifacts', version: '1.0.0', priority: 250, appliesTo: ['never'], source: 'static-md', maxChars: 0, meta: DEFAULT_META(TTL_TOOL) },
     { id: 'tool.manifest', version: '1.0.0', priority: 250, appliesTo: ['tool:manifest'], source: 'static-md', maxChars: 500, meta: DEFAULT_META(TTL_TOOL) },
+    // 2026-07-10 双栖 agent 网络新增 (按 plan 阶段 5):
+    { id: 'tool.p2p_request', version: '1.0.0', priority: 250, appliesTo: ['tool:send_message', 'tool:send_to_channel', 'tool:check_inbox', 'tool:list_peers', 'tool:agent_call', 'tool:broadcast_message'], source: 'static-md', maxChars: 700, meta: DEFAULT_META(TTL_TOOL) },
+    { id: 'tool.goal_handoff', version: '1.0.0', priority: 250, appliesTo: ['tool:park_goal', 'tool:resume_goal', 'tool:continue_goal_background'], source: 'static-md', maxChars: 600, meta: DEFAULT_META(TTL_TOOL) },
 ];
 /**
  * 动态 layer (运行时计算, 例如 project context, judgment 注入)
@@ -141,8 +154,13 @@ const DYNAMIC_LAYERS = [
  * P-Action 4 (2026-06-15): 总字符上限 15000 → 4500.
  * 阶段 0 单次 system prompt 控制在 ≤ 4.5KB (≈ 1125 tokens).
  * 配合单 layer maxChars 收紧 + 6 layer 停用, 每轮 chat 节省 ≈ 2625 tokens.
+ *
+ * 2026-07-10 改造: 4500 → 6500 → 8000 (≈ 2000 tokens).
+ *   原因: 7 个新 layer (4 channel + 1 core + 2 tool) 合计 ≈ 3500 chars.
+ *   实际测算: 现有 11 个 layer 装配后 ≈ 6930 chars; 必须松绑到 8000 才能保证 tool.* 也装入.
+ *   每次 chat 多 ~875 tokens input (7% 增), 可接受 — 双栖 agent 网络的"目标接力"必须让 LLM 看到.
  */
-const TOTAL_BUDGET = 4500;
+const TOTAL_BUDGET = 8000;
 export async function assembleSystemPrompt(ctx) {
     // 1. 收集所有 layer
     const allLayers = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bolloon/bolloon-agent",
-  "version": "0.2.15",
+  "version": "0.3.0",
   "type": "module",
   "description": "P2P AI Document Agent - 全局安装后执行 `bolloon` 启动产品",
   "main": "dist/cli-entry.js",