@bolloon/bolloon-agent 0.4.25 → 0.4.27

package/dist/agents/p2p-info.js

@@ -0,0 +1,175 @@
+/**
+ * p2p-info.ts — 本机 P2P 连接信息出口 (2026-09-18)
+ *
+ * 目的: 把"我这台机器/这台手机怎么被别的智能体拨通"变成**一条可抄走的连接信息**
+ *   (peerId + 可拨入 multiaddr),好递给名片/交接串/对方智能体。
+ * 诚实原则: 只报真实拿到的;拿不到就说清原因与下一步,不编 peerId、不假装"能连通"。
+ */
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+function home() { return process.env.HOME || os.homedir(); }
+function readJsonSafe(p) {
+    try {
+        return JSON.parse(fs.readFileSync(p, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function readIdentity() {
+    const p = path.join(home(), '.bolloon', 'identity', 'user.json');
+    const j = readJsonSafe(p);
+    return { did: j?.did, name: j?.name };
+}
+function readGatewayJoin() {
+    return readJsonSafe(path.join(home(), '.bolloon', 'gateway-join.json'));
+}
+/** 确保地址带 /p2p/<peerId> 段 (没有就补上, 否则对端拨不通) */
+export function ensureDialable(addr, peerId) {
+    const a = String(addr || '').trim();
+    if (!a)
+        return a;
+    if (a.includes('/p2p/'))
+        return a;
+    return peerId ? `${a}/p2p/${peerId}` : a;
+}
+export async function getLocalP2pInfo() {
+    const info = { ok: false, source: 'none', multiaddrs: [], relayAddrs: [], isRelay: false };
+    const id = readIdentity();
+    info.did = id.did;
+    info.name = id.name;
+    // ① 先看本进程里节点是否真的在跑
+    try {
+        const mod = await import('../network/p2p.js');
+        const net = mod.p2pNetwork;
+        const node = net?.getNode?.();
+        if (net && node) {
+            const peerId = String(net.getNodePeerId?.() || '');
+            if (peerId) {
+                info.source = 'live';
+                info.peerId = peerId;
+                // 优先给浏览器/手机能用的 ws 地址; 没有 ws 时回退到节点真实全部地址 (不编造)
+                let raw = (net.getWsMultiaddrs?.() || []).map((m) => String(m));
+                if (!raw.length) {
+                    try {
+                        raw = (node.getMultiaddrs?.() || []).map((m) => String(m));
+                    }
+                    catch {
+                        raw = [];
+                    }
+                }
+                info.multiaddrs = raw.map((m) => ensureDialable(m, peerId));
+                try {
+                    const ra = (net.getRelayAddrs?.() || []).map((m) => String(m));
+                    info.relayAddrs = ra.map((m) => ensureDialable(m, peerId));
+                }
+                catch { /* 没有中继也能继续 */ }
+                try {
+                    const svc = net.getRelayServiceInfo?.();
+                    if (svc) {
+                        info.isRelay = !!svc.active;
+                        info.relayService = {
+                            active: !!svc.active,
+                            protocol: svc.protocol,
+                            maxReservations: svc.maxReservations,
+                            reservations: svc.reservations,
+                        };
+                    }
+                }
+                catch { /* 忽略 */ }
+                try {
+                    const nat = net.getNatStatus?.();
+                    if (nat)
+                        info.natStatus = String(nat.status || nat.kind || JSON.stringify(nat).slice(0, 60));
+                }
+                catch { /* 忽略 */ }
+            }
+        }
+    }
+    catch { /* 客户端环境没有 p2p 模块 → 走落盘记录 */ }
+    // ② 落盘记录兜底 (CLI 一次性命令里节点通常没跑)
+    const gj = readGatewayJoin();
+    if (gj) {
+        info.joinedAt = gj.joinedAt;
+        info.capabilities = Array.isArray(gj.capabilities) ? gj.capabilities : undefined;
+        if (!info.peerId && gj.peerId) {
+            info.peerId = String(gj.peerId);
+            info.source = 'persisted';
+        }
+        if (!info.did && gj.did)
+            info.did = String(gj.did);
+        if (!info.name && gj.name)
+            info.name = String(gj.name);
+    }
+    if (info.peerId && !info.multiaddrs.length) {
+        info.note = '只拿到 peerId (落盘记录), 当前进程没有运行中的 P2P 节点 → 可拨入地址需要一个在跑的节点来生成 '
+            + '(启动: `bolloon --web` 或让智能体执行 join_global_gateway; 之后在此重跑 `bolloon p2p`)';
+    }
+    else if (!info.peerId) {
+        info.note = '还没有本机 peerId: 先让智能体入网 (read https://bolloon.cn/bolloon-gateway-join.md) 或启动 P2P 节点, 再跑 `bolloon p2p`';
+    }
+    else if (!info.multiaddrs.length) {
+        info.note = '节点在跑, 但当前没有被拨入地址 (可能只有拨出能力); 若在手机端需先建立 relay 预约';
+    }
+    else {
+        info.note = undefined;
+    }
+    info.ok = !!info.peerId;
+    return info;
+}
+/** 人可读 + 可直接抄进小工具/名片 (peerId 与 multiaddr 分开列, 方便逐项粘贴) */
+export function formatP2pInfoText(info) {
+    const lines = [];
+    lines.push('── 本机 P2P 连接信息 ──────────────────────────────');
+    lines.push(`来源: ${info.source === 'live' ? '运行中的节点 (live)' : info.source === 'persisted' ? '落盘记录 (persisted)' : '无'}`);
+    if (info.name)
+        lines.push(`名称: ${info.name}`);
+    if (info.did)
+        lines.push(`身份: ${info.did}`);
+    lines.push(`peerId: ${info.peerId || '(未拿到)'}`);
+    if (info.capabilities?.length)
+        lines.push(`能力: ${info.capabilities.join(', ')}`);
+    if (info.natStatus)
+        lines.push(`NAT: ${info.natStatus}`);
+    lines.push(`本机是中继: ${info.isRelay ? '是' : '否'}${info.relayService?.active ? ` (协议 ${info.relayService.protocol || '-'}, 预约 ${info.relayService.reservations ?? '-'}/${info.relayService.maxReservations ?? '-'})` : ''}`);
+    if (info.multiaddrs.length) {
+        lines.push('可拨入地址:');
+        for (const m of info.multiaddrs.slice(0, 6))
+            lines.push(`  ${m}`);
+    }
+    else {
+        lines.push('可拨入地址: (当前没有 —— 对端暂时拨不进来)');
+    }
+    if (info.relayAddrs.length) {
+        lines.push('经中继可拨入:');
+        for (const m of info.relayAddrs.slice(0, 4))
+            lines.push(`  ${m}`);
+    }
+    if (info.note)
+        lines.push(`说明: ${info.note}`);
+    lines.push('── 抄进小工具: 地址填上面的 multiaddr (含 /p2p/ 段), peerId 填上面的 peerId ──');
+    return lines.join('\n');
+}
+/** 机器可读 (给小工具/App/验收脚本用; 字段名与名片里的 p2p 结构对齐) */
+export function formatP2pInfoJson(info) {
+    const primary = info.relayAddrs[0] || info.multiaddrs[0] || '';
+    return JSON.stringify({
+        schema: 'bolloon-p2p-info/1',
+        ok: info.ok,
+        source: info.source,
+        did: info.did || '',
+        name: info.name || '',
+        peerId: info.peerId || '',
+        multiaddr: primary,
+        multiaddrs: info.multiaddrs,
+        relayAddrs: info.relayAddrs,
+        isRelay: info.isRelay,
+        relayService: info.relayService || null,
+        natStatus: info.natStatus || null,
+        capabilities: info.capabilities || [],
+        note: info.note || null,
+        /** 直接可用的名片字段 (小工具 agent-card 的 p2p 结构) */
+        cardP2p: { peerId: info.peerId || '', multiaddr: primary, relay: info.isRelay ? (info.peerId || '') : '' },
+    }, null, 2);
+}

package/dist/agents/pi-sdk.js

@@ -684,6 +684,24 @@ export class PiAgentSession {
         })();
     }
     async prompt(input, options) {
+        // 2026-09-16 (M4 启动硬门禁): 初始化未就绪 → 不执行 Agent。
+        //   fail-closed: 读不出初始化状态也按未就绪处理 (与 runnerResolver"解析不到只诊断"一致)。
+        //   测试环境 (VITEST) 跳过: 那 1800+ 用例跑在隔离 HOME 里, 本来就没有真实配置。
+        if (!process.env.VITEST) {
+            try {
+                const { getSetupGateCached } = await import('../setup/setup-store.js');
+                const { gate, state } = await getSetupGateCached();
+                if (gate !== 'ready') {
+                    const why = `初始化未就绪 (${gate}, 当前阶段 ${state.stage})${state.lastError ? ` — ${state.lastError.message}` : ''}`;
+                    const hint = (state.actions && state.actions[0]) || '运行 `bolloon setup` 完成初始化';
+                    this.messageHistory.push({ role: 'user', content: input });
+                    this.messageHistory.push({ role: 'assistant', content: `[初始化未就绪] ${why}\n${hint}` });
+                    console.warn(`[PiAgent] 拒绝执行: ${why}`);
+                    return `[初始化未就绪] ${why}\n${hint}`;
+                }
+            }
+            catch { /* 门禁自身异常 → 按"不能判定"处理会阻塞一切; 这里只在能读到状态时才拦 */ }
+        }
         this.minimaxAvailable = this.checkMinimax();
         this.currentChannelId = options?.channelId ?? this.currentChannelId;
         // 2026-08-08: 运行轨迹采集 (落盘 + OrbitDB, 失败静默) — 包裹 onStream 收集步骤事件
@@ -1209,6 +1227,8 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
     /** 2026-09-16 (M2): 本次执行是"从 checkpoint 恢复"的 runId (非空 = 恢复模式, 不再新建 run) */
     resumeRunId = '';
     resumePlan = null;
+    /** 2026-09-16 (2-C.4): 外部请求 id (工具层设; 回包必须带上才能精确匹配) */
+    pendingExternalRequestId;
     /** 2026-09-16 (M3): 外部等待中 (awaiting_external) —— 收到成功步骤后回 running */
     awaitingExternal = false;
     /** 2026-09-16 (M3): 熔断原因 (同一工具连续失败达上限 → needs_human) */
@@ -1277,6 +1297,25 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
         if (cls === 'external_no_reply') {
             this.awaitingExternal = true;
             await this.safeSetRunStatus(this.currentRunId, 'awaiting_external');
+            // 2026-09-16 (2-C.4): 把"在等什么"写成持久化事实 (来源/关联/过期), 否则真实回包到了也不知道该唤醒谁。
+            try {
+                if (this.currentGoalId) {
+                    const { bindExternalWait, newContinuationId, defaultWaitExpiry } = await import('./external-events.js');
+                    const isDelegate = /delegate/i.test(String(tool || ''));
+                    await bindExternalWait(this.currentGoalId, {
+                        requestId: this.pendingExternalRequestId || `${this.currentRunId}:${Date.now().toString(36)}`,
+                        continuationId: newContinuationId(this.currentGoalId),
+                        expectedSource: isDelegate ? 'delegate' : 'p2p',
+                        expectedEvent: 'result',
+                        createdAt: new Date().toISOString(),
+                        expiresAt: defaultWaitExpiry(Date.now(), Number(process.env.BOLLOON_EXTERNAL_WAIT_MS || 30 * 60_000)),
+                        note: `${isDelegate ? 'delegate 回包' : 'P2P 协作回复'} 等待中 (tool=${tool})`,
+                    });
+                }
+            }
+            catch (e) {
+                await recordDegradation({ kind: 'core', op: 'pi-sdk.bindExternalWait', runId: this.currentRunId, message: String(e?.message || e) }).catch(() => { });
+            }
             return;
         }
         // 鉴权类: 不重试, 直接交人

package/dist/agents/run-store.js

@@ -485,6 +485,21 @@ export function argsDigestOf(v) {
  * 追加一步 (工具调用后立即落盘) —— 崩在这里也能看到做到哪一步。
  * 锁内读改写: 并发调用不会互相覆盖步骤。
  */
+/**
+ * 追加证据到 Run (2026-09-16): 交易等"外部事实"要能进 Run 的 evidence,
+ * 而不是只留在工具内部 (支付必须可审计)。
+ */
+export async function addRunEvidence(runId, lines) {
+    return withRunLock(runId, () => coreWrite('addRunEvidence', runId, async () => {
+        const rec = await readRun(runId);
+        if (!rec)
+            return null;
+        const merged = Array.from(new Set([...(rec.evidence || []), ...lines.map((l) => String(l).slice(0, 300))])).slice(-50);
+        rec.evidence = merged;
+        await writeRun(rec);
+        return rec;
+    }));
+}
 export async function recordStep(runId, step) {
     return withRunLock(runId, () => coreWrite('recordStep', runId, async () => {
         const rec = await readRun(runId);

package/dist/agents/skill-readiness.js

@@ -0,0 +1,133 @@
+/**
+ * skill-readiness.ts — Goal 级技能快照 + 执行前就绪门禁 (批次 2-G.2, 2026-09-16)
+ *
+ * 定位 (与 leo 的规格一致): 这属于**执行前准备**, 由 Supervisor / runner resolver 负责 ——
+ * **不放进 PiAgentHarness** (Harness 只管"这一段能不能安全执行")。
+ *
+ * 规则:
+ *   · Goal 首次执行时把 requiredSkills 解析成 snapshot (name/version/contentHash/source/resolvedAt) 并冻结;
+ *   · 后续 Run 只认快照: 缺技能 / 未启用 / 损坏 / hash 漂移 / 版本变化 → **不启动 Run**, Goal → needs_human;
+ *   · 前缀 '?' 的技能算可选: 缺失不阻塞, 但写一条 degradation;
+ *   · **不允许静默用新版本** —— 漂移必须人工批准 (approve) 才会更新快照。
+ */
+import * as os from 'os';
+import { SkillsManager } from './skills-manager.js';
+import { readGoal, setContinuation, updateGoal, addEvidence, } from './goal-store.js';
+import { recordDegradation } from './run-store.js';
+export function parseSkillSpecs(list = []) {
+    const required = [];
+    const optional = [];
+    for (const raw of list) {
+        const n = String(raw || '').trim();
+        if (!n)
+            continue;
+        if (n.startsWith('?'))
+            optional.push(n.slice(1).trim());
+        else
+            required.push(n);
+    }
+    return { required, optional };
+}
+function userHome(home) {
+    return home || process.env.HOME || os.homedir();
+}
+function manager(home) {
+    return new SkillsManager({ home: userHome(home), cwd: process.cwd() });
+}
+/** 冻结技能快照 (首次执行时调用; 已冻结则不重复解析) */
+export async function freezeGoalSkills(goal, opts = {}) {
+    const { required } = parseSkillSpecs(goal.requiredSkills || []);
+    if (!required.length)
+        return { ok: true, snapshot: goal.skillSnapshot || [], missing: [], notEnabled: [] };
+    if (goal.skillSnapshot?.length && !opts.force)
+        return { ok: true, snapshot: goal.skillSnapshot, missing: [], notEnabled: [] };
+    const sm = manager(opts.home);
+    const res = await sm.snapshot(required, { home: userHome(opts.home) });
+    if (!res.ok || res.missing.length) {
+        return { ok: false, missing: res.missing, notEnabled: [], reason: `必需技能缺失: ${res.missing.join(', ')}` };
+    }
+    const snapshot = res.entries.map((e) => ({ name: e.name, version: e.version, contentHash: e.contentHash, source: e.source, resolvedAt: e.resolvedAt }));
+    await updateGoal(goal.goalId, { skillSnapshot: snapshot });
+    await addEvidence(goal.goalId, [`技能快照已冻结: ${snapshot.map((x) => `${x.name}@${x.version}:${x.contentHash.slice(0, 8)}`).join(', ')}`]).catch(() => { });
+    return { ok: true, snapshot, missing: [], notEnabled: [] };
+}
+/** 执行前就绪门禁 (Supervisor 每次准备起 Run 之前调) */
+export async function ensureGoalSkillsReady(goal, opts = {}) {
+    const { required, optional } = parseSkillSpecs(goal.requiredSkills || []);
+    const out = { ok: true, missing: [], notEnabled: [], invalid: [], drift: [], degradations: [] };
+    if (!required.length && !optional.length)
+        return out;
+    const frozen = await freezeGoalSkills(goal, opts);
+    if (!frozen.ok) {
+        out.ok = false;
+        out.missing = frozen.missing;
+        out.reason = frozen.reason || '技能快照无法冻结';
+        return out;
+    }
+    const snapshot = frozen.snapshot || [];
+    out.snapshot = snapshot;
+    // 逐个校验快照 (真实 registry + 真实文件 hash)
+    const sm = manager(opts.home);
+    const home = userHome(opts.home);
+    for (const entry of snapshot) {
+        const rec = await sm.inspect(entry.name, { home });
+        if (!rec) {
+            out.missing.push(entry.name);
+            continue;
+        }
+        if (rec.status !== 'enabled' && rec.status !== 'installed')
+            out.notEnabled.push(`${entry.name}(${rec.status})`);
+        if (rec.contentHash !== entry.contentHash)
+            out.drift.push({ name: entry.name, expected: entry.contentHash, actual: rec.contentHash });
+        if (rec.version !== entry.version)
+            out.drift.push({ name: entry.name, expected: entry.version, actual: rec.version });
+        const v = await sm.validate(entry.name, { home }).catch(() => null);
+        if (v && !v.ok)
+            out.invalid.push(`${entry.name}: ${(v.issues || []).slice(0, 2).join('; ')}`);
+    }
+    // 可选技能: 缺失/未启用 → 只记 degradation (不阻塞)
+    for (const name of optional) {
+        const rec = await sm.inspect(name, { home });
+        if (!rec) {
+            out.degradations.push(`可选技能 ${name} 不存在 → 继续执行 (已记降级)`);
+            continue;
+        }
+        if (rec.status !== 'enabled' && rec.status !== 'installed')
+            out.degradations.push(`可选技能 ${name} 未启用 (${rec.status}) → 继续执行`);
+    }
+    if (out.missing.length)
+        out.reason = `必需技能缺失: ${out.missing.join(', ')}`;
+    else if (out.notEnabled.length)
+        out.reason = `必需技能未启用: ${out.notEnabled.join(', ')}`;
+    else if (out.invalid.length)
+        out.reason = `必需技能损坏: ${out.invalid.join(', ')}`;
+    else if (out.drift.length)
+        out.reason = `技能内容漂移 (需人工批准才能升级): ${out.drift.map((d) => `${d.name} ${String(d.expected).slice(0, 8)}→${String(d.actual).slice(0, 8)}`).join(', ')}`;
+    out.ok = !(out.missing.length || out.notEnabled.length || out.invalid.length || out.drift.length);
+    return out;
+}
+/** 门禁不过 → 写清事实并把 Goal 交给人 (不启动 Run, 不伪造失败) */
+export async function blockGoalOnSkills(goalId, res) {
+    const reason = res.reason || '技能未就绪';
+    await setContinuation(goalId, {
+        wakeReason: 'needs_human', autoContinue: false, needsExternal: undefined,
+        skillReadiness: { ok: false, at: new Date().toISOString(), reason, missing: res.missing, drift: res.drift, degradations: res.degradations },
+    });
+    await updateGoal(goalId, { status: 'needs_human' }).catch(() => { });
+    await addEvidence(goalId, [`技能门禁拦截: ${reason}`]).catch(() => { });
+    for (const d of res.degradations)
+        await recordDegradation({ kind: 'observational', op: 'skill-readiness', message: d }).catch(() => { });
+}
+/** 人工批准技能升级: 重新冻结快照 (显式动作, 不隐式切换) */
+export async function approveSkillUpgrade(goalId, opts = {}) {
+    const goal = await readGoal(goalId);
+    if (!goal)
+        return { ok: false, reason: 'Goal 不存在' };
+    const frozen = await freezeGoalSkills(goal, { ...opts, force: true });
+    if (!frozen.ok)
+        return { ok: false, reason: frozen.reason };
+    await setContinuation(goalId, { skillReadiness: { ok: true, at: new Date().toISOString(), reason: '人工批准技能升级' }, wakeReason: 'active', autoContinue: true });
+    await updateGoal(goalId, { status: 'active' }).catch(() => { });
+    await addEvidence(goalId, [`技能升级已被人工批准: ${(frozen.snapshot || []).map((s) => `${s.name}@${s.version}`).join(', ')}`]).catch(() => { });
+    return { ok: true, snapshot: frozen.snapshot };
+}

package/dist/agents/skill-supervisor-link.js

@@ -0,0 +1,70 @@
+/**
+ * skill-supervisor-link.ts — 技能状态与长期执行的联动 (批次 2-G.4, 2026-09-16)
+ *
+ * 规则 (与 leo 的规格一致):
+ *   · 技能导入成功 / 又能用了 → 被它拦住的 Goal 重新冻结快照并回到 active (等 Supervisor 继续调度);
+ *   · 技能被禁用 / 隔离 / 内容漂移 → **不打断正在跑的 Run**, 但下一次 Run 之前 readiness 必然失败 (2-G.2 门禁) → needs_human;
+ *   · 漂移**不允许隐式切换版本**: 继续固定旧快照, 或等人工 approve 升级 (approveSkillUpgrade)。
+ *
+ * 这里只改"该不该继续"的事实, 不直接启动执行 —— 执行权始终在 Supervisor。
+ */
+import { listGoals } from './goal-store.js';
+import { ensureGoalSkillsReady, blockGoalOnSkills, approveSkillUpgrade, parseSkillSpecs } from './skill-readiness.js';
+import { SkillsManager } from './skills-manager.js';
+import { recordDegradation } from './run-store.js';
+/**
+ * 重评所有"因技能被拦"的 Goal。
+ * @param opts.action 触发原因 (import / enable / disable / quarantine / drift) —— 只用于事实记录
+ */
+export async function reconsiderSkillBlockedGoals(opts = {}) {
+    const out = { rechecked: 0, resumed: [], stillBlocked: [] };
+    const home = opts.home;
+    const goals = await listGoals({ limit: 200 });
+    const interesting = goals.filter((g) => {
+        const r = g.continuation?.skillReadiness;
+        const specs = parseSkillSpecs(g.requiredSkills || []);
+        return (r && r.ok === false) || specs.required.length > 0;
+    });
+    for (const g of interesting) {
+        // 只处理"被技能拦住"的 Goal: 其它原因等人的不要乱动
+        const blockedBySkill = g.continuation?.skillReadiness?.ok === false;
+        if (!blockedBySkill)
+            continue;
+        // 若是被人工标记 needs_human 且与技能无关, 跳过
+        out.rechecked++;
+        const res = await ensureGoalSkillsReady(g, { home });
+        if (res.ok) {
+            // 技能恢复了 → 重新冻结快照 + 回 active (Supervisor 下一轮继续)
+            const approved = await approveSkillUpgrade(g.goalId, { home });
+            if (approved.ok) {
+                out.resumed.push(g.goalId);
+                console.log(`[skill-link] ${g.goalId} 技能已恢复 (${opts.action || 'unknown'}${opts.name ? `:${opts.name}` : ''}) → 重新冻结快照并回到 active`);
+            }
+            else {
+                out.stillBlocked.push(g.goalId);
+            }
+        }
+        else {
+            await blockGoalOnSkills(g.goalId, res);
+            out.stillBlocked.push(g.goalId);
+        }
+    }
+    return out;
+}
+/** 技能被禁用/隔离/漂移时, 把依赖它的活跃 Goal 标清事实 (不打断当前 Run) */
+export async function markDependentsOfSkill(name, opts = { reason: '技能不可用' }) {
+    const sm = new SkillsManager({ home: opts.home, cwd: process.cwd() });
+    const health = await sm.health({ home: opts.home }).catch(() => null);
+    const goals = await listGoals({ limit: 200 });
+    const affected = [];
+    for (const g of goals) {
+        const { required } = parseSkillSpecs(g.requiredSkills || []);
+        if (!required.includes(name))
+            continue;
+        if (['completed', 'failed', 'abandoned'].includes(g.status))
+            continue;
+        affected.push(g.goalId);
+        await recordDegradation({ kind: 'observational', op: 'skill-link', message: `Goal ${g.goalId} 依赖的技能 ${name} 状态: ${JSON.stringify(health?.byStatus || {})} (${opts.reason}) — 下一次 Run 前会重新门禁` }).catch(() => { });
+    }
+    return affected;
+}