@bolloon/bolloon-agent 0.6.0 → 0.6.1

package/dist/kernel/channel-actor.js

@@ -215,6 +215,30 @@ export function peekActor(actorKey) {
 export function actorCount() {
     return actors.size;
 }
+/**
+ * K8 收尾: **按 channel 中止** —— 给 UI 的终止按钮用 (`POST /api/chat/abort`)。
+ *
+ * 为什么是"扫描"而不是"按 channel 分桶": 注册表的键是**会话身份** (channel 前缀分桶曾被全量回归打红 ——
+ * 同 channel 下不同会话会互相看见 history)。终止只是**只读查找 + 动作**, 不改归属粒度 ⇒ 扫 `state.channelId` 即可。
+ *
+ * 返回**真的被中止了几个** —— 调用方据此回 `aborted: true/false`;
+ * 不许把"没找到 / 没在跑"说成"已中止" (那是谎报)。
+ */
+export function abortActorsOfChannel(channelId, reason = 'aborted') {
+    const cid = String(channelId || '');
+    if (!cid)
+        return 0;
+    let aborted = 0;
+    for (const actor of actors.values()) {
+        if (actor.state.channelId !== cid)
+            continue;
+        if (!actor.state.cancellation)
+            continue; // 没在跑 ⇒ 不算中止 (不强造一个 controller)
+        actor.abort(reason);
+        aborted += 1;
+    }
+    return aborted;
+}
 /** 清空注册表 —— **仅测试用** (避免测试之间互相污染) */
 export function resetActors() {
     actors.clear();

package/dist/kernel/gate-scan.js

@@ -493,8 +493,10 @@ export function scanRunIdSeed(files, opts) {
     if ((code.match(/this\.runCtx = this\.seedRunContext\(\)/g) || []).length > 0) {
         out.push({ rule: 'runid-seed-on-reset', file: 'agents/pi-sdk.ts', line: 1, what: '复位点带了播种 (清空不许携带身份)' });
     }
-    if (resets < 5)
-        out.push({ rule: 'runid-reset-missing', file: 'agents/pi-sdk.ts', line: 1, what: `复位点只剩 ${resets} 处 (期望 ≥5)` });
+    // K4-B (2026-10-02): 阈值 5 → 3 —— 原先是**两条 loop** (老 `runReActLoop` 内另有 2 处 `createRunContext()`);
+    //   老 loop 删除后只剩 pivot 这条路的复位点。不变量不变: **每条退出路径都要复位** (用完即清)。
+    if (resets < 3)
+        out.push({ rule: 'runid-reset-missing', file: 'agents/pi-sdk.ts', line: 1, what: `复位点只剩 ${resets} 处 (期望 ≥3, K4-B 后只剩一条 loop)` });
     return out;
 }
 /**
@@ -698,7 +700,9 @@ export function countEntryExecutionPoints(code, opts = {}) {
         for (const m of methods) {
             // `[!?]?` 允许非空断言 / 可选调用: `session.runExecution!(req)` 也是执行点
             //   (实测: 不带这一段, 改成请求式的站点会从计数里消失 ⇒ 该文件 total 从 11 掉到 10)
-            const rx = new RegExp(`\\.\\s*${m}\\s*[!?]?\\s*\\(`, 'g');
+            // 2026-10-02 (K8): 也认**助手形态** `requireRunExecution(agent)(req)` —— 它是"响亮检查 + 调入口"的等价执行点。
+            //   不认它 ⇒ 迁移后的站点从 total 里消失, 而 wired(deliverThroughActor 数) 不变 ⇒ 破坏 `wired ≤ total` 不变量 (门当场拒了)。
+            const rx = new RegExp(`\\.\\s*${m}\\s*[!?]?\\s*\\(|require${m[0].toUpperCase()}${m.slice(1)}\\s*\\(`, 'g');
             if (!rx.test(l))
                 continue;
             const recv = new RegExp(`([A-Za-z_$][\\w$]*|this)\\s*\\.\\s*${m}\\s*[!?]?\\s*\\(`).exec(l);
@@ -813,7 +817,8 @@ export function scanExecutionRequest(entrySources, piCode, req) {
             const l = raw.replace(/\/\/.*$/, '');
             if (/^\s*\*/.test(l))
                 continue;
-            converted += (l.match(/runExecution[!?]?\(/g) ?? []).length;
+            // 2026-10-02 (K8): 也认助手形态 `requireRunExecution(agent)(...)` —— 它是"响亮检查 + 调入口"的等价形状
+            converted += (l.match(/runExecution[!?]?\(|requireRunExecution\s*\(/g) ?? []).length;
         }
     }
     if (converted !== req.converted)
@@ -1034,3 +1039,312 @@ export function scanModelRuntimeFile(code, opts) {
         f(`capabilitiesDone=${opts.progress.capabilitiesDone} ≠ 清单里 done 的条数 ${done}`);
     return out;
 }
+// ─────────────────────────────────────────────────────────────────────────────
+// K7: Harness 唯一系统调用门 (台账 + 执行点普查)
+// ─────────────────────────────────────────────────────────────────────────────
+/** 剥掉块注释 (保留换行, 不破坏行号) 与行注释 —— 判据吃源码文本前必须先剥注释 (K2 教训) */
+export function stripJsComments(src) {
+    return src
+        .replace(/\/\*[\s\S]*?\*\//g, (m) => m.replace(/[^\n]/g, ' '))
+        .split('\n')
+        .map((l) => l.replace(/\/\/.*$/, ''))
+        .join('\n');
+}
+/**
+ * 执行点计数 (K7 的唯一口径): 剥注释后数 `\.execute\s*\(` 与 `executeTool` 的**匹配次数**。
+ * 口径必须是**纯函数 + 可重算**, 否则台账与盘上事实会对不上。
+ */
+export function countHarnessExecSites(src) {
+    const s = stripJsComments(src);
+    return (s.match(/\.execute\s*\(/g) || []).length + (s.match(/executeTool/g) || []).length;
+}
+/** 阶段顺序即契约 (与设计页 §7 第 164 行逐字一致) */
+export const HARNESS_STAGE_ORDER = [
+    'discover', 'permission', 'policy', 'budget', 'idempotency', 'execute', 'verify', 'evidence', 'event',
+];
+const EXEC_KINDS = ['main', 'skill', 'mcp', 'registry', 'bypass', 'homonym', 'port-callback', 'decl', 'import', 'ledger-string'];
+/**
+ * 再核对整本 K7 台账:
+ * ① 9 阶段顺序/唯一/gate 指向的文件真存在 ② 9 覆盖面 canonical 真存在
+ * ③ 执行点**逐文件重算**并与台账一致, 合计 == progress.execSitesTotal
+ * ④ 旁路候选逐条有替代路径且目标文件存在; 旁路数 == 台账 progress.bypasses == kinds 含 bypass 的条目所声明的数量
+ * ⑤ 拿不到事实 (文件读不出来) ⇒ 拒跑, 不许跳过
+ */
+export function scanHarnessLedger(ledger, opts) {
+    const out = [];
+    const f = (what) => out.push({ rule: 'harness-ledger', file: 'kernel/plan-harness.ts', line: 1, what });
+    // ① 阶段
+    if (ledger.stages.length !== 9)
+        f(`阶段数 ${ledger.stages.length} ≠ 9`);
+    const names = ledger.stages.map((s) => s.stage);
+    if (new Set(names).size !== names.length)
+        f('阶段名有重复');
+    if (names.join(',') !== HARNESS_STAGE_ORDER.join(','))
+        f(`阶段顺序不等于契约顺序: ${names.join(' → ')}`);
+    for (const s of ledger.stages) {
+        if (!s.gate?.trim())
+            f(`阶段 ${s.stage} 没写 gate (谁承担它)`);
+        if ((s.why ?? '').trim().length < 6)
+            f(`阶段 ${s.stage} 的 why 太短 (要能说清为什么)`);
+        for (const m of s.gate.match(/[\w./-]+\.ts/g) || []) {
+            if (opts.readFile(m) === null)
+                f(`阶段 ${s.stage} 的 gate 指向的文件不存在: ${m}`);
+        }
+    }
+    // ② 覆盖面
+    if (ledger.surfaces.length !== 9)
+        f(`覆盖面数 ${ledger.surfaces.length} ≠ 9`);
+    const surf = ledger.surfaces.map((s) => s.surface);
+    if (new Set(surf).size !== surf.length)
+        f('覆盖面名有重复');
+    for (const s of ledger.surfaces) {
+        if (opts.readFile(s.canonical) === null)
+            f(`覆盖面 ${s.surface} 的 canonical 文件不存在: ${s.canonical}`);
+    }
+    // ③ 执行点逐文件重算
+    let total = 0;
+    for (const site of ledger.execSites) {
+        const code = opts.readFile(site.file);
+        if (code === null) {
+            f(`执行点普查里的文件读不出来 ⇒ 拒跑: ${site.file}`);
+            continue;
+        }
+        const real = countHarnessExecSites(code);
+        if (real !== site.count)
+            f(`${site.file} 执行点 台账=${site.count} 盘上=${real} (增=新旁路未登记 · 减=改了盘没改账)`);
+        for (const k of site.kinds)
+            if (!EXEC_KINDS.includes(k))
+                f(`${site.file} 未知 kind: ${k}`);
+        total += site.count;
+    }
+    if (total !== ledger.progress.execSitesTotal)
+        f(`普查合计 ${total} ≠ progress.execSitesTotal ${ledger.progress.execSitesTotal}`);
+    // ④ 旁路候选
+    // 2026-10-02: 核"**开着**的旁路数"而不是"候选项个数" —— 收敛掉的旁路要留在台账里当记录,
+    //   否则收敛历史随进度条一起消失 (而 progress.bypasses 是棘轮基线: 只许减)。
+    const openBypasses = ledger.bypasses.filter((b) => b.status !== 'converged').length;
+    if (openBypasses !== ledger.progress.bypasses)
+        f(`开着的旁路 ${openBypasses} ≠ progress.bypasses ${ledger.progress.bypasses}`);
+    const bypassKinds = ledger.execSites.filter((s) => s.kinds.includes('bypass')).length;
+    if (bypassKinds === 0 && ledger.bypasses.length > 0)
+        f('登记了旁路候选, 但普查里没有任何条目标 bypass');
+    for (const b of ledger.bypasses) {
+        // 2026-10-02: target 只许是**文件路径**, 指位置靠 `symbol` —— 行号会随任何编辑漂移,
+        //   而旧 clause 要求 `文件:行` 却只核"文件存在", 等于**把一个会过期的东西写进台账而没人核它**。
+        //   现在改核 `symbol` 是否**真出现在该文件里** (防漂, 且比行号更强)。
+        if (!/\.tsx?$/.test(b.target))
+            f(`旁路 target 要写成文件路径 (行号会漂, 不许 file:line): ${b.target}`);
+        if (opts.readFile(b.target) === null)
+            f(`旁路目标文件不存在: ${b.target}`);
+        if (!b.symbol?.trim())
+            f(`旁路 ${b.target} 没写 symbol (指位置要有可在文件里被找到的记号)`);
+        else if (!(opts.readFile(b.target) ?? '').includes(b.symbol))
+            f(`旁路 symbol 在该文件里找不到 ⇒ 台账已过期: ${b.symbol}`);
+        if (b.status === 'converged' && !b.evidence?.trim())
+            f(`旁路 ${b.target} 标了 converged 却没写证据`);
+        if (!b.replacesWith?.trim())
+            f(`旁路 ${b.target} 没写替代路径 (五条件第 ① 条)`);
+        if ((b.why ?? '').trim().length < 6)
+            f(`旁路 ${b.target} 的 why 太短`);
+    }
+    // ⑤ 台账自报与盘上一致: 说"台账已落"就必须真存在
+    if (ledger.progress.stage === 'ledger-landed' && !opts.planFileExists)
+        f('progress 说台账已落, 但 plan-harness.ts 不存在');
+    if (ledger.progress.stage === 'not-started' && opts.planFileExists)
+        f('progress 说未开始, 但台账文件已存在 (半搬状态)');
+    return out;
+}
+// ════════════════════════════════════════════════════════════════════════════════
+// K8: Communication Runtime 收口 —— 判据 (口径唯一: 剥注释后数 `.promptStream(`/`.prompt(`)
+// ════════════════════════════════════════════════════════════════════════════════
+export const K8_SITE_KINDS = ['direct-prompt', 'via-actor'];
+/** transport→agent 直连的**唯一口径**: 剥注释后数 `.promptStream(` / `.prompt(` */
+export function countTransportAgentSites(src) {
+    return (stripJsComments(src).match(/\.promptStream\s*\(|\.prompt\s*\(/g) || []).length;
+}
+export function scanCommunicationLedger(ledger, opts) {
+    const out = [];
+    const f = (what) => out.push({ rule: 'k8-communication', file: 'kernel/plan-communication.ts', line: 1, what });
+    // 行号的**自然写法**都要抓: `(668,`/`(668)`/`:668`/`第 668 行`
+    const LINE_REF = /\(\s*\d{2,5}\s*[,)]|:\d{2,5}\b|第\s*\d{2,5}\s*行/;
+    if (ledger.faces.length !== 10)
+        f(`事件面数 ${ledger.faces.length} ≠ 10`);
+    if (new Set(ledger.faces).size !== ledger.faces.length)
+        f('事件面有重复');
+    let total = 0;
+    for (const s of ledger.sites) {
+        const code = opts.readFile(s.file);
+        if (code === null) {
+            f(`直连普查里的文件读不出来 ⇒ 拒跑: ${s.file}`);
+            continue;
+        }
+        const real = countTransportAgentSites(code);
+        if (real !== s.count)
+            f(`${s.file} 直连 台账=${s.count} 盘上=${real} (增=新直连未登记 · 减=改了盘没改账)`);
+        if (!K8_SITE_KINDS.includes(s.kind))
+            f(`${s.file} 未知 kind: ${s.kind}`);
+        if (!s.faces?.length)
+            f(`${s.file} 没写属于哪个事件面`);
+        if (s.why && LINE_REF.test(s.why))
+            f(`${s.file} why 里写了行号 (行号会漂 ⇒ 按符号写)`);
+        total += s.count;
+    }
+    if (total !== ledger.progress.directSites)
+        f(`直连合计 ${total} ≠ progress.directSites ${ledger.progress.directSites}`);
+    for (const p of ledger.perChannel) {
+        if (opts.readFile(p.file) === null)
+            f(`各通道自带状态的文件不存在: ${p.file}`);
+        if (p.why && LINE_REF.test(p.why))
+            f(`${p.file} why 里写了行号`);
+    }
+    if (ledger.perChannel.length !== ledger.progress.perChannelStateFiles) {
+        f(`各通道自带状态文件数 ${ledger.perChannel.length} ≠ progress.perChannelStateFiles ${ledger.progress.perChannelStateFiles}`);
+    }
+    return out;
+}
+// ════════════════════════════════════════════════════════════════════════════════
+// K8 第二步: "各通道自带状态" 台账 —— 判据 (按**符号**核, 不按行号)
+//
+// 为什么按符号: 行号会随任何编辑漂 (K7 真发生过: 台账写 4144, 插 35 行后变 4176 而没人发现)。
+// 为什么每个符号都要真: "看起来该有" 不算 —— 台账里写一个盘上没有的符号 = 台账撒谎。
+// ════════════════════════════════════════════════════════════════════════════════
+export const K8_STATE_SCOPE_NAMES = ['k8-target', 'ui-state', 'domain-pending', 'infra-retry'];
+/** 数"通道自带状态"的符号数 (总 / 其中属 K8 收口对象的) */
+export function countChannelStateSymbols(ledger) {
+    let total = 0, target = 0;
+    for (const s of ledger.sites) {
+        for (const sym of s.symbols ?? []) {
+            total += 1;
+            if (sym.scope === 'k8-target')
+                target += 1;
+        }
+    }
+    return { total, target };
+}
+export function scanChannelStateLedger(ledger, opts) {
+    const out = [];
+    const f = (what) => out.push({ rule: 'k8-channel-state', file: 'kernel/plan-communication.ts', line: 1, what });
+    // 0) 台账文本里不许出现行号 (抓自然写法)
+    const LINE_REF = /\(\s*\d{2,5}\s*[,)]|:\d{2,5}\b|第\s*\d{2,5}\s*行/;
+    for (const s of ledger.sites) {
+        const text = `${s.file} ${s.kind} ${s.why ?? ''} ${(s.symbols ?? []).map((x) => `${x.name} ${x.note ?? ''}`).join(' ')}`;
+        if (LINE_REF.test(text))
+            f(`通道状态台账写了行号 ⇒ 改按符号记: ${s.file}`);
+    }
+    // 1) 逐符号核"真在该文件里" + 逐符号定性必须齐全
+    let total = 0, target = 0;
+    for (const s of ledger.sites) {
+        const src = opts.readFile(s.file);
+        if (src === null) {
+            f(`各通道状态台账里的文件读不出来 ⇒ 拒跑: ${s.file}`);
+            continue;
+        }
+        const code = stripJsComments(src);
+        const syms = s.symbols ?? [];
+        if (syms.length === 0 && !/纯存储|无自带|none/i.test(s.why ?? '')) {
+            f(`${s.file} 符号表为空却没说清"无自带状态" (空表要显式声明, 不许静默留白)`);
+        }
+        for (const sym of syms) {
+            total += 1;
+            if (sym.scope === 'k8-target')
+                target += 1;
+            if (!K8_STATE_SCOPE_NAMES.includes(sym.scope)) {
+                f(`${s.file} 的符号 ${sym.name} scope 非法: ${sym.scope} (只能是 ${K8_STATE_SCOPE_NAMES.join(' / ')})`);
+            }
+            // 范围外符号**必须**写明为什么不算 —— 不许拿"范围外"当静默豁免
+            if (sym.scope !== 'k8-target' && (sym.note ?? '').trim().length < 6) {
+                f(`${s.file} 的 ${sym.name} 标了 scope=${sym.scope} 却没写明理由 ⇒ 不许静默豁免`);
+            }
+            const re = new RegExp(`(^|[^\\w$])${sym.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}([^\\w$]|$)`);
+            if (!re.test(code))
+                f(`${s.file} 的通道状态符号盘上找不到: ${sym.name} (台账=有 · 盘上=无)`);
+        }
+    }
+    // 2) 自洽 + 棘轮
+    if (ledger.sites.length !== ledger.progress.perChannelStateFiles) {
+        f(`各通道状态文件数 台账=${ledger.sites.length} progress=${ledger.progress.perChannelStateFiles}`);
+    }
+    const totalBudget = ledger.progress.perChannelStateSymbols;
+    if (typeof totalBudget === 'number' && total !== totalBudget) {
+        f(`通道状态符号总数 台账=${total} progress=${totalBudget} (增了要登记, 减了要同步)`);
+    }
+    const targetBudget = ledger.progress.k8TargetSymbols;
+    if (typeof targetBudget === 'number' && target > targetBudget) {
+        f(`K8 收口对象符号数超棘轮: 盘上=${target} > 预算=${targetBudget} (新增通道自带 outbound/重试/恢复必须走 router/mailbox)`);
+    }
+    return out;
+}
+export function scanDidFixConsolidation(spec) {
+    const out = [];
+    const f = (what) => out.push({ rule: 'k8-consolidation', file: 'web/server.ts', line: 1, what });
+    const code = stripJsComments(spec.src);
+    // 用字符串拼接造正则, 避开模板字面量里的多层转义 (踩过: 写出过非法 TS)
+    const wordy = (sym) => new RegExp('(^|[^\\w$])' + sym + '([^\\w$]|$)');
+    if (wordy(spec.removedFlag).test(code)) {
+        f(spec.removedFlag + ' 仍在代码里 (通道自己的全局单飞) ⇒ 收口没真生效');
+    }
+    if (!code.includes(spec.mustUse + '(')) {
+        f('没看到 ' + spec.mustUse + '( ⇒ 待办执行没走内核邮箱');
+    }
+    if (!wordy(spec.nextTargetSymbol).test(code)) {
+        f(spec.nextTargetSymbol + ' 不见了 ⇒ 台账必须同步 (它是**下一目标**或已收口, 两种都要显式登记)');
+    }
+    return out;
+}
+/** 剥注释后数某符号出现次数 (迁移工作面的唯一口径) */
+export function countSymbolOccurrences(src, symbol) {
+    return (stripJsComments(src).match(new RegExp('(^|[^\\w$])' + symbol + '([^\\w$]|$)', 'g')) || []).length;
+}
+export function scanRunStateConsolidation(ledger, progress, opts) {
+    const out = [];
+    const f = (what) => out.push({ rule: 'k8-runstate', file: 'kernel/plan-communication.ts', line: 1, what });
+    const src = opts.readFile(ledger.file);
+    if (src === null) {
+        f(`读不出源码 ⇒ 拒跑: ${ledger.file}`);
+        return out;
+    }
+    // ① 用法数: 台账 == 盘上 (迁移后同步下调)
+    const real = countSymbolOccurrences(src, ledger.symbol);
+    if (real !== ledger.sites)
+        f(`${ledger.symbol} 用法数 台账=${ledger.sites} 盘上=${real} (增=新用法未登记 · 减=改了盘没改账)`);
+    // 棘轮: 不许比基线更多
+    const base = progress.runStateSites;
+    if (typeof base === 'number' && real > base)
+        f(`${ledger.symbol} 用法数超棘轮: 盘上=${real} > 基线=${base}`);
+    // ② 字段必须真在接口里
+    for (const fld of ledger.fields) {
+        const re = new RegExp('(^|[^\\w$])' + fld.name + '\\??\\s*:', 'm');
+        if (!re.test(src))
+            f(`字段 ${fld.name} 在 ${ledger.file} 的接口里找不到`);
+        if (!['k8-target', 'observational', 'domain-collab'].includes(fld.role))
+            f(`字段 ${fld.name} role 非法: ${fld.role}`);
+        if (fld.role === 'k8-target' && !(fld.replacedBy ?? '').trim())
+            f(`字段 ${fld.name} 是收口对象却没写替代机制`);
+        if (fld.role !== 'k8-target' && (fld.note ?? '').trim().length < 6)
+            f(`字段 ${fld.name} 标了 ${fld.role} 却没写明理由 ⇒ 不许静默豁免`);
+    }
+    // K8 正刀 (2026-10-02): 收口对象 **3 → 1** —— `queue` 已**删除** (每条消息自己进内核邮箱, 通道不再持队列),
+    //   `running` 已**降为观测** (串行权威归邮箱); 只剩 `abortController` (abort 语义要单独定, 不随队列顺手合并)。
+    //   棘轮: 只许减; 要加回来必须是一次显式动作 + 说明为什么。
+    if (ledger.fields.filter((x) => x.role === 'k8-target').length !== 0) {
+        f(`收口字段数应为 0 (K8 收尾 2026-10-02: 最后一个 abortController 已归内核 actor —— beginCancellation/abort; queue 早前已删 · running 已降观测), 实际 ${ledger.fields.filter((x) => x.role === 'k8-target').length}`);
+    }
+    // 反回归: 已收口的 `queue` 不许悄悄溜回接口 (删于 2026-10-02 正刀)
+    if (/(^|[^\w$])queue\s*:\s*\w+\[\]/.test(src))
+        f('已收口的字段 queue 又出现在接口里 (通道不该再持队列)');
+    // ③ 计划必须有 (别只登记不动手)
+    if ((ledger.plan ?? '').trim().length < 10)
+        f('缺迁移计划 (台账不能只登记)');
+    // ④ 收口**前置**必须有, 且要点到机制 —— 否则下一个人会裸删字段把串行性搞坏
+    const pre = (ledger.prerequisite ?? '').trim();
+    if (pre.length < 20)
+        f('缺收口总前置 (哪些字段不能裸删 / 为什么)');
+    else if (!pre.includes('getChannelQueue'))
+        f('收口总前置必须点到机制 (`getChannelQueue`) ⇒ 否则只是空话');
+    for (const fld of ledger.fields) {
+        if (typeof fld.prerequisite === 'string' && fld.prerequisite.trim().length < 10) {
+            f(`字段 ${fld.name} 的 prerequisite 太短 (要写清先满足什么)`);
+        }
+    }
+    return out;
+}

package/dist/kernel/model-runtime.js

@@ -14,6 +14,28 @@
  * 通用判据 (K2 实证): **本文件出现后, 旧写口的调用点数不许增加** —— 由 `scanModelRuntimeFile` 机械核对。
  */
 /** 429 识别 (端口可以把限流表达成返回值 status=429, 或抛一个带 status 的错) */
+/**
+ * K10 ②: 把"有效选择"投影成内核的 `ModelSnapshot` —— **只读投影 + 校验**。
+ *   缺 provider/model ⇒ **返回 null** (调用方自己决定降级): 不许编一个假的填进去。
+ *   `acquire()` 自己也会拒, 但这里先拒能省掉一次"猜配置"的机会 (而且这个函数是纯的, 好判)。
+ */
+export function snapshotFromSelection(sel) {
+    const provider = String(sel?.provider ?? '').trim();
+    const model = String(sel?.model ?? '').trim();
+    if (!provider || !model)
+        return null;
+    const out = { provider, model };
+    const baseUrl = String(sel?.baseUrl ?? '').trim();
+    if (baseUrl)
+        out.baseUrl = baseUrl;
+    if (typeof sel?.timeoutMs === 'number')
+        out.timeoutMs = sel.timeoutMs;
+    if (sel?.capabilities)
+        out.capabilities = sel.capabilities;
+    if (sel?.fallbackProviders)
+        out.fallbackProviders = sel.fallbackProviders;
+    return out;
+}
 export function isRateLimited(x) {
     if (!x || typeof x !== 'object')
         return false;

package/dist/kernel/plan-channel-actor.js

@@ -53,6 +53,8 @@
  *     (用户消息 / 第二条路径 / 重新生成), `web/server.ts` 里共 8 处入口执行点 ⇒ `entrySites { total: 8, wired: 3 }`,
  *     两个数字都由判据 `scanEntryDelivery` **从盘上重算**, 自报无效。
  *     四个**粗粒度**入口 (web / CLI / P2P / Supervisor) 的 `entriesWired` 仍 **0/4** —— 一条入口要全部执行点接完才算。
+ *   · 2026-10-02 (K8 第二步/第三步): server.ts 11 → **8** —— 3 处 `promptStream(...)` 改走 `runExecution` (统一入口),
+ *     它们不再是"通道直呼 agent"的执行点 ⇒ 逐文件表跟着重建 (仍全部 wired)。
  *   · 2026-10-02 **步骤④ 完成**: web (server.ts 11/11 + routes-tasks 1/1) · CLI (index.ts) · P2P 入站 · Supervisor/子Agent
  *     (runner-resolver.ts 1/1) ⇒ `entriesWired **4/4**`。
  *     **关键发现 (口径漏了一整类入口)**: P2P 入站调的是 `a.summarizeDocument(...)` / `a.improveDocument(...)` ——
@@ -216,9 +218,11 @@ export const K5_FIELD_DELETION = {
 */
 export const K5_EXECUTION_REQUEST = {
     methodAdded: true,
-    converted: 1,
-    wiredTotal: 24,
-    remaining: 23,
+    // 2026-10-02 (K8 第二步): 1 → 3 —— routes-tasks.ts / runner-resolver.ts 两处改走 `runExecution`
+    //   (K5 这张台账记的正是"请求式投递的收敛进度", K8 的迁移会推进它 ⇒ 跨台账必须同步)
+    converted: 12, // 2026-10-02: 6 → 10 → 13 → **12** (K8 正刀删掉 `runMessageFromQueue` 简化版路径 ⇒ 随它消失 1 处)
+    wiredTotal: 23, // 2026-10-02 正刀: 24 → **23** (删掉的 `runMessageFromQueue` 自己也有一处请求式投递点)
+    remaining: 11, // 派生: wiredTotal − converted = 23 − 12 = 11 (与盘上一致)
 };
 /** 入口 → 文件分组 (判据做**双向**校验: 说完成 ⇒ 其文件必须全接完; 说没完成 ⇒ 必须真有文件没接完) */
 export const K5_ENTRY_GROUPS = [
@@ -265,8 +269,11 @@ export const K5_PROGRESS = {
     entrySites: [
         // `excludeReceivers` 是**已核实的非执行点 receiver** (台账数据, 冻结; 改动会出现在 diff 里):
         //   `this` = CLI readline 提示 (`this.prompt('> ')`);  `s` = index.ts 里的 UI 打印助手 (`s.prompt('📩 …')`)
-        { file: 'web/server.ts', total: 11, wired: 11, excludeReceivers: ['this'] }, // web 用户/中继/任务/心跳
-        { file: 'web/routes-tasks.ts', total: 1, wired: 1, excludeReceivers: ['this'] }, // web 任务路由
+        // 2026-10-02 (K8 第二/三步): 3 处 `promptStream(...)` 改走唯一入口 `runExecution`。
+        //   口径说明: `runExecution` 也在方法名单里, 且**助手形态** `requireRunExecution(...)` 也被认作执行点
+        //   ⇒ 迁移前后 total/wired 都不变 (11/11); 真正在变的是 K8 台账的"通道直呼 prompt"直连数 (10 → 7)。
+        { file: 'web/server.ts', total: 10, wired: 10, excludeReceivers: ['this'] }, // web 用户/中继/任务/心跳 (2026-10-02 正刀: 11 → 10, 简化版路径删除)
+        { file: 'web/routes-tasks.ts', total: 1, wired: 1, excludeReceivers: ['this'] }, // web 任务路由 (K8 后是请求式点; total 不降)
         { file: 'index.ts', total: 11, wired: 11, excludeReceivers: ['this', 's'] }, // CLI 主入口 + P2P 入站 (含文档摘要/改写)
         { file: 'cli/interface.ts', total: 0, wired: 0, excludeReceivers: ['this'] }, // readline ⇒ 无执行点
         { file: 'agents/runner-resolver.ts', total: 1, wired: 1, excludeReceivers: ['this'] }, // 子 Agent / Supervisor 面

package/dist/kernel/plan-communication.js

@@ -0,0 +1,163 @@
+/**
+ * K8 台账 (2026-10-02 建) —— **Communication Runtime 收口**
+ *
+ * 目标形态: `transport → router → channel mailbox`
+ * **绝不**: `transport → agent.promptStream()` (通道各自直呼 Agent = 通信层长出 N 条执行路径,
+ *   每条的流式/错误/重试/恢复语义都不一样, 没人能一眼看清"一条消息到底怎么被处理")。
+ *
+ * 本文件是 K8 的**第一步 (台账)**; 判据在 `gate-scan.ts` 的 `countTransportAgentSites` +
+ * `scanCommunicationLedger` 里重算比对 —— **台账与盘上事实必须逐字一致**。
+ */
+/** K8 要统一的 8 个事件面 (设计页 §7 原文口径) */
+export const K8_EVENT_FACES = [
+    'web-message', // Web 普通消息
+    'web-stream', // Web 流式回复
+    'web-regen', // Web 重生成
+    'cli', // CLI 通道
+    'p2p', // P2P 对等消息
+    'mobile', // 手机端
+    'contacts-reply', // 联系人自动回复
+    'external-wake', // 外部唤醒
+    'cron', // 定时任务
+    'supervisor', // Supervisor 事件
+];
+/**
+ * 迁移记录 (每题一处, 都要有"为什么这次是零差量/有差量"的判断):
+ *   · 2026-10-02 第二步: `routes-tasks.ts` / `runner-resolver.ts` 改走 `runExecution`
+ *     —— routes-tasks 那处**有差量** (隐式绑定 → 显式 `channelId`), 记为待真跑核验。
+ *   · 2026-10-02 第三步: `web/server.ts` **10 → 7** —— 三处 `promptStream(p, cb, undefined, channelId)`
+ *     改走 `runExecution({ input, onStream, channelId })`: 参数与派发**完全一致** ⇒ **按构造零差量** (不新增任何绑定)。
+ */
+export const K8_TRANSPORT_AGENT_SITES = [
+    // K8 第五步: 10 → 7 → 3 → 0 (★ server.ts 已零直连)
+    { file: 'src/web/server.ts', count: 0, kind: 'via-actor', faces: ['web-message', 'web-stream', 'web-regen', 'cron', 'supervisor', 'external-wake'], status: 'open', why: 'web 通道 (消息/流式/重生成/cron/Supervisor/外部唤醒)' },
+    { file: 'src/web/routes-tasks.ts', count: 0, kind: 'via-actor', status: 'migrated', evidence: '改经 runExecution({input}) —— 行为等价 (applyExecutionRequest 只覆盖显式给出的字段)', faces: ['contacts-reply'], why: 'task 路由' },
+    { file: 'src/agents/runner-resolver.ts', count: 0, kind: 'via-actor', status: 'migrated', evidence: 'routes-tasks 那处由隐式绑定改为**显式**传 channelId —— **2026-10-02 真跑核验通过** (src/test/k8-routes-tasks-execution.test.ts: 两半 id 一致的自检不变量 + agent 无 prompt 也跑通 + 真变异判红)', faces: ['external-wake'], why: '独立宿主 runner' },
+    { file: 'src/cli-entry.ts', count: 0, kind: 'direct-prompt', status: 'open', faces: ['cli'], why: 'CLI 通道' },
+    { file: 'src/web/mobile-core.ts', count: 0, kind: 'direct-prompt', status: 'open', faces: ['mobile'], why: '手机端通道' }
+];
+/** 各通道自带的出站/重试/恢复状态 (K8 验收: "无各通道自己的重试/任务恢复/outbound 状态")
+ *
+ * 纪律: **按符号记, 不按行号** —— 行号会漂 (K7 已发生过一次), 门的核法 = "该符号真在该文件里"。
+ * 口径 (2026-10-02 逐符号定性, 修正过一次): 每个符号必须带 **scope** —— 因为"文件里出现的状态"
+ * 不等于"通道自己的 outbound/重试/恢复"。把 UI 展示状态当收口对象是**伪收口**。
+ */
+export const K8_STATE_SCOPES = ['k8-target', 'ui-state', 'domain-pending', 'infra-retry'];
+const T = (name) => ({ name, scope: 'k8-target' });
+export const K8_PER_CHANNEL_STATE = [
+    { file: 'src/network/p2p-outbox.ts', kind: 'outbox',
+        symbols: ['outbox', 'outboxFile', 'outboxStats', 'totalQueued', 'sendOrQueue', 'queueOnly', 'flushAllOutboxes'].map(T),
+        why: 'P2P 出站队列 (通道自己的 outbound 状态 + 自己的 flush 时机)' },
+    { file: 'src/web/delivery-ledger.ts', kind: 'delivery-ledger',
+        symbols: ['DeliveryLedger', 'DeliveryRecord', 'DeliveryState', 'LedgerStats'].map(T),
+        why: '投递台账 (通道自己的投递状态机)' },
+    { file: 'src/web/server-v3-p2p.ts', kind: 'retry',
+        symbols: ['v3PendingHistoryGets', 'getV3PendingHistoryGets'].map(T),
+        why: 'P2P 侧挂起的 history 取回 (通道自己的待办 + 恢复路径)' },
+    { file: 'src/web/server.ts', kind: 'retry',
+        symbols: [
+            T('didFixQueue'),
+            T('deliveryLedger'), // SSE ping 用的 per-client 连败计数 ⇒ 真出站状态
+            { name: 'didFixTimer', scope: 'k8-target', note: '2s 节流定时器 —— 保留为**调度策略** (执行已交内核邮箱); 它本身仍是通道自己的调度状态' },
+            { name: 'channelRunState', scope: 'k8-target', note: '**下一个(大)目标**: 模块级 `Map<channelId, {running, queue, abortController}>` (24 处用法) —— 通道自己的消息队列 + 串行 flag + abort, 与内核邮箱**功能重复**' },
+            { name: 'messageQueue', scope: 'ui-state', note: '`(global as any)` 上的 **Web UI 通知列表** (pending/已读) ⇒ 展示状态, 不是 outbound/重试/恢复' },
+            { name: 'pendingFriendRequests', scope: 'domain-pending', note: '**好友申请待办** (业务审批数据, 落盘恢复) ⇒ 业务状态, 不是投递状态' },
+            { name: 'PENDING_FRIEND_REQ_FILE', scope: 'domain-pending', note: '同上: 好友申请待办的落盘文件' },
+            { name: 'maxAttempts', scope: 'infra-retry', note: 'HTTP `listen` 的 **EADDRINUSE 重试上限** ⇒ 进程启动基础设施, 不是通道出站' },
+        ],
+        why: 'web 通道内联的真状态: 待修复 channelId 队列(执行已交内核邮箱) + SSE 投递连败计数 + 通道自己的消息队列 channelRunState; 三个符号经定性**不属** K8 收口范围, 逐条写明原因' },
+    { file: 'src/cli-entry.ts', kind: 'resume',
+        symbols: [T('resumeId')],
+        why: 'CLI 侧会话恢复' },
+    { file: 'src/network/peer-fs.ts', kind: 'outbox',
+        symbols: ['OutboxEntry', 'enqueueOutbox', 'readOutbox', 'countOutbox', 'clearOutbox', 'getPeerOutboxPath'].map(T),
+        why: '文件传输侧出站 (落盘 outbox, 与 p2p-outbox 又一套)' },
+    { file: 'src/agents/contacts/store.ts', kind: 'none', symbols: [],
+        why: '纯存储: **无**自带出站/重试/恢复状态 (显式记 none, 不是"忘了填")' },
+    { file: 'src/agents/contacts/providers.ts', kind: 'retry',
+        symbols: ['DeliverResult', 'OTP_MAX_ATTEMPTS', 'smtpDeliver'].map(T),
+        why: '联系人通道自己的投递结果与重试上限' },
+    { file: 'src/agents/p2p-chat-tools.ts', kind: 'outbox',
+        symbols: ['outboxPath', 'processPendingInbox'].map(T),
+        why: 'P2P 聊天工具侧出站 + 待办处理' },
+    { file: 'src/agents/task/task-runner.ts', kind: 'resume',
+        symbols: ['ResumeResult', 'resumeTask', 'redelivered', 'refetchDeliveredContent'].map(T),
+        why: '任务运行器自带恢复 (含 x402 内容重取/重投递语义)' },
+];
+export const K8_ACCEPTANCE = [
+    '通信层**无直接 Agent 调用** (一律 transport → router → channel mailbox)',
+    '**无各通道自己的** 重试 / 任务恢复 / outbound 状态 (统一到 router + mailbox)',
+    '8 个事件面全部经同一条路由 (Web/CLI/P2P/手机/联系人回复/外部唤醒/cron/Supervisor)',
+    '收口后**直连数只许减** (棘轮), 且每减一处都要有"改走 router"的可回滚提交点',
+    '失败语义统一: 通道不再各自决定重试/放弃 (避免"有的通道静默丢、有的无限重试")',
+];
+export const K8_PROGRESS = {
+    stage: 'ledger-landed',
+    directSites: 0, // 12 → 10 (K8 第二步) → 7 (第三步: server.ts 3 处零差量迁移) (2026-10-02: routes-tasks / runner-resolver 两处已走唯一入口; 棘轮只许减)
+    perChannelStateFiles: 10,
+    // ⚠️ 2026-10-02 **补登**: 上一版漏了两个真状态符号 (`channelRunState` / `didFixTimer`) ⇒ 35 → 37。
+    //    这是**纠正漏登**不是范围扩张 (棘轮拦的是"通道自己状态变多", 不是"把已存在的登记上来")。
+    //    同一次提交里 `didFixRunning` (通道自己的全局单飞) 被**真删掉** —— 收口本身是减项, 只是它先前没被登记。
+    perChannelStateSymbols: 37, // 10 文件 / 37 个状态符号 (含 4 个范围外)
+    k8TargetSymbols: 33, // 其中 **33** 个属 K8 收口对象 (棘轮: 只许减)
+    runStateSites: 20, // 下一大目标的迁移工作面 (棘轮: 只许减)
+};
+// ════════════════════════════════════════════════════════════════════════════════
+// K8 下一个大目标: `web/server.ts` 的 `channelRunState` (通道自己的消息队列 + 串行 flag + abort)
+//
+// 为什么它是"最大的一刀": 它与内核邮箱**功能重复** —— 通道自己存队列、自己管 running、自己管 abort。
+// 为什么先落台账不直接改: 21 处用法 (剥注释后, 2026-10-02 量) + 三种语义混在一个对象里
+//   (调度 / 观测 / 协作续看), 直接改必然把观测与业务语义一起搅进去。
+// ════════════════════════════════════════════════════════════════════════════════
+export const K8_RUNSTATE_ROLES = ['k8-target', 'observational', 'domain-collab'];
+/**
+ * `channelRunState` 收口的**总前置** (2026-10-02 量出, 必须写在代码旁边而不是只写在提交里)。
+ *
+ * 为什么: `running` 同时是**主路径内联跑**与**排队路径**的串行权威。内核邮箱只认识"投给它的任务" ——
+ * 若只把排队项投进邮箱而主路径仍内联跑, 邮箱会在内联跑还没结束时**立刻起跑**排队项
+ * ⇒ 同一 channel **两条 run 并行** ⇒ 串行性被破坏 (K5 的"同通道串行"承诺失效)。
+ * 所以删 `queue`/`running` 的**前置**是: 主路径内联跑自己也进邮箱 (`await getChannelQueue(id).submit(...)`)。
+ *
+ * **2026-10-02 自纠: 下面这段早些时候写的"实测缺陷"是错的, 按盘上事实改正 (留着错的说法比没有更危险)。**
+ * 旧说法 = "主路径 check-then-set 夹在多个 `await` 之间 ⇒ 并发 `/message` 会都通过检查 ⇒ 同通道双开"。
+ * **盘上事实不成立**: `if (runState.running)` (server.ts 4839) 与 `running = true` (4853) 之间只有
+ * `queue.push` / `broadcastQueueUpdate` / `console.log` / `return` —— **没有 await**; 排空路径那对
+ * (`if (runState.running) return;` / `running = true`, 5657/5658) 更是**相邻两行**
+ * ⇒ 两处在 Node 单线程模型下都**是原子的**。
+ *
+ * 真正存在的洞是**同族的另一条** (`handoff 不是授权`): `finishChannelRun` 先**同步**置 `running = false`,
+ * 再把下一条**异步**交给邮箱 (`getChannelQueue(channelId).submit`) —— 而该邮箱**与 didFix 等任务共用**
+ * (`server.ts` 5790 用同一个 `getChannelQueue(id)`) ⇒ 邮箱里排着前序任务时 handoff 会延后, 这期间新到的
+ * `/message` 看到 `running === false` 就**内联起跑**; 等那条排队消息终于被跑到时, 它的防重入守卫
+ * `if (runState.running) return;` 直接返回 ⇒ **那条排队消息被静默丢掉** (不是双开, 是丢消息 —— 更糟),
+ * 且顺序也被打乱 (后到的先跑)。修法仍是同一个前置: **每条消息 (含主路径) 都投邮箱**, `running`/`queue` 降为观测。
+ */
+export const K8_RUNSTATE_PREREQUISITE = '主路径内联跑必须先进内核邮箱 (`await getChannelQueue(channelId).submit(...)`) 才能删 `queue`/`running`: ' +
+    '否则邮箱会与内联跑并行起跑排队项, 同通道双开 (K5 串行承诺失效)。' +
+    '**已核实的现网缺陷 (2026-10-02 自纠后)**: handoff 不是授权 —— `finishChannelRun` 同步置 running=false 后异步投邮箱, ' +
+    '邮箱与 didFix 共用 ⇒ 前序任务排队时 handoff 延后, 新 `/message` 见 running=false 就内联跑; ' +
+    '那条排队消息随后撞上 `if (runState.running) return;` ⇒ **被静默丢掉** (并打乱 FIFO)。' +
+    '(旧说法"check-then-set 夹 await ⇒ 并发双开"**不成立**, 已按盘上事实改正。)';
+export const K8_CHANNEL_RUNSTATE = {
+    file: 'src/web/server.ts',
+    symbol: 'channelRunState',
+    sites: 20, // 2026-10-02 收尾后真实值 20 (原 21; 中止位归 actor 时删掉 1 处用法) · 剥注释口径
+    fields: [
+        { name: 'running', role: 'observational',
+            note: '**2026-10-02 正刀后已降为观测口径**: 串行权威归内核邮箱 (`getChannelQueue(channelId).submit`), `running` 只剩"这一轮是否在飞"的展示/判定用途 (UI 的 `queue_update` · `remoteFollowup` 的 `!matchedRs.running` · `/api/loop/inspect` 文案), 不再参与任何"能不能起跑"的判断' },
+        // `queue` 字段 **已删除** (2026-10-02 正刀): 每条消息自己 `getChannelQueue(channelId).submit(...)`,
+        //   通道不再持有队列 (随之删掉 `PendingMessage` 接口与 `runMessageFromQueue` 那条简化路径)。
+        // `abortController` 字段 **已删除** (2026-10-02 收尾): 中止位归**内核 actor** ——
+        //   `ChannelActor.beginCancellation()` 每次执行开一个新 controller (与邮箱串行一致) ·
+        //   `ChannelActor.abort(reason)` 中断它; UI 的终止按钮 (`POST /api/chat/abort`) 走
+        //   `abortActorsOfChannel(channelId, 'user abort')` (按 channel 扫描注册表, 返回**真的中止了几个**)。
+        //   ⇒ 通道状态里**不再留第二份**中止位 (该条原先挂在 `role: 'k8-target'` 下, 现已收口)。
+        { name: 'lastSteps', role: 'observational', note: '供 `/api/loop/inspect` 的步骤累积 ⇒ 观测数据, 不是调度状态' },
+        { name: 'lastSummary', role: 'observational', note: '同上: 最近一轮摘要 (检查接口用)' },
+        { name: 'lastFinalReply', role: 'observational', note: '同上: 最近一次最终回复 (检查接口用)' },
+        { name: 'lastTokens', role: 'observational', note: '同上: token 计数 (用量展示)' },
+        { name: 'remoteFollowup', role: 'domain-collab', note: '远端协作续看 (`rounds`/`maxRounds`/`remoteChannelId`) ⇒ **业务协作语义**, 不是通道调度' },
+    ],
+    plan: '按语义分三批, 每批独立提交: ① 队列+单飞 (`queue`/`running`) → 内核邮箱; ② `abort` → `ExecutionRequest.signal` (先定语义); ③ `last*` 观测数据搬出通道对象 (或显式标注"非调度")。',
+    prerequisite: K8_RUNSTATE_PREREQUISITE,
+};