@bolloon/bolloon-agent 0.6.6 → 0.6.7

package/dist/agents/ha-daemon.js

@@ -0,0 +1,85 @@
+/**
+ * ha-daemon.ts — 独立 kernel 守护进程入口 (业务侧宿主, 2026-10-16, leo: 双内核冗余 — 拆独立 kernel 守护进程)
+ *
+ * 由主进程 spawn (见 ha-supervisor.ts 的 startHaDaemon): `node dist/agents/ha-daemon.js --role standby --home <HOME>`
+ * 职责: 以 **standby** 角色运行 HA 守护循环 —— 探测主进程心跳, 主死则接管其 orphan run。
+ *
+ * 位置说明: **不放在 src/kernel/** — kernel 目录有 K1 边界门 (禁 import 业务); 本文件要注入 run-store
+ * 的 reconcileOrphans/prepareResume, 是**业务侧宿主**, 放 src/agents/。kernel/ha/ 只留纯机制
+ * (ha-arbiter 心跳格式/锁/决策 + ha-guard 守护循环, 端口注入), 零业务依赖。
+ *
+ * 环境变量:
+ *   BOLLOON_HOME          数据目录 (缺省 ~/.bolloon)
+ *   BOLLOON_HA_BEAT_MS    心跳间隔 (缺省 10s)
+ *   BOLLOON_HA_STALE_MS   心跳过期阈值 (缺省 30s)
+ *
+ * 退出: SIGTERM/SIGINT → 停心跳 → exit(0); 父进程退出 → 管道关闭 → 退出 (不孤儿存活)。
+ */
+import * as os from 'os';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import { startHaGuard } from '../kernel/ha/ha-guard.js';
+import { runsDir } from './run-store.js';
+const home = process.env.BOLLOON_HOME || os.homedir();
+const beatMs = Number(process.env.BOLLOON_HA_BEAT_MS) || 10_000;
+const staleMs = Number(process.env.BOLLOON_HA_STALE_MS) || 30_000;
+// 2026-10-16: run-store 的 runsDir() 用 os.homedir() (POSIX 读 $HOME)。
+//   设置了 BOLLOON_HOME = daemon 操作隔离数据目录 → 无条件把 $HOME 指过去
+//   (daemon 是独立 spawn 的守护进程, 改自己的 HOME 不影响主进程; 这里不设的话
+//   reconcileOrphans/prepareResume 会读真实 ~/.bolloon/runs, 接不到隔离 runs 的孤儿)。
+if (process.env.BOLLOON_HOME) {
+    process.env.HOME = process.env.BOLLOON_HOME;
+}
+// 业务侧端口注入: run-store 实现 (守护循环不自己 import 业务, 由宿主注入)
+const ports = {
+    reconcileOrphans: async () => {
+        const { reconcileOrphans } = await import('./run-store.js');
+        return reconcileOrphans();
+    },
+    prepareResume: async (runId) => {
+        const { prepareResume } = await import('./run-store.js');
+        const r = await prepareResume(runId);
+        return r.ok ? { ok: true } : { ok: false, reason: r.reason };
+    },
+    collectActiveRunIds: async () => {
+        // 2026-10-16: BOLLOON_HOME 优先 (隔离 HOME 的 daemon 读隔离 runs), 否则 fallback 真实 runsDir()
+        const home = process.env.BOLLOON_HOME || '';
+        const dir = home ? path.join(home, '.bolloon', 'runs') : runsDir();
+        const files = await fs.readdir(dir).catch(() => []);
+        const active = [];
+        for (const n of files) {
+            if (!n.endsWith('.json') || n.endsWith('.bak'))
+                continue;
+            const id = n.replace(/\.json$/, '');
+            if (/^(run|goal)_/.test(id))
+                active.push(id); // 保守: 只认 run/goal 前缀
+        }
+        return active;
+    },
+    log: (level, message) => {
+        process.stdout.write(`[ha-daemon:${level}] ${message}\n`);
+    },
+};
+const guard = startHaGuard(ports, {
+    role: 'standby',
+    home,
+    kernelVersion: process.env.npm_package_version || '',
+    beatMs,
+    staleMs,
+    onTakeover: (info) => {
+        process.stdout.write(`[ha-daemon] 接管主进程: adopted=${info.adoptedRunIds.length} runs (${info.reason})\n`);
+    },
+});
+process.stdout.write(`[ha-daemon] 启动 role=standby pid=${process.pid} home=${home} beat=${beatMs}ms stale=${staleMs}ms\n`);
+let shuttingDown = false;
+function shutdown(sig) {
+    if (shuttingDown)
+        return;
+    shuttingDown = true;
+    process.stdout.write(`[ha-daemon] 收到 ${sig}, 停止心跳退出\n`);
+    guard.stop();
+    process.exit(0);
+}
+process.on('SIGTERM', () => shutdown('SIGTERM'));
+process.on('SIGINT', () => shutdown('SIGINT'));
+export { guard };

package/dist/agents/ha-supervisor.js

@@ -0,0 +1,146 @@
+/**
+ * ha-supervisor.ts — 主进程侧 HA 守护管理器 (2026-10-16, leo: 双内核冗余 — 独立 kernel 守护进程)
+ *
+ * 主进程 (createWebServer / CLI) 侧:
+ *   ① 自己以 **primary** 角色写心跳 (含当前活跃 runIds)
+ *   ② spawn 独立 kernel 守护进程 (src/agents/ha-daemon.ts, 以 standby 角色跑)
+ *   ③ 监控 daemon 存活: 心跳过期 / 进程退出 → **自动重启 + 接管** (重启后它自己会 reconcileOrphans + prepareResume)
+ *   ④ daemon 启动即探测主进程: 主死 → daemon 接管 (反向故障转移)
+ *
+ * 依赖注入 (业务侧端口):
+ *   - primary 心跳的 runIds 来源: collectActiveRunIds (runs 目录扫描)
+ *   - 全端口注入 → 可单测 (注入假 DAEMON_TS 路径 / 假 child_process)
+ */
+import * as os from 'os';
+import * as path from 'path';
+import { spawn } from 'node:child_process';
+import { startHaGuard } from '../kernel/ha/ha-guard.js';
+import { collectActiveRunIds, STALE_MS, BEAT_MS } from '../kernel/ha/ha-arbiter.js';
+import * as fs from 'fs';
+const noop = () => { };
+function defaultSpawn(cmd, args, opts) {
+    return spawn(cmd, args, opts);
+}
+export class HaSupervisor {
+    opts;
+    guard = null;
+    daemon = null;
+    restartTimer = null;
+    state = {
+        primaryStarted: false,
+        daemonPid: null,
+        daemonAlive: false,
+        restarts: 0,
+        daemonExitCode: null,
+    };
+    stopped = false;
+    constructor(opts = {}) {
+        this.opts = opts;
+    }
+    getState() { return { ...this.state }; }
+    /** 启动: primary 心跳 + spawn daemon + 监控重启 */
+    async start() {
+        const home = this.opts.home || os.homedir();
+        const beatMs = this.opts.beatMs ?? BEAT_MS;
+        const staleMs = this.opts.staleMs ?? STALE_MS;
+        const log = this.opts.log || noop;
+        // ① primary 心跳 (主进程自己; runIds 从 runs 目录收集)
+        const ports = {
+            reconcileOrphans: async () => ({ interrupted: [], stillRunning: [], failed: [] }),
+            prepareResume: async () => ({ ok: false, reason: 'primary 不接管 (它是主)' }),
+            collectActiveRunIds: async () => collectActiveRunIds(path.join(home, '.bolloon', 'runs')),
+            log: (l, m) => log(l, `[ha:primary] ${m}`),
+        };
+        this.guard = startHaGuard(ports, {
+            role: 'primary',
+            home,
+            kernelVersion: process.env.npm_package_version || '',
+            beatMs,
+            staleMs,
+        });
+        this.state.primaryStarted = true;
+        log('info', `[ha] primary 心跳已启动 (home=${home}, beat=${beatMs}ms, stale=${staleMs}ms)`);
+        // ② spawn 独立 kernel 守护进程 (standby)
+        this.spawnDaemon();
+        // ③ 监控 daemon: 退出 → 自动重启 (kernel 死则重启 + 它接管)
+        //    监控交给 child 'exit' 事件 (已在 spawnDaemon 里挂), 无需额外轮询。
+    }
+    spawnDaemon() {
+        if (this.stopped)
+            return;
+        const log = this.opts.log || noop;
+        const home = this.opts.home || os.homedir();
+        const nodeBin = this.opts.nodeBin || process.execPath;
+        const entry = this.opts.daemonEntry || path.join(__dirname, 'ha-daemon.js');
+        const spawnImpl = this.opts.spawnImpl || defaultSpawn;
+        log('info', `[ha] spawn kernel 守护进程: ${nodeBin} ${entry} (role=standby)`);
+        try {
+            const child = spawnImpl(nodeBin, [entry], {
+                env: {
+                    ...process.env,
+                    BOLLOON_HOME: home,
+                    BOLLOON_HA_BEAT_MS: String(this.opts.beatMs ?? BEAT_MS),
+                    BOLLOON_HA_STALE_MS: String(this.opts.staleMs ?? STALE_MS),
+                },
+                stdio: ['ignore', 'pipe', 'pipe'],
+                detached: false,
+            });
+            this.daemon = child;
+            this.state.daemonPid = child.pid ?? null;
+            this.state.daemonAlive = true;
+            child.stdout?.on('data', (d) => {
+                const s = String(d).trim();
+                if (s)
+                    log('info', `[ha:daemon] ${s}`);
+            });
+            child.stderr?.on('data', (d) => {
+                const s = String(d).trim();
+                if (s)
+                    log('warn', `[ha:daemon:err] ${s}`);
+            });
+            child.on('exit', (code, signal) => {
+                this.state.daemonAlive = false;
+                this.state.daemonExitCode = code;
+                log('warn', `[ha] kernel 守护进程退出 code=${code} signal=${signal || ''}`);
+                if (!this.stopped && this.opts.autoRestart !== false) {
+                    log('info', `[ha] 守护进程退出, 自动重启 (第 ${this.state.restarts + 1} 次)`);
+                    this.restartTimer = setTimeout(() => {
+                        if (!this.stopped) {
+                            this.state.restarts++;
+                            this.spawnDaemon();
+                        }
+                    }, 1000);
+                }
+            });
+        }
+        catch (e) {
+            log('error', `[ha] spawn 守护进程失败: ${String(e?.message || e).slice(0, 160)}`);
+        }
+    }
+    /** 停止: 停 primary 心跳 + 杀 daemon (幂等) */
+    stop() {
+        this.stopped = true;
+        this.guard?.stop();
+        this.guard = null;
+        if (this.restartTimer) {
+            clearTimeout(this.restartTimer);
+            this.restartTimer = null;
+        }
+        if (this.daemon && !this.daemon.killed) {
+            try {
+                this.daemon.kill('SIGTERM');
+            }
+            catch { /* 忽略 */ }
+        }
+        // best-effort 清 primary 心跳
+        try {
+            const f = path.join(this.opts.home || os.homedir(), '.bolloon', 'kernel-ha', 'primary.heartbeat');
+            fs.unlinkSync(f);
+        }
+        catch { /* 忽略 */ }
+    }
+}
+/** 便捷工厂 */
+export function createHaSupervisor(opts = {}) {
+    return new HaSupervisor(opts);
+}

package/dist/agents/memory-store.js

@@ -353,6 +353,31 @@ export function formatRecallBlock(hits) {
     });
     return `<memory-context>\n${lines.join('\n')}\n</memory-context>`;
 }
+/**
+ * 稳态记忆块 (2026-10-15, 对齐 Hermes `_memory_parts` 的整块注入):
+ * 每次 build system prompt 时把「重要且稳定」的记忆整块给出 — 不依赖当轮 query 召回。
+ * 选材: ① crystallized (固化 = 用户确认过/多次命中) ② 未淡化 (decayed=false)
+ * ③ importance 降序; 上限 maxEntries (默认 6), 单条 120 字符摘要。
+ * 与 recall 互补: recall 是 query 驱动的即时相关, 这块是「始终可见的稳态事实」。
+ */
+export function formatMemorySystemBlock(entries, maxEntries = 6) {
+    const picked = entries
+        .filter((e) => !e.decayed) // 淡化中的不算稳态
+        .sort((a, b) => {
+        // 固化优先, 然后 importance 降序
+        if (a.crystallized !== b.crystallized)
+            return a.crystallized ? -1 : 1;
+        return b.importance - a.importance;
+    })
+        .slice(0, maxEntries);
+    if (!picked.length)
+        return '';
+    const lines = picked.map((e) => {
+        const tag = `${e.kind}${e.crystallized ? '★' : ''}`;
+        return `- (${tag}, ${e.importance.toFixed(2)}) ${e.content.slice(0, 120)}`;
+    });
+    return `<stable-memory>\n${lines.join('\n')}\n</stable-memory>`;
+}
 /** 测试辅助: 清空分桶 (隔离 HOME 时用) */
 export function resetMemoryStores() {
     stores.clear();

package/dist/agents/opportunity-match.js

@@ -114,6 +114,18 @@ export async function recordFeedback(action, sourceId) {
     await writeFeedback(fb);
     return { ok: true };
 }
+/** 按 provider DID 过滤 (通讯录卡片): 只留信箱投递人/搜索来源命中指定 DID 的; 本机 board 源无 DID → 过滤掉 */
+function filterByProviderDids(all, providerDids) {
+    if (!providerDids || !providerDids.length)
+        return all;
+    const set = new Set(providerDids.map((d) => String(d || '').trim()).filter(Boolean));
+    if (!set.size)
+        return all;
+    return all.filter((c) => {
+        const did = c.inbox?.providerDid || '';
+        return !!did && set.has(did);
+    });
+}
 function candidateOf(entry, intentId, score, reason, matchTags) {
     return {
         id: `opp_${entry.announcementId.slice(0, 12)}`,
@@ -229,7 +241,7 @@ export async function scanOpportunities(opts = {}) {
             for (const c of all.filter((x) => x.reason === 'match').slice(0, 10)) {
                 void noteObservation({ ts: Date.now(), kind: 'opportunity-seen', sourceId: c.sourceId, title: c.title, score: c.score, reason: 'match' });
             }
-            return { ok: true, results: (await mergeInboxOnTop(all)).slice(0, limit) };
+            return { ok: true, results: filterByProviderDids(await mergeInboxOnTop(all), opts.providerDids ?? []).slice(0, limit) };
         }
         // 默认世界流: 新鲜度优先
         const sorted = [...openEntries].sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0));
@@ -243,7 +255,7 @@ export async function scanOpportunities(opts = {}) {
         for (const c of out.slice(0, 10)) {
             void noteObservation({ ts: Date.now(), kind: 'world-change', sourceId: c.sourceId, title: c.title, score: c.score, reason: 'world' });
         }
-        return { ok: true, results: (await mergeInboxOnTop(out)).slice(0, limit) };
+        return { ok: true, results: filterByProviderDids(await mergeInboxOnTop(out), opts.providerDids ?? []).slice(0, limit) };
     }
     // 有意图: 匹配打分, match 优先; 世界变化不消失
     const matches = [];
@@ -274,7 +286,7 @@ export async function scanOpportunities(opts = {}) {
             return rank(a.reason) - rank(b.reason);
         return b.score - a.score;
     });
-    return { ok: true, results: (await mergeInboxOnTop(all)).slice(0, limit) };
+    return { ok: true, results: filterByProviderDids(await mergeInboxOnTop(all), opts.providerDids ?? []).slice(0, limit) };
 }
 /** 对单个意图即时匹配 (list --intent 用; 不走反馈过滤) */
 export async function matchOneIntentText(text, tags, budget, opts = {}) {

package/dist/agents/pi-sdk-session-manager.js

@@ -219,6 +219,14 @@ export class PiSessionManager {
     getPersona() {
         return this.persona;
     }
+    /**
+     * 2026-10-15 (对齐 Hermes invalidate_system_prompt): 重读 persona 源并刷新快照。
+     * persona.json / persona/<agentId>/*.md 在外被改时, 由上层 (pi-sdk) 检测指纹变化后调用,
+     * 让本轮 systemPrompt 就带上新 persona — 不再等 agent 重建/切 channel。
+     */
+    async reloadPersona() {
+        this.persona = await this.loadPersona();
+    }
     getState() {
         return { ...this.state, lastActive: new Date().toISOString() };
     }