@bolloon/bolloon-agent 0.6.5 → 0.6.7

package/dist/agents/chain/chain-settlement.js

@@ -18,7 +18,6 @@ import { loadChainConfig, DEFAULT_CONFIRMATIONS, } from './chain-config.js';
 /** ERC20 Transfer 事件 topic0 */
 export const ERC20_TRANSFER_TOPIC0 = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef';
 const ERC20_IFACE = new Interface(['event Transfer(address indexed from, address indexed to, uint256 value)']);
-const ZERO32 = '0x0000000000000000000000000000000000000000000000000000000000000000';
 function base(partial) {
     return {
         chainSettled: false,

package/dist/agents/chat-segmenter.js

@@ -44,25 +44,13 @@ export function segmentChatReply(reply, ctx) {
     if (remaining.trim()) {
         remaining = filterFillerText(remaining);
     }
-    // === 6. final 之前的 text 段 (中间对话) push — 必须在 final push 之前 ===
-    //   注意: 这时 remaining 还含 <final gen> 标记 + 标记后内容. 切 final 前先把 <final gen> 之后内容清掉
-    //   实际: 切 final 后再切 text 更清楚
-    const finalIdx = remaining.indexOf('<final gen>');
-    let beforeFinalText = remaining;
-    if (finalIdx >= 0) {
-        beforeFinalText = remaining.substring(0, finalIdx);
-    }
-    const textContent = beforeFinalText.trim();
+    // === 6. 剩余内容全部作为 text 段 (2026-10-12: 移除 <final gen> 后不再切 final segment) ===
+    //   旧实现找 `<final gen>` 标记把内容切成 before/after 两段; 标记已全项目移除,
+    //   剩余内容就是给用户的完整答复, 全部进 text。
+    const textContent = remaining.trim();
     if (textContent) {
         segments.push({ type: 'text', content: textContent });
     }
-    // === 7. 切 <final gen>...</final gen> (永远最后 push, 渲染时在最后) ===
-    if (finalIdx >= 0) {
-        const afterFinal = remaining.substring(finalIdx + '<final gen>'.length).trim();
-        if (afterFinal) {
-            segments.push({ type: 'final', content: afterFinal });
-        }
-    }
     return segments;
 }
 /**

package/dist/agents/contacts/human-directory.js

@@ -0,0 +1,155 @@
+/**
+ * human-directory.ts — 手机号 → DID 人类账号目录 (2026-10-11, phone-account-lookup-design §3)
+ *
+ * 落点 A (群内/已知盐目录, 推荐起步):
+ *   - 发布: 用户 opt-in → 本地算 HMAC(salt || phone, pepper) 盲化哈希 → 存目录条目
+ *   - 查询: 输入对方手机号 → 用同一算法算哈希 → 遍历本地目录比对 → 命中拿 DID
+ *   - 隐私: 目录永不存明文手机号 · 哈希带 per-user salt (不可离线枚举) ·
+ *           pepper 本地持有不进目录 · 未发布 = 查不到 (与不存在同义)
+ *
+ * 诚实边界 (写死):
+ *   - 落点 A 只能搜「已与你交换过 salt / 已加入同一群」的节点 (三角不可能: 隐私/可搜/去中心化只取二)
+ *   - 本模块只做「本地目录 + 哈希运算」; 跨节点查询靠既有 P2P (群目录复制 / direct 消息)
+ *   - pepper 是本机私密 (~/.bolloon/contacts/directory-pepper.json, 0600), 不进目录条目
+ */
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import { createHmac, randomBytes } from 'node:crypto';
+const home = () => process.env.HOME || os.homedir() || '/tmp';
+export function directoryPath(homeDir) {
+    return path.join(homeDir || home(), '.bolloon', 'contacts', 'human-directory.json');
+}
+/** pepper 路径 (0600 私密) */
+export function pepperPath(homeDir) {
+    return path.join(homeDir || home(), '.bolloon', 'contacts', 'directory-pepper.json');
+}
+/** 原子写: tmp + rename (写坏不残留半截文件; 0600 私密权限) */
+async function atomicWriteJson(file, value) {
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    const tmp = `${file}.tmp-${process.pid}-${Date.now().toString(36)}`;
+    await fs.writeFile(tmp, JSON.stringify(value, null, 2), { encoding: 'utf8', mode: 0o600 });
+    await fs.rename(tmp, file);
+}
+/** 读取/生成 pepper (首次生成随机 32 字节; 幂等复用) */
+export async function loadPepper(homeDir) {
+    const p = pepperPath(homeDir);
+    try {
+        const raw = await fs.readFile(p, 'utf8');
+        const j = JSON.parse(raw);
+        if (j?.pepper)
+            return j.pepper;
+    }
+    catch { /* 不存在 → 生成 */ }
+    const pepper = randomBytes(32).toString('hex');
+    await atomicWriteJson(p, { pepper });
+    return pepper;
+}
+/** 手机号归一化: 只留数字与 + (同一规则只此一处, 供校验与哈希共用) */
+export function normalizePhone(value) {
+    return String(value || '').replace(/[^\d+]/g, '');
+}
+/** 盲化哈希: HMAC-SHA256(salt || phone, pepper) → hex (同一输入永远同一输出) */
+export function blindHash(phone, salt, pepper) {
+    const normalized = normalizePhone(phone);
+    return createHmac('sha256', pepper).update(`${salt}||${normalized}`).digest('hex');
+}
+/** 生成 per-user salt */
+export function genSalt() {
+    return randomBytes(16).toString('hex');
+}
+/** 校验手机号形状 (宽松: 8-15 位数字, 可带 + 前缀) */
+export function isPlausiblePhone(value) {
+    return /^\+?\d{8,15}$/.test(normalizePhone(value));
+}
+/** 目录存储: 读/写原子 (与 contacts store 同模式) */
+export async function readDirectory(homeDir) {
+    try {
+        const raw = await fs.readFile(directoryPath(homeDir), 'utf8');
+        const j = JSON.parse(raw);
+        return Array.isArray(j) ? j : [];
+    }
+    catch (err) {
+        if (err?.code === 'ENOENT')
+            return [];
+        throw new Error(`手机号目录损坏 (${directoryPath(homeDir)}): ${err?.message || err}`);
+    }
+}
+async function writeDirectory(entries, homeDir) {
+    await atomicWriteJson(directoryPath(homeDir), entries);
+}
+/** 从本机 identity/user.json 读取 64 hex publicKey (目录发布自动带上, 供对方直达加好友) */
+export async function loadOwnPublicKeyHex(homeDir) {
+    try {
+        const p = path.join(homeDir || home(), '.bolloon', 'identity', 'user.json');
+        const j = JSON.parse(await fs.readFile(p, 'utf8'));
+        const pk = String(j?.publicKeyHex || '');
+        return /^[0-9a-f]{64}$/i.test(pk) ? pk.toLowerCase() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** 发布一条目录条目 (opt-in; 同 phoneHash 已存在 → 更新为最新, 撤销后重发 = 恢复) */
+export async function publishEntry(phone, did, opts = {}) {
+    if (!isPlausiblePhone(phone))
+        throw new Error('手机号格式不正确 (8-15 位数字, 可带 + 前缀)');
+    if (!did || !did.startsWith('did:'))
+        throw new Error('DID 格式不正确 (须以 did: 开头)');
+    const pepper = await loadPepper(opts.homeDir);
+    const salt = genSalt(); // 每次发布新 salt (旧哈希不可回推, 重发布 = 新哈希)
+    const publicKeyHex = opts.publicKeyHex
+        ? opts.publicKeyHex.toLowerCase()
+        : await loadOwnPublicKeyHex(opts.homeDir); // 缺省自动带本机 P2P 公钥 (若有)
+    const entry = {
+        phoneHash: blindHash(phone, salt, pepper),
+        salt,
+        did,
+        publicKeyHex,
+        displayName: opts.displayName,
+        publishedAt: new Date().toISOString(),
+        revokedAt: null,
+        ownerSig: '', // P2 落点 B 才要求签名
+    };
+    const entries = await readDirectory(opts.homeDir);
+    const idx = entries.findIndex((e) => e.did === did); // 同一 DID 只留一条 (更新)
+    if (idx >= 0)
+        entries[idx] = entry;
+    else
+        entries.push(entry);
+    await writeDirectory(entries, opts.homeDir);
+    return entry;
+}
+/** 撤销 (软删): 标记 revokedAt, 条目保留 (审计/可恢复) */
+export async function retractEntry(did, homeDir) {
+    const entries = await readDirectory(homeDir);
+    const e = entries.find((x) => x.did === did);
+    if (!e)
+        return false;
+    e.revokedAt = new Date().toISOString();
+    await writeDirectory(entries, homeDir);
+    return true;
+}
+/** 查询: 用同一算法算哈希, 遍历比对 (未发布/已撤销 → not found) */
+export async function lookupPhone(phone, homeDir) {
+    const pepper = await loadPepper(homeDir);
+    const entries = await readDirectory(homeDir);
+    // 对方的 salt 未知 → 逐个试本目录里的条目 salt (落点 A: 群小, N 可接受)
+    for (const e of entries) {
+        if (blindHash(phone, e.salt, pepper) === e.phoneHash) {
+            if (e.revokedAt)
+                return { found: false, revoked: true }; // 撤销 = 与不存在同义
+            return { found: true, did: e.did, publicKeyHex: e.publicKeyHex, displayName: e.displayName };
+        }
+    }
+    return { found: false };
+}
+/** 列出已发布条目 (本机审计用; 只回脱敏: 哈希前 8 位 + DID + 时间) */
+export function summarizeEntries(entries) {
+    return entries.map((e) => ({
+        hash: e.phoneHash.slice(0, 8) + '…',
+        did: e.did,
+        publishedAt: e.publishedAt,
+        revoked: !!e.revokedAt,
+    }));
+}

package/dist/agents/contacts/tools.js

@@ -150,5 +150,84 @@ export function registerContactTools(ctx, chain) {
         },
     });
     registered.push(...CONTACT_TOOL_NAMES);
+    // ── 手机号目录 (2026-10-11, phone-account-lookup-design 落点 A) ──────────
+    // 工具面: 发布自己的手机号指针 / 查对方 / 撤销。隐私: 只操作哈希, 明文手机号只在本机。
+    ctx.tools.set('directory.publish', {
+        name: 'directory.publish',
+        description: '把自己的手机号 → DID 指针发布到本机目录 (opt-in, 用户显式要求才做)。之后对方凭手机号可查到你的 DID 加好友。**先问用户确认**再调用 (发布手机号是隐私动作)。',
+        parameters: { phone: '手机号 (11 位, 可带 +86 前缀)', displayName: '公开昵称 (可选, 不是真名)' },
+        execute: async (args) => {
+            const { publishEntry, isPlausiblePhone } = await import('./human-directory.js');
+            const phone = text(args.phone);
+            if (!isPlausiblePhone(phone))
+                return { success: false, error: '手机号格式不正确 (8-15 位数字)' };
+            const did = globalThis.__bolloonUserDid || 'did:bolln:local';
+            const e = await publishEntry(phone, did, { displayName: text(args.displayName) || undefined });
+            return { success: true, phoneHash: e.phoneHash.slice(0, 8) + '…', did: e.did, note: '已发布到本机目录 (对方凭手机号可查到你的 DID)' };
+        },
+    });
+    ctx.tools.set('directory.lookup', {
+        name: 'directory.lookup',
+        description: '按手机号查对方 DID (在本机目录内找)。用于: 用户说"用手机号找 XX 加好友"、想加某人为好友但只有手机号。响应只回 DID/昵称, 不回手机号。',
+        parameters: { phone: '对方手机号 (11 位)' },
+        execute: async (args) => {
+            const { lookupPhone, isPlausiblePhone } = await import('./human-directory.js');
+            const phone = text(args.phone);
+            if (!isPlausiblePhone(phone))
+                return { success: false, error: '手机号格式不正确' };
+            const r = await lookupPhone(phone);
+            if (!r.found)
+                return { success: true, found: false, note: '未找到 (对方未注册目录或已撤销)' };
+            return { success: true, found: true, did: r.did, publicKeyHex: r.publicKeyHex || null, displayName: r.displayName || null, note: '已找到, 可用 directory.add_friend 发起好友请求' };
+        },
+    });
+    ctx.tools.set('directory.add_friend', {
+        name: 'directory.add_friend',
+        description: '按手机号发起好友申请: 目录 lookup → P2P friend request。用于用户明确说“用手机号加好友”。这是对外通信动作,调用前应确认目标手机号和用户意图; 对方仍需 consent 接受,不会自动成为好友。',
+        parameters: { phone: '对方手机号 (8-15 位)', name: '好友备注 (可选)', message: '申请附言 (可选)' },
+        execute: async (args) => {
+            const { lookupPhone, isPlausiblePhone } = await import('./human-directory.js');
+            const phone = text(args.phone);
+            if (!isPlausiblePhone(phone))
+                return { success: false, error: '手机号格式不正确' };
+            const r = await lookupPhone(phone);
+            if (!r.found)
+                return { success: true, found: false, note: '未找到 (对方未注册目录或已撤销)' };
+            if (!r.publicKeyHex)
+                return { success: false, found: true, did: r.did, error: '对方已公开目录但未发布 P2P 公钥, 暂时无法直接发好友请求' };
+            try {
+                const port = process.env.PORT || '54188';
+                const resp = await fetch(`http://127.0.0.1:${port}/api/friend-request`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        targetPublicKey: r.publicKeyHex,
+                        name: text(args.name) || r.displayName || undefined,
+                        message: text(args.message) || '来自手机号目录的好友申请',
+                        note: 'via-phone-directory',
+                    }),
+                });
+                const data = await resp.json();
+                return resp.ok
+                    ? { success: true, found: true, did: r.did, requestId: data.requestId, output: `已向 ${r.displayName || r.did} 发起好友申请; 对方同意后才会建立好友关系` }
+                    : { success: false, found: true, did: r.did, error: data.error || '好友申请发送失败', code: data.code };
+            }
+            catch (err) {
+                return { success: false, error: `好友申请链路不可用: ${String(err?.message || err)}` };
+            }
+        },
+    });
+    ctx.tools.set('directory.retract', {
+        name: 'directory.retract',
+        description: '从本机目录撤销自己的手机号 → DID 指针 (软删)。用于: 用户说"不要让别人查到我手机号了"。',
+        parameters: {},
+        execute: async () => {
+            const { retractEntry } = await import('./human-directory.js');
+            const did = globalThis.__bolloonUserDid || 'did:bolln:local';
+            const ok = await retractEntry(did);
+            return { success: ok, note: ok ? '已从目录撤销 (手机号不再可查)' : '目录里没有你的条目' };
+        },
+    });
+    registered.push('directory.publish', 'directory.lookup', 'directory.add_friend', 'directory.retract');
     return registered;
 }

package/dist/agents/experience-review.js

@@ -173,9 +173,6 @@ export function applyExperience(d, home = os.homedir(), nowIso = new Date().toIS
         return { wrote: false };
     }
 }
-function escapeRe(s) {
-    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
 /**
  * 自审编排 (纯旁路, **绝不抛错**)。
  *

package/dist/agents/goal-flywheel/goal-change.js

@@ -299,7 +299,7 @@ function impactFor(kind, scope) {
     };
 }
 const EMPTY_IMPACT = (scope) => impactFor('clarification', scope);
-function describeKind(kind, r, dir) {
+function describeKind(kind, dir) {
     switch (kind) {
         case 'abort':
             return `撤销/终止: 在下一个 Run 边界终止该目标 (优先级最高, 压过同批其余变更)`;
@@ -334,7 +334,6 @@ function describeKind(kind, r, dir) {
 export function classifyChange(r, goal) {
     if (TERMINAL_STATUSES.includes(r.status))
         return { ...r, appliesToFutureRunsOnly: true };
-    const t = lower(r.instruction);
     const criteria = Array.isArray(goal?.successCriteria) ? goal.successCriteria.map(String) : [];
     let intents = detectChangeIntents(r.instruction);
     if (intents.includes('success_criteria_change') && isCriteriaRestatement(r.instruction, criteria)) {
@@ -362,7 +361,7 @@ export function classifyChange(r, goal) {
             status: 'triaged',
             requiresReplan: false,
             impact: impactFor('abort', scope),
-            interpreted: `${describeKind('abort', r, null)}; 原文: ${head(r.instruction)}` +
+            interpreted: `${describeKind('abort', null)}; 原文: ${head(r.instruction)}` +
                 (superseded.length ? `; 同批的 ${superseded.join('/')} 一律作废 (superseded), 需单独重新提交` : ''),
         };
     }
@@ -386,7 +385,7 @@ export function classifyChange(r, goal) {
         status: 'triaged',
         requiresReplan: REPLAN_KINDS.has(kind),
         impact,
-        interpreted: `${KIND_LABELS[kind]}: ${describeKind(kind, r, dir)}; 影响面: ${impactLabel(impact)}; 原文: ${head(r.instruction)}`,
+        interpreted: `${KIND_LABELS[kind]}: ${describeKind(kind, dir)}; 影响面: ${impactLabel(impact)}; 原文: ${head(r.instruction)}`,
     };
 }
 function impactLabel(i) {

package/dist/agents/goal-resume.js

@@ -28,7 +28,6 @@
 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';
@@ -88,9 +87,6 @@ async function loadAllSnapshots() {
     }
     return out;
 }
-function newGoalId() {
-    return `goal-${Date.now()}-${crypto.randomBytes(3).toString('hex')}`;
-}
 // ============================================================
 // Park 现有 task (复用 task-state.ts 'paused' 状态)
 // ============================================================

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/intent-classifier.js

@@ -60,7 +60,7 @@ export function intentHint(intent) {
 2. 用 \`edit_file\` 精确定位改 (old_text 全文匹配) 或 \`write_file\` 整体覆写
 3. 改完跑 \`npx tsc --noEmit\` 和 \`npx vitest run --reporter=dot --bail=1\` 验证
 4. 用 \`git_commit\` 提交到当前分支 (分支名 agent/<task-id>)
-不要调用 \`<final gen>\` 标记除非任务真正完成 (commit + 测试通过).
+不要提前收尾: 任务真正完成 (commit + 测试通过) 之前持续调用工具推进.
 
 ## 信息不足时主动查询
 **重要**: 不要假设! 如果任何步骤信息不足 (路径不明确/命令参数不知道/分支策略不清楚/保护规则不明白), 用工具主动查:

package/dist/agents/iteration-budget.js

@@ -1,3 +1,15 @@
+/**
+ * 迭代预算 (2026-10-01 落实第二轮: 学的是"**可退还**的迭代预算"那套)。
+ *
+ * 意图: 惩罚**零碎**调用, 奖励**批处理** —— 一次调用干多件事(程序化工具调用)不该吃预算。
+ *   用户的抱怨正是"一件小事花太多次工具调用" ⇒ 把预算变成**激励**而不是单纯的刹车。
+ * 设计对齐 (只搬约束, 不搬实现):
+ *   · `consume()` 扣一次; **`refund()` 还一次** —— 批处理工具(见 REFUNDABLE_TOOLS)调用后归还;
+ *   · 每个 agent 一份(父/子各自的 cap 不同);
+ *   · 阈值**警告**(默认 80%) ⇒ 提前提示, 而不是到顶了才硬停;
+ *   · 非法配置 **fail-open**(坏值当关闭, 绝不因配置坏掉就把 agent 卡死)。
+ * 纪律: 这是**记账 + 激励**, 不做硬刹车 —— 循环退出条件仍由调用方决定(它读 effective 值)。
+ */
 /**
  * 这些工具"一次调用可顶多次操作" ⇒ 用它换来的迭代要**退还**。
  * 加新工具时问自己: 它能不能在一次调用里做完 N 件事? 能 ⇒ 加进来。

package/dist/agents/knowledge-organizer.js

@@ -419,7 +419,6 @@ export async function maintainGoals(home, llm) {
         const queue = (await readJson(path.join(goalsDir, 'queue.json'))) || {};
         // queue.json 结构未知, 兼容 object/array
         const queueItems = Array.isArray(queue) ? queue : Object.values(queue).filter((v) => v && typeof v === 'object');
-        const events = await readDir(goalsDir);
         const now = new Date().toISOString().slice(0, 10);
         const currentDir = path.join(home, '.bolloon', 'context-os', '03-Current');
         const currentFiles = (await listMd(currentDir)).filter((f) => f.file !== 'README.md');
@@ -453,7 +452,6 @@ export async function maintainGoals(home, llm) {
 /** 自动整理心跳 · 知识层: 串行跑全部 9 个整理器, 汇总 sections */
 export async function runKnowledgeOrganize(opts = {}) {
     const home = opts.home || os.homedir();
-    const cwd = opts.cwd || process.cwd();
     const llm = opts.llm;
     const sections = [];
     sections.push(await archiveContextOs(home));

package/dist/agents/lesson-to-skill.js

@@ -198,7 +198,6 @@ export function routeLessonToSkill(lesson, skills, home = os.homedir()) {
         // 命中了但写不进去(文件读不到/空) ⇒ 退到沉淀技能, 保证"都进去" ✓
     }
     const sink = ensureSinkSkill(home);
-    const body = fs.readFileSync(sink.file, 'utf-8');
     const withCandidates = d.suggestions.length
         ? { ...lesson, body: `${lesson.body} (候选技能: ${d.suggestions.map((s) => `${s.name}(${s.score})`).join(', ')})` }
         : lesson;

package/dist/agents/loop-review.js

@@ -61,9 +61,9 @@ export function buildReviewHint(state, maxReviews = DEFAULT_MAX_REVIEWS) {
         `\n用户需求: ${intent.slice(0, 300)}` +
         actionLines +
         `\n已完成工具: ${tools}` +
-        `\n[完成契约] 宣布 <final gen> 前必须展示具体证据 (命令输出 / 文件内容 / 测试结果), 只写结论不算完成.` +
+        `\n[完成契约] 宣布完成前必须展示具体证据 (命令输出 / 文件内容 / 测试结果), 只写结论不算完成.` +
         `\n请对照需求逐条自查: 用户需求是否每一项都真正完成了? 如果还有未完成的子目标或自然衔接的后续步骤 → 继续调用工具推进 (已完成动作不要重复, 直接基于已有结果做下一步); ` +
-        `如果用户需求已全部满足 → 直接输出 <final gen> 结束.` +
+        `如果用户需求已全部满足 → 直接给出完整最终回答结束.` +
         `\n[重要] 不要因为做了一部分就提前结束 — 结束前逐条对照「用户需求」确认每一项都完成.`);
 }
 /** 布尔门: 是否该继续 review (测试/消融快速断言) */