@bolloon/bolloon-agent 0.6.5 → 0.6.7

package/dist/kernel/ha/ha-arbiter.js

@@ -0,0 +1,177 @@
+/**
+ * ha-arbiter.ts — Kernel 双活仲裁器 (2026-10-16, leo: 双内核冗余第一刀)
+ *
+ * 职责: 同机两个 bolloon 进程各自加载 kernel, 通过**心跳文件**互相探测,
+ *      主进程死亡时备进程接管其 orphan run (复用 reconcileOrphans + prepareResume)。
+ *
+ * 设计 (对齐 tick-lock 跨进程先例):
+ *   - 心跳文件 `~/.bolloon/kernel-ha/<role>.heartbeat` = JSON {pid, host, role, startedAt, lastBeat, runIds[], kernelVersion}
+ *   - 主进程每 BEAT_MS (10s) 写自己的心跳 (含当前 runIds); 备进程每 BEAT_MS 探测主心跳
+ *   - 角色仲裁: 抢 `~/.bolloon/kernel-ha/.primary.lock` (O_EXCL 原子创建) — 防双主
+ *   - 主心跳过期 (lastBeat 超过 STALE_MS=30s 或 pid 已死) → 备**接管**:
+ *       ① 标记本机 role=primary (抢锁)
+ *       ② reconcileOrphans() 找主进程留下的 orphan run
+ *       ③ 逐个 prepareResume(runId) 确认可恢复 → 记入本机心跳 runIds
+ *       ④ 心跳文件切 role=primary
+ *   - 纯函数可单测: parseHeartbeat / isHeartbeatStale / decideTakeover / serializeHeartbeat
+ */
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+export const BEAT_MS = 10_000; // 心跳间隔
+export const STALE_MS = 30_000; // 心跳过期阈值 (3 倍间隔)
+export const PRIMARY_LOCK_STALE_MS = 60_000;
+/** HA 数据目录 ~/.bolloon/kernel-ha */
+export function haDir(home = os.homedir()) {
+    return path.join(home, '.bolloon', 'kernel-ha');
+}
+export function heartbeatPath(role, home = os.homedir()) {
+    return path.join(haDir(home), `${role}.heartbeat`);
+}
+export function primaryLockPath(home = os.homedir()) {
+    return path.join(haDir(home), '.primary.lock');
+}
+// ---------------------------------------------------------------- 纯函数
+/** 序列化心跳 (原子写用) */
+export function serializeHeartbeat(rec) {
+    return JSON.stringify(rec, null, 2);
+}
+/** 解析心跳文件内容 — 坏行/畸形一律 ok:false (fail-closed) */
+export function parseHeartbeat(raw) {
+    try {
+        const p = JSON.parse(raw);
+        if (!p || typeof p !== 'object')
+            return { ok: false, error: 'not-object' };
+        if (typeof p.pid !== 'number' || typeof p.host !== 'string' || typeof p.role !== 'string') {
+            return { ok: false, error: 'missing-fields' };
+        }
+        if (p.role !== 'primary' && p.role !== 'standby')
+            return { ok: false, error: 'bad-role' };
+        const record = {
+            pid: p.pid,
+            host: p.host,
+            role: p.role,
+            startedAt: typeof p.startedAt === 'string' ? p.startedAt : new Date().toISOString(),
+            lastBeat: typeof p.lastBeat === 'string' ? p.lastBeat : new Date().toISOString(),
+            runIds: Array.isArray(p.runIds) ? p.runIds.filter((x) => typeof x === 'string') : [],
+            kernelVersion: typeof p.kernelVersion === 'string' ? p.kernelVersion : '',
+        };
+        return { ok: true, record };
+    }
+    catch (e) {
+        return { ok: false, error: String(e?.message || e).slice(0, 80) };
+    }
+}
+/** 心跳是否过期: lastBeat 距今 > staleMs, 或 pid 已不存在 */
+export function isHeartbeatStale(rec, now = Date.now(), staleMs = STALE_MS) {
+    const last = Date.parse(rec.lastBeat);
+    if (!Number.isFinite(last))
+        return true; // 坏时间 → 判过期 (fail-closed)
+    if (now - last > staleMs)
+        return true;
+    // pid 不存在 = 进程已死 → 判过期
+    try {
+        process.kill(rec.pid, 0);
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * 是否接管: 主心跳缺失 / 解析失败 / 过期 → true。
+ * 纯函数 (不含抢锁副作用), 调用方拿到 true 再走 acquirePrimaryLock。
+ */
+export function decideTakeover(primaryBeat, now = Date.now(), staleMs = STALE_MS) {
+    if (!primaryBeat || !primaryBeat.ok)
+        return { takeover: true, reason: 'primary-heartbeat-missing' };
+    const rec = primaryBeat.record;
+    if (isHeartbeatStale(rec, now, staleMs))
+        return { takeover: true, reason: 'primary-heartbeat-stale' };
+    return { takeover: false, reason: 'primary-alive' };
+}
+// ---------------------------------------------------------------- 副作用 (原子写 / 锁)
+/** 原子写心跳文件 (tmp + rename) */
+export async function writeHeartbeat(rec, home = os.homedir()) {
+    await fs.mkdir(haDir(home), { recursive: true });
+    const target = heartbeatPath(rec.role, home);
+    const tmp = target + '.tmp';
+    await fs.writeFile(tmp, serializeHeartbeat(rec), { mode: 0o600 });
+    await fs.rename(tmp, target);
+}
+/** 抢主锁 (O_EXCL 原子创建; 已存在且持锁者存活 → 未抢到; 陈旧 → 回收重试一次) */
+export async function acquirePrimaryLock(pid, host, home = os.homedir(), staleMs = PRIMARY_LOCK_STALE_MS) {
+    const lockPath = primaryLockPath(home);
+    await fs.mkdir(haDir(home), { recursive: true });
+    const content = JSON.stringify({ pid, host, at: new Date().toISOString() });
+    try {
+        await fs.writeFile(lockPath, content, { flag: 'wx', mode: 0o600 });
+        return { acquired: true, reason: 'created' };
+    }
+    catch (e) {
+        if (e?.code !== 'EEXIST')
+            return { acquired: false, reason: String(e?.message || e).slice(0, 80) };
+        // 已存在 → 判陈旧
+        let holder = {};
+        try {
+            holder = JSON.parse(await fs.readFile(lockPath, 'utf-8'));
+        }
+        catch { /* 坏锁文件 → 视为陈旧 */ }
+        const holderAlive = holder && typeof holder.pid === 'number' && (() => { try {
+            process.kill(holder.pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        } })();
+        const fresh = holderAlive;
+        if (fresh)
+            return { acquired: false, reason: 'held-by-alive-primary' };
+        // 陈旧 → 回收重试一次
+        try {
+            await fs.unlink(lockPath);
+        }
+        catch { /* 忽略 */ }
+        try {
+            await fs.writeFile(lockPath, content, { flag: 'wx', mode: 0o600 });
+            return { acquired: true, reason: 'reclaimed-stale' };
+        }
+        catch {
+            return { acquired: false, reason: 'reclaim-race-lost' };
+        }
+    }
+}
+/** 读主心跳 (不存在 → null; 坏内容 → ok:false) */
+export async function readPrimaryHeartbeat(home = os.homedir()) {
+    try {
+        const raw = await fs.readFile(heartbeatPath('primary', home), 'utf-8');
+        return parseHeartbeat(raw);
+    }
+    catch (e) {
+        if (e?.code === 'ENOENT')
+            return null; // 主心跳还没写过 = 缺失
+        return { ok: false, error: String(e?.message || e).slice(0, 80) };
+    }
+}
+/** 当前活跃 runIds: 扫 runs 目录里 status ∈ running/recovering/interrupted 的 run */
+export async function collectActiveRunIds(runsDir, now = Date.now()) {
+    try {
+        const names = await fs.readdir(runsDir);
+        const out = [];
+        for (const n of names) {
+            if (!n.endsWith('.json') || n.endsWith('.bak'))
+                continue;
+            try {
+                const rec = JSON.parse(await fs.readFile(path.join(runsDir, n), 'utf-8'));
+                if (rec && typeof rec.status === 'string' && ['running', 'recovering', 'interrupted'].includes(rec.status)) {
+                    out.push(n.replace(/\.json$/, ''));
+                }
+            }
+            catch { /* 坏 run 文件跳过 */ }
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}

package/dist/kernel/ha/ha-guard.js

@@ -0,0 +1,151 @@
+/**
+ * ha-guard.ts — Kernel 双活守护循环 (2026-10-16, leo: 双内核冗余 — 独立 kernel 守护进程)
+ *
+ * 职责: 心跳循环 + 对等探测 + 接管 orphan run。
+ *
+ * 边界 (K1 目录边界: kernel 只做机制, 不碰业务):
+ *   - 本文件**不 import** 任何业务模块 (run-store / supervisor 等);
+ *   - reconcileOrphans / prepareResume / collectActiveRunIds 全部**端口注入**,
+ *     由调用方 (主进程) 把业务实现传进来 —— 守护循环只负责「什么时候探测/什么时候接管/接管几步」。
+ *
+ * 循环语义:
+ *   - 每 BEAT_MS 写自己的心跳 (含当前活跃 runIds, 由注入的 collectActiveRunIds 提供)
+ *   - 每 BEAT_MS 读对端 (primary) 心跳 → decideTakeover
+ *   - 判定接管 → acquirePrimaryLock (防双主) → 接管步骤 (注入的 takeoverRuns):
+ *       ① reconcileOrphans() 找主进程留下的 orphan run
+ *       ② 逐个 prepareResume(runId) 确认可恢复
+ *       ③ 记入自己的心跳 runIds
+ *       ④ 自己的心跳 role 切 primary
+ *   - 一次接管只做一轮; 下轮心跳若 primary 复活 (心跳新鲜) → 备进程让位 (不主动降级, 由仲裁决定)
+ *
+ * 退出: stop() 幂等; 进程退出时 best-effort 清心跳 (防止陈旧心跳误导对端判接管)。
+ */
+import { BEAT_MS, STALE_MS, writeHeartbeat, readPrimaryHeartbeat, decideTakeover, acquirePrimaryLock, } from './ha-arbiter.js';
+import * as fsSync from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+const noop = () => { };
+/** 构造一条心跳记录 */
+export function makeHeartbeat(role, runIds, kernelVersion = '') {
+    const now = new Date().toISOString();
+    return {
+        pid: process.pid,
+        host: os.hostname(),
+        role,
+        startedAt: now,
+        lastBeat: now,
+        runIds: runIds || [],
+        kernelVersion: String(kernelVersion || '').slice(0, 40),
+    };
+}
+/**
+ * 一次探测+可能的接管 (纯编排, 可单测)。
+ * 返回 { action: 'beat' | 'takeover' | 'noop' } — noop = 本进程是 primary, 只写心跳。
+ */
+export async function guardTick(ports, opts, state) {
+    const log = opts.log || ((_l, _m) => { });
+    const home = opts.home || os.homedir();
+    const beatMs = opts.beatMs ?? BEAT_MS;
+    const staleMs = opts.staleMs ?? STALE_MS;
+    const collect = ports.collectActiveRunIds || (async () => []);
+    // ① 收集当前活跃 runIds (本机)
+    const runIds = await collect();
+    if (opts.role === 'primary') {
+        // 主进程: 写心跳, 什么都不用探测 (备进程会探测我)
+        const rec = makeHeartbeat('primary', runIds, opts.kernelVersion);
+        await writeHeartbeat(rec, home);
+        state.lastBeatAt = rec.lastBeat;
+        state.beats++;
+        if (opts.onBeat)
+            opts.onBeat(rec);
+        return { action: 'noop' };
+    }
+    // ② 备进程: 探测主进程心跳
+    const primaryBeat = await readPrimaryHeartbeat(home);
+    const decision = decideTakeover(primaryBeat, Date.now(), staleMs);
+    if (!decision.takeover) {
+        // 主还活着 → 备待命 (写自己的 standby 心跳, 供观察; 不接管)
+        const rec = makeHeartbeat('standby', runIds, opts.kernelVersion);
+        await writeHeartbeat(rec, home);
+        state.lastBeatAt = rec.lastBeat;
+        state.beats++;
+        if (opts.onBeat)
+            opts.onBeat(rec);
+        // 2026-10-16: 待命 tick 打一条 (verify/诊断用; 生产可忽略)
+        if (process.env.BOLLOON_HA_DEBUG === '1')
+            log('info', `standby 待命 beat#${state.beats} (primary alive)`);
+        return { action: 'beat' };
+    }
+    // ③ 判定接管: 抢主锁 (防双主), 抢到才接
+    const lock = await acquirePrimaryLock(process.pid, os.hostname(), home);
+    if (!lock.acquired) {
+        log('warn', `接管被拒: ${lock.reason} (另一进程已抢到主锁)`);
+        return { action: 'noop' };
+    }
+    // ④ 接管步骤: reconcileOrphans → prepareResume 逐个 → 记入心跳 runIds
+    let adopted = [];
+    try {
+        const orphan = await ports.reconcileOrphans();
+        adopted = [...orphan.interrupted];
+        const resumed = [];
+        for (const runId of orphan.interrupted) {
+            const r = await ports.prepareResume(runId);
+            if (r.ok)
+                resumed.push(runId);
+            else
+                log('warn', `接管 ${runId} 未恢复: ${r.reason || ''}`);
+        }
+        adopted = resumed;
+        // 接管后本机心跳提升为 primary (包含接管的 run)
+        const rec = makeHeartbeat('primary', [...runIds, ...resumed], opts.kernelVersion);
+        await writeHeartbeat(rec, home);
+        state.lastBeatAt = rec.lastBeat;
+        state.adoptedRunIds = resumed;
+        state.role = 'primary';
+        state.takeovers++;
+        if (opts.onTakeover)
+            opts.onTakeover({ adoptedRunIds: resumed, reason: decision.reason });
+        return { action: 'takeover', adoptedRunIds: resumed, reason: decision.reason };
+    }
+    catch (e) {
+        log('error', `接管失败: ${String(e?.message || e).slice(0, 200)}`);
+        return { action: 'noop' };
+    }
+}
+/** 持续守护循环 (每 beatMs 一次 guardTick); stop() 幂等停止 */
+export function startHaGuard(ports, opts) {
+    const state = { running: true, role: opts.role, beats: 0, takeovers: 0, lastBeatAt: null, adoptedRunIds: [] };
+    const beatMs = opts.beatMs ?? BEAT_MS;
+    let timer = null;
+    const tick = async () => {
+        if (!state.running)
+            return;
+        try {
+            await guardTick(ports, opts, state);
+        }
+        catch (e) {
+            (opts.log || noop)('error', `guardTick 异常: ${String(e?.message || e).slice(0, 160)}`);
+        }
+    };
+    // 首跳立即执行 (不等一个 beatMs)
+    void tick();
+    timer = setInterval(() => { void tick(); }, beatMs);
+    // 2026-10-16 修复: **不 unref** — daemon 是 spawn 出来的独立守护进程, 必须持续跑。
+    //   旧代码 unref() 导致事件循环只剩 interval 时 (stdio pipe 不算活跃句柄),
+    //   daemon 首跳写完心跳后进程直接退出 → 永远等不到接管 (真跑验证撞出的硬坑)。
+    //   只有「不拖住宿主退出」的场景才该 unref (如 CLI 内嵌的心跳), daemon 不属于那种。
+    const stop = () => {
+        state.running = false;
+        if (timer) {
+            clearInterval(timer);
+            timer = null;
+        }
+        // best-effort 清自己的心跳 (防陈旧误导对端判接管) — 静态 fsSync (打包面禁 require)
+        try {
+            const f = path.join(opts.home || os.homedir(), '.bolloon', 'kernel-ha', `${opts.role}.heartbeat`);
+            fsSync.unlinkSync(f);
+        }
+        catch { /* 清理失败不影响退出 */ }
+    };
+    return { stop, state: () => ({ ...state }) };
+}

package/dist/kernel/index.js

@@ -0,0 +1,36 @@
+/**
+ * @bolloon/bolloon-kernel — Bolloon Native Macro-Kernel SDK 出口
+ *
+ * 进程内 Agent 内核机制层（统一调度 · 共享状态受控 · 端口注入 · 零业务依赖）。
+ *
+ * 设计页: docs/wiki/bolloon-native-macro-kernel.md
+ * 出口纪律:
+ *   · 只导出「机制」—— 不导出任何业务判定（Kernel 判据: 不判"该不该继续"、不判"算不算完成"）。
+ *   · 只导出「运行时机制」—— gate-scan / roster / plan-* 是 Bolloon 仓库治理件（判据与台账），
+ *     面向本仓的门（kernel-boundary / kernel-authority / kernel-gate-scan 等测试）直接吃源码，
+ *     不进 SDK 出口。
+ *   · 依赖面: 除 node: 内置外零依赖 —— 每个模块的 I/O 走端口注入，调用方给什么就用什么。
+ *
+ * 模块速览:
+ *   channel-actor   K5  ChannelActor + SerialMailbox（同 channel 串行、异 channel 并发、ALS 重入）
+ *   model-runtime   K6  ModelRuntime.acquire(snapshot) 只读租约（连接复用/超时/取消/退避/熔断）
+ *   control         命令式控制面（pause / resume / abort / recover）
+ *   run-lifecycle   Run 生命周期写口（start-run / record-step / finish-run / save-checkpoint）
+ *   session-lifecycle 会话规则（持久化映射 / 过滤水合 / 运行种子合并）
+ *   run-resume      恢复编排（漂移上报 / 核对失败不阻塞 / 单次语义）
+ *   turn-selfcheck  回合末自检编排（fail-closed: 被拒/门抛错 ⇒ 零执行且可见）
+ *   code-write-gate 写代码工具判定（哪个写操作产出 TS · 收尾要不要跑 tsc）
+ *   transport       通信端口（send / broadcast / peers，未注入即拒）
+ */
+export * from './channel-actor.js';
+export * from './model-runtime.js';
+export * from './control.js';
+export * from './run-lifecycle.js';
+export * from './session-lifecycle.js';
+export * from './run-resume.js';
+export * from './turn-selfcheck.js';
+export * from './code-write-gate.js';
+export * from './transport.js';
+// 2026-10-16 (leo: 双内核冗余): Kernel 双活 — 心跳仲裁 (纯机制) + 守护循环 (端口注入)
+export * from './ha/ha-arbiter.js';
+export * from './ha/ha-guard.js';

package/dist/kernel/model-runtime.js

@@ -179,7 +179,14 @@ export class ModelRuntime {
             call: async (req, opts) => {
                 if (released)
                     return { ok: false, error: '租约已归还' };
-                const budget = snapshotReadonly.timeoutMs ?? this.defaultTimeoutMs;
+                // 2026-10-13 (leo: 「多步执行的任务会返回空」根因链的②): 30s 硬超时与上下文长度脱钩 ——
+                //   多步任务工具多轮后 prompt 膨胀到 40KB+, 模型生成要更久, 30s 一到就被杀。
+                //   预算 = max(配置/默认, 上下文长度自适应): 每 1KB 上下文给 4s, 再加 10s 生成余量。
+                //   长上下文不被误杀; 短上下文仍是 30s 底线 (供应商真慢照样暴露, 不掩盖问题)。
+                const baseBudget = snapshotReadonly.timeoutMs ?? this.defaultTimeoutMs;
+                const ctxChars = String(req?.context ?? '').length + String(req?.systemPrompt ?? '').length;
+                const adaptive = Math.ceil(ctxChars / 1024) * 4_000 + 10_000;
+                const budget = Math.max(baseBudget, adaptive);
                 const external = opts?.signal;
                 if (external?.aborted) {
                     self.stats.aborts += 1;

package/dist/kernel/plan.js

@@ -79,7 +79,7 @@ export const ENTRY_GRAPH = [
     { file: 'agents/pi-sdk.ts', kind: 'adapter-internal', method: 'promptStream', count: 1, path: 'direct', targetPhase: 'K4', note: "runExecution 的流式派发 (K5 步骤⑦ 新增)" },
     { file: 'agents/pi-sdk.ts', kind: 'adapter-internal', method: 'promptWithPivotLoop', count: 2, path: 'direct', targetPhase: 'K4', note: "适配器内部 pivot 分派 (不是外部入口)" },
     { file: 'cli/interface.ts', kind: 'readline-tui', method: 'prompt', count: 3, path: 'queued', targetPhase: 'K3', note: "readline 输入提示, 非 agent 入口" },
-    { file: 'index.ts', kind: 'agent-entry', method: 'prompt', count: 7, path: 'direct', targetPhase: 'K3', note: "CLI 装配点" },
+    { file: 'index.ts', kind: 'agent-entry', method: 'prompt', count: 6, path: 'direct', targetPhase: 'K3', note: "CLI 装配点 (2026-10-16 并行线: prompt 调用点 7→6)" },
     { file: 'index.ts', kind: 'agent-entry', method: 'promptStream', count: 1, path: 'direct', targetPhase: 'K3', note: "CLI 装配点" },
 ];
 /**
@@ -87,7 +87,7 @@ export const ENTRY_GRAPH = [
  * ⚠️ 24 → **25** (2026-10-02, K5 步骤⑦): `runExecution` 内部新增 `prompt`/`promptStream` 派发各 1 处 (+2),
  *    web/server.ts 用户消息路径改成请求式 (-1)。**这是"形态变化"不是"旁路复活"** —— 见 ENTRY_GRAPH 的两行 adapter-internal。
  */
-export const ENTRY_DIRECT_CALLS_FROZEN_AT = 13; // 2026-10-02: 20 → 16 → 13 (K8 第四/五步: server.ts 7 处全迁; 只剩 CLI 侧 index.ts 的 8 处)   // 2026-10-02: 25 → 20 (K8: 5 处改走 runExecution; 棘轮只许降)
+export const ENTRY_DIRECT_CALLS_FROZEN_AT = 12; // 2026-10-16: 13 → 12 (并行线 src/index.ts prompt 调用点 7→6)   // 2026-10-02: 20 → 16 → 13 (K8 第四/五步: server.ts 7 处全迁; 只剩 CLI 侧 index.ts 的 8 处)   // 2026-10-02: 25 → 20 (K8: 5 处改走 runExecution; 棘轮只许降)
 export const DELETION_LEDGER = [
     {
         target: 'src/constraint-runtime/src/migrations/',
@@ -144,6 +144,6 @@ export const DELETION_LEDGER = [
     },
 ];
 /** 第一批删除候选 = 产品码里 **0 入边引用** 且非入口形态 (机械派生, 不手写) */
-export const DELETION_CANDIDATE_COUNT = 94;
-export const DELETION_CANDIDATE_SHA256 = '8ec437279513ddb82e0d909338c84d003486c3905143615b2b86f76d0d070112';
-export const DELETION_CANDIDATE_DIRS = { "agents": 5, "bollharness-integration": 1, "bollharness": 61, "cli": 1, "(根)": 1, "judgeness": 3, "llm": 1, "network": 3, "orbitdb": 2, "scripts": 1, "social": 2, "utils": 3, "web": 10 };
+export const DELETION_CANDIDATE_COUNT = 100;
+export const DELETION_CANDIDATE_SHA256 = '8f70bd1370cdb1c37aabdb19feb9d46d55fb51b8072b0ecf4f77f51b618a9478';
+export const DELETION_CANDIDATE_DIRS = { "agents": 10, "bollharness-integration": 1, "bollharness": 61, "cli": 1, "(根)": 1, "judgeness": 3, "llm": 1, "network": 3, "orbitdb": 2, "scripts": 1, "social": 2, "utils": 3, "web": 11 };

package/dist/kernel/roster.js

@@ -100,7 +100,7 @@ export const KERNEL_ALLOWED_IMPORT_PREFIXES = ['kernel/'];
  * 判据是**双向相等**: 盘上多一个未登记文件 ⇒ 红; 名册有而盘上没有 ⇒ 红。
  * (先例: SEAM_ROSTER 的「名册外无人越界」)
  */
-export const KERNEL_FILES = ['kernel/channel-actor.ts', 'kernel/control.ts', 'kernel/run-lifecycle.ts', 'kernel/transport.ts', 'kernel/session-lifecycle.ts', 'kernel/code-write-gate.ts', 'kernel/turn-selfcheck.ts', 'kernel/run-resume.ts', 'kernel/gate-scan.ts', 'kernel/model-runtime.ts', 'kernel/plan-harness.ts', 'kernel/plan-modelruntime.ts', 'kernel/plan-constraint.ts', 'kernel/plan-channel-actor.ts', 'kernel/plan-deletion.ts', 'kernel/plan-runcontext.ts', 'kernel/plan-communication.ts', 'kernel/plan.ts', 'kernel/roster.ts'];
+export const KERNEL_FILES = ['kernel/channel-actor.ts', 'kernel/control.ts', 'kernel/run-lifecycle.ts', 'kernel/transport.ts', 'kernel/session-lifecycle.ts', 'kernel/code-write-gate.ts', 'kernel/turn-selfcheck.ts', 'kernel/run-resume.ts', 'kernel/gate-scan.ts', 'kernel/model-runtime.ts', 'kernel/index.ts', 'kernel/ha/ha-arbiter.ts', 'kernel/ha/ha-guard.ts', 'kernel/plan-harness.ts', 'kernel/plan-modelruntime.ts', 'kernel/plan-constraint.ts', 'kernel/plan-channel-actor.ts', 'kernel/plan-deletion.ts', 'kernel/plan-runcontext.ts', 'kernel/plan-communication.ts', 'kernel/plan.ts', 'kernel/roster.ts'];
 /** Goal 事实的写入口 (goal-store.ts 的导出中带副作用的那些) */
 export const GOAL_WRITES = [
     'createGoal',
@@ -230,9 +230,9 @@ export const AUTHORITY_DEBT_FROZEN_AT = 0; // 3 → 0 (K4 用内核控制面还
  * 目的只有一个: **不许所有逻辑回流到 kernel.ts**。要加就得显式抬这个数字, 留下痕迹。
  * 数值 = 当前 kernel 目录真实行数, 不留余量。
  */
-export const KERNEL_LINE_BUDGET = 3852; // 2026-10-02: 收尾自检规则 `kernel/code-write-gate.ts` 从 agents 侧整条搬入 (+49, 减法: agent 侧少一个模块)   // 2026-10-02: 会话生命周期端口 `kernel/session-lifecycle.ts` (278 行) + `gate-scan` 播种锚点跟形状 (+4) —— **显式抬档 +282** (K10 余项; pi-sdk 本批 -18 行);   // 2026-10-02 **显式抬档 +22** (K8 收尾: channel-actor 加 `abortActorsOfChannel` + 台账/门同步)   // 2026-10-02 **显式抬档 +16** (K10 ④ 后半: transport.ts 加同步读入口 `transportPeersSync` + `peersSync` 端口)   // 2026-10-02 **显式抬档 +145** (K10 ④: 新增内核模块 kernel/transport.ts —— 通信入口端口)   // 2026-10-02 **显式抬档 +184** (K10 ①: 新增内核模块 kernel/run-lifecycle.ts —— 运行生命周期写口, 与 control.ts 的控制面分开; 预算 == 真实值)   // 2026-10-02: +1 (K4-B: gate-scan 复位阈值注释)   // 2026-10-02: +5 (K8 正刀: gate-scan 加"收口字段数 3→1"+ queue 反回归)   // 2026-10-02: +54 (K8: gate-scan 加 K8 判据)   // 2026-10-02: +2 (STAGE_STATUS 拆 K4-A/K4-B + K6/K7 如实修正)
+export const KERNEL_LINE_BUDGET = 4302; // 2026-10-16: **显式抬档 +379** (重构: 删重复 re-export + fsSync 泄漏, 4304→4302) (Kernel 双活: 新增 kernel/ha/ha-arbiter.ts 心跳仲裁 + kernel/ha/ha-guard.ts 守护循环, 纯机制零业务 import; 守护进程宿主在 src/agents/ha-daemon.ts 不占 kernel 预算)   // 2026-10-16: **显式抬档 +38** (10-13/14 两笔 loop 机制: model-runtime 超时预算按上下文长度自适应 +8 / channel-actor Ctrl+C 取消信号 ALS 注入 +33, 均无可删的真实功能)   // 2026-10-12: **显式抬档 +33** (kernel SDK 独立 npm 包: 新增 `kernel/index.ts` 出口, 零业务 import 纯 `export *`)   // 2026-10-02: 收尾自检规则 `kernel/code-write-gate.ts` 从 agents 侧整条搬入 (+49, 减法: agent 侧少一个模块)   // 2026-10-02: 会话生命周期端口 `kernel/session-lifecycle.ts` (278 行) + `gate-scan` 播种锚点跟形状 (+4) —— **显式抬档 +282** (K10 余项; pi-sdk 本批 -18 行);   // 2026-10-02 **显式抬档 +22** (K8 收尾: channel-actor 加 `abortActorsOfChannel` + 台账/门同步)   // 2026-10-02 **显式抬档 +16** (K10 ④ 后半: transport.ts 加同步读入口 `transportPeersSync` + `peersSync` 端口)   // 2026-10-02 **显式抬档 +145** (K10 ④: 新增内核模块 kernel/transport.ts —— 通信入口端口)   // 2026-10-02 **显式抬档 +184** (K10 ①: 新增内核模块 kernel/run-lifecycle.ts —— 运行生命周期写口, 与 control.ts 的控制面分开; 预算 == 真实值)   // 2026-10-02: +1 (K4-B: gate-scan 复位阈值注释)   // 2026-10-02: +5 (K8 正刀: gate-scan 加"收口字段数 3→1"+ queue 反回归)   // 2026-10-02: +54 (K8: gate-scan 加 K8 判据)   // 2026-10-02: +2 (STAGE_STATUS 拆 K4-A/K4-B + K6/K7 如实修正)
 /** 预算冻结值 (棘轮: 只许减; 想抬预算必须同时改上面那个数字 ⇒ 一次显式动作, diff 里看得见) */
-export const KERNEL_LINE_BUDGET_FROZEN_AT = 3852; // 同步至 2026-10-02 真实值 (K10 ④ 新增 transport.ts 后)
+export const KERNEL_LINE_BUDGET_FROZEN_AT = 4302; // 2026-10-16: 随抬档同步 (Kernel 双活 +376)   // 2026-10-16: 随抬档同步 (10-13/14 loop 机制增量)
 /**
  * K3b —— **台账数据**单独一档预算 (`src/kernel/plan.ts`)。
  *

package/dist/llm/config-store.js

@@ -225,6 +225,26 @@ function getDefaultConfig() {
         activeProvider = 'mimo';
     else if (process.env.OLLAMA_BASE_URL)
         activeProvider = 'ollama';
+    // ── 2026-10-07: 开箱即用 — 无任何私有 key 时落到内置公共网关 ──────────────
+    //   手机端/网页端下载安装后**不需要配置任何 API key** 就能直接对话:
+    //   Cloudflare Worker 托管 (api.bolloon.cn) 转发到 GLM 上游, 公共通道每天 ≤500 次/人,
+    //   配了自己的 key 的机器不受限 (上面 env 检测先命中)。
+    const hasAnyKey = !!(process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY
+        || process.env.OPENROUTER_API_KEY || process.env.GEMINI_API_KEY || process.env.MINIMAX_API_KEY
+        || process.env.DEEPSEEK_API_KEY || process.env.KIMI_API_KEY || process.env.MOONSHOT_API_KEY
+        || process.env.GLM_API_KEY || process.env.ZHIPU_API_KEY || process.env.QWEN_API_KEY
+        || process.env.DASHSCOPE_API_KEY || process.env.MIMO_API_KEY || process.env.OLLAMA_BASE_URL);
+    if (!hasAnyKey) {
+        envConfigs.glm = {
+            ...DEFAULT_PROVIDER_CONFIGS.glm,
+            enabled: true,
+            baseUrl: 'https://api.bolloon.cn/v1', // CF Worker 公共网关 (免配置)
+            apiKey: 'bolloon-free', // 公共通道标识 (每天 ≤500 次/人)
+            model: 'glm-5.3',
+            maxTokens: 16384,
+        };
+        activeProvider = 'glm';
+    }
     const providers = { ...DEFAULT_PROVIDER_CONFIGS };
     for (const [provider, config] of Object.entries(envConfigs)) {
         if (config) {

package/dist/llm/embedding-adapter.js

@@ -0,0 +1,69 @@
+/** none 实现: 无向量能力, 调用即抛 (由调用方按 provider 判走关键词回退) */
+const noneAdapter = {
+    provider: 'none',
+    dim: 0,
+    async embed() {
+        throw new Error('embedding adapter 未配置 (provider=none); 调用方应先查 provider !== "none"');
+    },
+    async embedBatch(texts) {
+        throw new Error('embedding adapter 未配置 (provider=none); 调用方应先查 provider !== "none"');
+    },
+};
+/**
+ * 工厂: 从配置构造 adapter。
+ * 规则:
+ *   - 无 provider / provider='none' → none adapter (关键词回退)
+ *   - provider 有值但没有实现 → none + 说明 (不假装能用)
+ *   - 新增供应商实现在此登记 (每实现一个, 加一个 case)
+ */
+export function createEmbeddingAdapter(cfg = {}) {
+    const provider = String(cfg.provider || 'none').toLowerCase();
+    switch (provider) {
+        case 'none':
+        case '':
+            return noneAdapter;
+        // 预留登记位: 供应商 key 就绪后在此补实现 (见文件头诚实边界)
+        // case 'glm':      return createGlmAdapter(cfg);
+        // case 'minimax':  return createMiniMaxAdapter(cfg);
+        // case 'openai':   return createOpenAIAdapter(cfg);
+        default:
+            return noneAdapter;
+    }
+}
+/** 测试辅助: 造一个确定性伪 adapter (cosine 检索测试用, 不碰网络) */
+export function createFakeAdapter(dim = 8, seedText = 'seed') {
+    // 确定性伪向量: 文本长度 + 字符和 → 稳定可复现 (仅测试用)
+    const vec = (t) => {
+        const out = [];
+        const s = String(t || '');
+        for (let i = 0; i < dim; i++) {
+            const v = (s.length * (i + 1) + s.charCodeAt(i % Math.max(1, s.length)) * 0.01) % 1;
+            out.push(Number(v.toFixed(6)));
+        }
+        // 归一化 (cosine 需要)
+        const norm = Math.sqrt(out.reduce((a, b) => a + b * b, 0)) || 1;
+        return out.map((x) => x / norm);
+    };
+    return {
+        provider: 'fake',
+        dim,
+        embed: async (t) => vec(t),
+        embedBatch: async (ts) => ts.map(vec),
+    };
+}
+/** cosine 相似度 (纯函数, 供检索用; 维度不一致 → 0) */
+export function cosineSimilarity(a, b) {
+    if (!a || !b || a.length === 0 || a.length !== b.length)
+        return 0;
+    let dot = 0;
+    let na = 0;
+    let nb = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        na += a[i] * a[i];
+        nb += b[i] * b[i];
+    }
+    if (na === 0 || nb === 0)
+        return 0;
+    return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}