@bolloon/bolloon-agent 0.2.14 → 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/cli-entry.js

@@ -23,7 +23,7 @@ const YELLOW = '\x1b[33m';
 const GREEN = '\x1b[32m';
 const MAGENTA = '\x1b[35m';
 // 版本信息 — 与 package.json:version 同步, 否则 banner 会显示过时版本误导用户
-const VERSION = '0.2.14';
+const VERSION = '0.2.15';
 function log(msg, color = RESET) {
     console.log(`${color}${msg}${RESET}`);
 }