@bolloon/bolloon-agent 0.6.6 → 0.6.7

package/dist/kernel/gate-scan.js

@@ -238,7 +238,7 @@ export function validateDeletionRecord(rec) {
     return bad;
 }
 /** 第一批删除候选 = 产品码里 **0 入边引用** 且非入口形态 (机械派生, 不手写) */
-const ENTRY_SHAPE_RE = /(index\.ts$|cli-entry\.ts$|electron\.ts$|\.d\.ts$|server\.ts$|main\.ts$|route|command|register|setup|bootstrap|migration|types\.ts$|constants?\.ts$|config)/;
+const ENTRY_SHAPE_RE = /(index\.ts$|cli-entry\.ts$|electron\.ts$|\.d\.ts$|server\.ts$|main\.ts$|daemon\.ts$|route|command|register|setup|bootstrap|migration|types\.ts$|constants?\.ts$|config)/;
 /**
  * **豁免规则 (2026-10-02)**: 冻结面自身的文件 (KERNEL_FILES 成员 —— `kernel/roster.ts` / `kernel/plan*.ts`)
  * **不算删除候选**。它们是台账/名册, 在"0 入边"口径下天然是孤岛, 每加一个台账就会让候选集变一次

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

@@ -31,3 +31,6 @@ 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/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 = 95;
-export const DELETION_CANDIDATE_SHA256 = 'f271d369c830b73833e195c62076a0869dc8c8ef7c9b3cffddd6ce5342f2cb3a';
-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": 11 };
+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/index.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 = 3885; // 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 如实修正)
+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 = 3885; // 2026-10-12: 与 SDK index.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/pi-ai.js

@@ -1183,7 +1183,7 @@ export class PiAIModel {
     }
     // 注: callLocal 直接代理 ollama. 工具清单由 generateText 在外层拼到 messages, 这里 messages 已是 finalMessages.
     /**
-     * 2026-09-28: 装配系统提示词并拆成「稳定段 / 动态段」, 按 working dir 缓存 (TTL 10 分钟)。
+     * 2026-09-28: 装配系统提示词并拆成「稳定段 / 动态段」, 按 working dir + **文档指纹** 缓存 (TTL 10 分钟)。
      *
      * 返回: `{ stableText, dynamicText, cached }`
      *   - `stableText` 进 system (逐字节稳定 → 服务端前缀 KV 可复用);
@@ -1192,14 +1192,27 @@ export class PiAIModel {
      * 为什么缓存: 旧版每轮都跑 25 次 fs.readFile + 装配; 缓存后同一次会话内只装一次,
      *   且装配结果逐字节相同 (缓存本身也是"前缀稳定"的必要条件 —— 每次重装都可能因动态层
      *   内容变化而抖动)。
+     *
+     * 2026-10-15 (leo: 「文档改了要下一轮生效, 对齐 Hermes invalidate_system_prompt」):
+     *   缓存 key 并入 `contextFingerprint` —— project Bolloon.md / AGENTS.md / CLAUDE.md /
+     *   hierarchy 4 层 / 当前 agent persona 任一文档的 mtime+size 变了, key 就变 ⇒ 缓存 miss
+     *   ⇒ 下一轮重装配。此前只有 working dir 作 key: 文档改了要等 10 分钟 TTL 才生效。
      */
     async buildSystemPromptParts(context) {
-        const key = context || process.cwd();
         const now = Date.now();
+        const workingDir = context || process.cwd();
+        let fp = '';
+        try {
+            const { contextFingerprint } = await import('../bootstrap/context-collector.js');
+            fp = await contextFingerprint(workingDir);
+        }
+        catch { /* 指纹不可得 → 退回无指纹 key (文档失效钩子缺席, 但装配不阻塞) */ }
+        // 缓存 key = workingDir + 指纹; 装配时 workingDir 保持原值 (不把指纹拼进 prompt 文本)
+        const key = `${workingDir}\u0000${fp}`;
         if (_systemPromptCache && _systemPromptCache.key === key && now - _systemPromptCache.at < SYSTEM_PROMPT_CACHE_TTL_MS) {
             return { stableText: _systemPromptCache.stableText, dynamicText: _systemPromptCache.dynamicText, cached: true };
         }
-        const parts = await this.assembleSystemPromptPartsText(key);
+        const parts = await this.assembleSystemPromptPartsText(workingDir);
         _systemPromptCache = { key, at: now, ...parts };
         return { ...parts, cached: false };
     }

package/dist/llm/system-prompt/registry.js

@@ -87,13 +87,14 @@ const DEFAULT_META = (ttlDays) => ({
 const STATIC_LAYERS = [
     // ── core/ ──
     { id: 'core.identity', version: '1.0.0', priority: 50, appliesTo: ['all'], source: 'static-md', maxChars: 800, meta: DEFAULT_META(TTL_KNOWLEDGE) },
-    { id: 'core.knowledge', version: '1.0.0', priority: 60, appliesTo: ['all'], source: 'static-md', maxChars: 600, meta: DEFAULT_META(TTL_KNOWLEDGE) },
-    { id: 'core.tools.thin', version: '1.0.0', priority: 70, appliesTo: ['all'], source: 'static-md', maxChars: 400, meta: DEFAULT_META(TTL_SAFETY) },
+    // 2026-10-16: 停用过时的通用知识/Computer Use 提示；实际工具与知识边界由运行时提供。
+    { id: 'core.knowledge', version: '1.0.0', priority: 60, appliesTo: ['never'], source: 'static-md', maxChars: 0, meta: DEFAULT_META(TTL_KNOWLEDGE) },
+    { id: 'core.tools.thin', version: '1.0.0', priority: 70, appliesTo: ['never'], source: 'static-md', maxChars: 0, meta: DEFAULT_META(TTL_SAFETY) },
     { id: 'core.hibs_reminders', version: '1.0.0', priority: 80, appliesTo: ['never'], source: 'static-md', maxChars: 0, meta: DEFAULT_META(TTL_SAFETY) },
     { id: 'core.refusal', version: '1.0.0', priority: 100, appliesTo: ['all'], source: 'static-md', maxChars: 800, meta: DEFAULT_META(TTL_SAFETY) },
-    { id: 'core.tone', version: '1.0.0', priority: 110, appliesTo: ['all'], source: 'static-md', maxChars: 500, meta: DEFAULT_META(TTL_KNOWLEDGE) },
-    { id: 'core.wellbeing', version: '1.0.0', priority: 120, appliesTo: ['all'], source: 'static-md', maxChars: 600, meta: DEFAULT_META(TTL_KNOWLEDGE) },
-    { id: 'core.evenhandedness', version: '1.0.0', priority: 130, appliesTo: ['all'], source: 'static-md', maxChars: 300, meta: DEFAULT_META(TTL_KNOWLEDGE) },
+    { id: 'core.tone', version: '1.0.0', priority: 110, appliesTo: ['never'], source: 'static-md', maxChars: 0, meta: DEFAULT_META(TTL_KNOWLEDGE) },
+    { id: 'core.wellbeing', version: '1.0.0', priority: 120, appliesTo: ['never'], source: 'static-md', maxChars: 0, meta: DEFAULT_META(TTL_KNOWLEDGE) },
+    { id: 'core.evenhandedness', version: '1.0.0', priority: 130, appliesTo: ['never'], source: 'static-md', maxChars: 0, meta: DEFAULT_META(TTL_KNOWLEDGE) },
     { id: 'core.artifacts_storage', version: '1.0.0', priority: 145, appliesTo: ['never'], source: 'static-md', maxChars: 0, meta: DEFAULT_META(TTL_KNOWLEDGE) },
     { id: 'core.network_filesystem', version: '1.0.0', priority: 148, appliesTo: ['never'], source: 'static-md', maxChars: 0, meta: DEFAULT_META(TTL_KNOWLEDGE) },
     // ── role/ ── 阶段 0 只用 expert, 其他 3 个停用 (节省 + 阶段 0 不分 role)
@@ -111,7 +112,8 @@ const STATIC_LAYERS = [
     { id: 'channel.human-async', version: '1.0.0', priority: 150, appliesTo: ['local'], source: 'static-md', maxChars: 500, meta: DEFAULT_META(TTL_CHANNEL) },
     { id: 'channel.session-handoff', version: '1.0.0', priority: 150, appliesTo: ['local', 'p2p-visitor', 'p2p-agent'], source: 'static-md', maxChars: 600, meta: DEFAULT_META(TTL_CHANNEL) },
     // ── core/ ──
-    { id: 'core.memory_system', version: '1.0.0', priority: 140, appliesTo: ['all'], source: 'static-md', maxChars: 200, meta: DEFAULT_META(TTL_KNOWLEDGE) },
+    // 2026-10-16: 停用 memory_system — 静态"无记忆"描述与真实记忆系统不符, 记忆状态由 buildStableMemoryBlock 动态注入。
+    { id: 'core.memory_system', version: '1.0.0', priority: 140, appliesTo: ['never'], source: 'static-md', maxChars: 0, meta: DEFAULT_META(TTL_KNOWLEDGE) },
     // 2026-07-10 双栖 agent 网络新增 (按 plan 阶段 4):
     // priority 90 (在 channel 150 之后) — 保证 channel 装完后再装 core, 避免 channel 预算被 core 吃掉
     // maxChars 700 → 400: 7 个新 layer 总预算 3900 chars, 必须让出空间给 tool.p2p_request (700) + tool.goal_handoff (600)

package/dist/web/bolloon-web.json

@@ -1,10 +1,10 @@
 {
   "schema": "bolloon-mobile-web/1",
-  "version": "0.6.6",
+  "version": "0.6.7",
   "channel": "stable",
   "build": "stable",
-  "commit": "f2668fa9e6cc17c9868356b581a15d8cef867a3b",
-  "builtAt": "2026-10-15T10:28:08.907Z",
+  "commit": "94ac12e0c01b2136d9034a38ee1545efb21b23c1",
+  "builtAt": "2026-10-16T19:05:31.069Z",
   "layer": "web",
   "note": "web 资源层构建戳 (手机端 OTA 的身份第 ③ 级回退; 装机后以 OTA state.json 为准)"
 }