@bolloon/bolloon-agent 0.6.5 → 0.6.6

package/dist/ios/style.css

@@ -126,13 +126,20 @@ body {
   flex-shrink: 0;
   transition: var(--transition);
   transform: translateX(0);
-  position: relative;
+  /* 2026-10-06: 改为 fixed 覆盖 — sidebar 收起时绝对定位脱离流, relative 会被挤成 0 宽,
+      恢复条必须固定在屏幕左侧才能被看到/点到 */
+  position: fixed;
+  left: 0;
+  top: 0;
+  height: 100%;
   z-index: 99;
 }
 
 .sidebar-collapsed.hidden {
   transform: translateX(calc(-1 * var(--sidebar-collapsed)));
-  position: absolute;
+  position: fixed;
+  left: 0;
+  top: 0;
   height: 100%;
 }
 
@@ -1876,18 +1883,19 @@ body {
   flex-shrink: 0;
 }
 .header-tab {
-  padding: 5px 14px;
+  padding: 7px 22px;
   background: transparent;
   border: none;
   border-radius: 6px;
   color: var(--text-secondary);
-  font-size: 12px;
+  font-size: 13px;
   font-weight: 600;
   cursor: pointer;
   transition: var(--transition);
   display: flex;
   align-items: center;
-  gap: 4px;
+  gap: 5px;
+  white-space: nowrap;
 }
 .header-tab:hover {
   color: var(--text-primary);

package/dist/ios/ui/message-renderer.js

@@ -261,21 +261,10 @@ function segmentChatReply(reply, ctx) {
   if (remaining.trim()) {
     remaining = filterFillerText(remaining);
   }
-  const finalIdx = remaining.indexOf("<final gen>");
-  let beforeFinalText = remaining;
-  if (finalIdx >= 0) {
-    beforeFinalText = remaining.substring(0, finalIdx);
-  }
-  const textContent = beforeFinalText.trim();
+  const textContent = remaining.trim();
   if (textContent) {
     segments.push({ type: "text", content: textContent });
   }
-  if (finalIdx >= 0) {
-    const afterFinal = remaining.substring(finalIdx + "<final gen>".length).trim();
-    if (afterFinal) {
-      segments.push({ type: "final", content: afterFinal });
-    }
-  }
   return segments;
 }
 function extractAndPush(type, text, out, re) {
@@ -530,11 +519,7 @@ function addMessage(content, type, save = true, container, usedJudgmentIds = [],
   div.className = `message message-${type}`;
   let cleanContent = content;
   if (type === "ai") {
-    cleanContent = cleanContent.replace(/<think>[\s\S]*?<\/think>/g, "");
-    const finalGenIdx = cleanContent.indexOf("<final gen>");
-    if (finalGenIdx >= 0) {
-      cleanContent = cleanContent.substring(0, finalGenIdx).trim();
-    }
+    cleanContent = cleanContent.replace(/ thinking[\s\S]*?<\/think>/g, "");
   }
   const knownToolNames = ctx && ctx.knownToolNames || /* @__PURE__ */ new Set();
   const segments = segmentChatReply(cleanContent, { knownToolNames });
@@ -858,7 +843,8 @@ function handleStepEvent(data, ctx = { messagesEl: null, messagesContainers: /*
     args: data.args,
     success: data.success,
     output: data.output,
-    error: data.error
+    error: data.error,
+    durationMs: data.durationMs
   });
 }
 function flushStepEventBuffer(channelId, ctx) {

package/dist/ios/ui/step-timeline.js

@@ -1,6 +1,15 @@
 // src/web/ui/step-timeline.ts
 var MAX_VISIBLE_NODES = 20;
 var STORAGE_PREFIX = "bolloon.stepTimeline.expanded.";
+function formatDuration(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return "(耗时未知)";
+  if (ms < 1e3) return `${ms}ms`;
+  const s = ms / 1e3;
+  if (s < 60) return `${s.toFixed(1)}s`;
+  const m = Math.floor(s / 60);
+  const rem = Math.round(s % 60);
+  return `${m}m${rem}s`;
+}
 var stateMap = /* @__PURE__ */ new WeakMap();
 function readExpanded(channelId) {
   if (!channelId) return false;
@@ -121,7 +130,10 @@ function render(timelineEl) {
       }
       node.setAttribute("data-status", step.status);
       const label = node.querySelector(".step-timeline-label");
-      if (label) label.textContent = step.name;
+      if (label) {
+        const dur = step.durationMs !== void 0 && step.status !== "active" ? ` · ${formatDuration(step.durationMs)}` : "";
+        label.textContent = step.name + dur;
+      }
       const argsEl = node.querySelector(".step-timeline-args");
       if (argsEl) {
         const argStr = step.args && Object.keys(step.args).length > 0 ? JSON.stringify(step.args).slice(0, 60) : "";
@@ -265,6 +277,7 @@ function pushStepToTimeline(timelineEl, eventType, data) {
       steps[targetIdx].status = data.success === false ? "error" : "done";
       if (data.output) steps[targetIdx].output = data.output;
       if (data.error) steps[targetIdx].error = data.error;
+      if (data.durationMs !== void 0) steps[targetIdx].durationMs = data.durationMs;
     } else {
       steps[targetIdx].status = "error";
       if (data.error) steps[targetIdx].error = data.error;

package/dist/kernel/channel-actor.js

@@ -23,6 +23,17 @@ import { AsyncLocalStorage } from 'node:async_hooks';
  * ⇒ 用 ALS 记住"我在谁的上下文里", 同 actor 重入时**直跑**, 不同 actor 照常排队。
  */
 const actorCtx = new AsyncLocalStorage();
+/**
+ * 2026-10-13: 当前 mailbox 任务被注入的**取消信号**。
+ * `deliverThroughActor` 进入执行时调 `actor.beginCancellation()` 并把 signal 注入本 ALS,
+ * 业务侧 (CLI/Web) 在 run() 里经 `currentRequestSignal()` 取它传给模型/循环调用 ⇒
+ * Ctrl+C / 终止按钮走 `actor.abort()` / `abortActorsOfChannel()` 能真正打断回合。
+ * 零业务依赖: 只用 node:async_hooks, 不 import 任何业务模块。
+ */
+const requestSignalCtx = new AsyncLocalStorage();
+export function currentRequestSignal() {
+    return requestSignalCtx.getStore() ?? undefined;
+}
 /** 当前是否正跑在某个 Actor 的 mailbox 任务内 (诊断用) */
 export function currentActorContext() {
     return actorCtx.getStore();
@@ -245,6 +256,18 @@ export function resetActors() {
     channelQueues.clear();
     privateActorsCreated = 0;
 }
+/**
+ * 2026-10-13: 在 mailbox 任务体内开新的取消位并把 signal 注入 ALS (见 deliverThroughActor)。
+ * 收尾时**只有本任务仍是取消位主人**才清掉 —— 嵌套/并行路径下防 abort 打到下一个任务。
+ */
+function runWithCancellation(actor, run) {
+    const ac = new AbortController();
+    actor.state.cancellation = ac;
+    return requestSignalCtx.run(ac.signal, () => Promise.resolve(run()).finally(() => {
+        if (actor.state.cancellation === ac)
+            actor.state.cancellation = null;
+    }));
+}
 export async function deliverThroughActor(
 // 形参故意放宽成 `unknown`: 调用点的 receiver 类型五花八门 (AgentSession / 结构子集 / any),
 //   写成 `{ actor?: ChannelActor }` 会触发 TS 的弱类型检查 ("no properties in common") 而误报。
@@ -264,10 +287,15 @@ holder, run, opts = {}) {
             const q = getChannelQueue(ch);
             if (channelCtx.getStore() === q)
                 return run();
-            return q.submit(() => channelCtx.run(q, () => actor.submit(() => actorCtx.run(actor, () => run()))));
+            return q.submit(() => channelCtx.run(q, () => actor.submit(() => actorCtx.run(actor, () => runWithCancellation(actor, run)))));
         }
     }
-    return actor.submit(run);
+    // 2026-10-13 (leo: 「Ctrl+C 中断的落点必须是 kernel 的取消通道」):
+    //   mailbox 任务体内开一个新的取消位 (state.cancellation) 并把 signal 注入 ALS ——
+    //   业务侧 run() 经 `currentRequestSignal()` 取到它 ⇒ Ctrl+C abort 能打断回合。
+    //   **重入保护里直跑的分支不重新开位**: 嵌套的 inner run 复用同一个外层的 signal,
+    //   不会被内层 abort 清掉 (abort() 把 state.cancellation 置 null, 而 signal 经 ALS 走闭包引用)。
+    return actor.submit(() => actorCtx.run(actor, () => runWithCancellation(actor, run)));
 }
 // ─────────────────────────────────────────────────────────────────────────────
 // channel 级串行锁 (K5 步骤⑤) —— **能力先落地, 默认不启用**

package/dist/kernel/gate-scan.js

@@ -108,7 +108,7 @@ export function scanProhibition(files, p) {
     const out = [];
     const targets = p.targets ?? [];
     const calls = p.writeCalls ?? [];
-    const callRe = calls.length ? new RegExp(`\\b(${calls.join('|')})\\s*\\(`) : null;
+    const callRe = calls.length ? new RegExp(`(?<![\\w.])(?<!async\\s)(${calls.join('|')})\\s*\\(`) : null;
     for (const f of files) {
         if (p.mode === 'import-edge') {
             for (const { line, spec } of importSpecifiers(f.text)) {

package/dist/kernel/index.js

@@ -0,0 +1,33 @@
+/**
+ * @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';

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

@@ -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 = 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 };

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/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 = 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 如实修正)
 /** 预算冻结值 (棘轮: 只许减; 想抬预算必须同时改上面那个数字 ⇒ 一次显式动作, diff 里看得见) */
-export const KERNEL_LINE_BUDGET_FROZEN_AT = 3852; // 同步至 2026-10-02 真实值 (K10 ④ 新增 transport.ts 后)
+export const KERNEL_LINE_BUDGET_FROZEN_AT = 3885; // 2026-10-12: 与 SDK index.ts 出口新增同步
 /**
  * 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));
+}

package/dist/llm/pi-ai.js

@@ -9,6 +9,42 @@ export const LLAMACPP_DEFAULT_BASE_URL = 'http://localhost:8080/v1';
 export const LLAMACPP_DEFAULT_MODEL = 'local';
 /** 唯一的重路径用途 */
 export const MAIN_AGENT_PURPOSE = 'main-agent';
+// ---------------------------------------------------------------------------
+// 模型调用并发闸 (2026-10-15, leo: 「[AI 服务调用失败] ... 429 并发请求已达上限, 有错误也要修复」)
+// ---------------------------------------------------------------------------
+// 根因: CLI/Web/心跳/会话总结等多路会同时打同一个 provider, 上游按 API key 限并发
+//   (实测 zai/glm: `当前 API Key 的并发请求已达到上限` 429 rate_limit_error)。
+// 修复: 在**全仓唯一模型调用咽喉** generateText 前按 `providerId|baseUrl` 分桶限流 —
+//   同 key 同时最多 LLM_MAX_CONCURRENCY 个在途请求, 其余排队 (轮询, 可响应 abort)。
+const llmConcurrencyBuckets = new Map();
+export const LLM_MAX_CONCURRENCY = (() => {
+    const n = Number(process.env.BOLLOON_LLM_MAX_CONCURRENCY ?? '');
+    return Number.isFinite(n) && n >= 1 ? Math.min(n, 8) : 2;
+})();
+/** 包一个模型调用进并发闸: 同 key 超限则排队, abort 时尽快退出 (轮询 120ms, 最坏等一拍) */
+export async function withLlmConcurrency(key, signal, fn) {
+    for (;;) {
+        if (signal?.aborted)
+            throw new Error(String(signal.reason || 'AbortError'));
+        const b = llmConcurrencyBuckets.get(key) ?? { active: 0, waiting: 0 };
+        if (b.active < LLM_MAX_CONCURRENCY) {
+            b.active++;
+            llmConcurrencyBuckets.set(key, b);
+            try {
+                return await fn();
+            }
+            finally {
+                b.active--;
+                if (b.active <= 0 && b.waiting <= 0)
+                    llmConcurrencyBuckets.delete(key);
+            }
+        }
+        b.waiting++;
+        llmConcurrencyBuckets.set(key, b);
+        await new Promise((r) => setTimeout(r, 120));
+        b.waiting--;
+    }
+}
 /** 轻量前缀的 system 上限 (字符). 只对**自动装配部分 + 调用方自带短提示**做兜底截断, 正常调用远低于它 */
 export const LIGHTWEIGHT_SYSTEM_MAX_CHARS = 2000;
 /**
@@ -577,7 +613,9 @@ export class PiAIModel {
                     error = retryErr; // 记录最后一次错误, 循环继续重试 (backoff 递增)
                 }
             }
-            console.error('PiAI chat error:', error);
+            // 2026-10-15: 单行标签形 (`[pi-ai]` 是 log-gate INTERNAL_CHATTER_TAG, 只落盘不上屏;
+            //   `分类` 在 for 循环块级作用域内, errMsg 在下面才解析 —— 这里自包含一行, 不引块内变量)
+            console.error(`[pi-ai] chat 失败: ${String(error?.message ?? error).replace(/\n/g, ' ').slice(0, 300)}`);
             // 2026-06-15: 真实 error 信息 + 明确告诉 LLM "这是 API 错, 不要 retry"
             // 旧版: "抱歉，AI服务暂时不可用。" → LLM 看到 isTooShort=false(< 50 但 > 0),
             //       needsMoreWork 不会触发, 但 hasError 模式 (含 "error" / "失败") 会判定要继续修
@@ -655,29 +693,36 @@ export class PiAIModel {
                 finalMessages = [{ role: 'system', content: `可用工具:\n${toolDescriptions}` }, ...messages];
             }
         }
-        switch (this.provider) {
-            case 'openai':
-            case 'minimax':
-            case 'deepseek':
-            case 'kimi':
-            case 'glm':
-            case 'qwen':
-            case 'mimo':
-            case 'grok':
-                return this.callOpenAI(finalMessages, temperature, maxTokens, signal, openaiTools, onToken, purpose, source);
-            case 'anthropic':
-                return this.callAnthropic(finalMessages, temperature, maxTokens, signal);
-            case 'ollama':
-                return this.callOllama(finalMessages, temperature, signal);
-            case 'openrouter':
-                return this.callOpenRouter(finalMessages, temperature, maxTokens, signal);
-            case 'gemini':
-                return this.callGemini(finalMessages, temperature, maxTokens, signal);
-            case 'local':
-                return this.callLocal(finalMessages, temperature, signal);
-            default:
-                throw new Error(`Unsupported provider: ${this.provider}`);
-        }
+        // 2026-10-15 (leo: 429 并发已达上限, 有错误也要修复): 全仓唯一模型调用咽喉 —
+        //   所有入口 (CLI/Web/MCP/技能/子 Agent/长期任务) 都经 generateText 出网,
+        //   在这里按 `providerId|baseUrl` 分桶限流, 同 key 同时最多 LLM_MAX_CONCURRENCY 个在途,
+        //   排队等待 (轮询 120ms, abort 时尽快退出) — 不再把同一 API key 的并发打爆。
+        const bucketKey = `${this.config.providerId ?? this.provider}|${this.getBaseUrl()}`;
+        return withLlmConcurrency(bucketKey, signal, async () => {
+            switch (this.provider) {
+                case 'openai':
+                case 'minimax':
+                case 'deepseek':
+                case 'kimi':
+                case 'glm':
+                case 'qwen':
+                case 'mimo':
+                case 'grok':
+                    return this.callOpenAI(finalMessages, temperature, maxTokens, signal, openaiTools, onToken, purpose, source);
+                case 'anthropic':
+                    return this.callAnthropic(finalMessages, temperature, maxTokens, signal);
+                case 'ollama':
+                    return this.callOllama(finalMessages, temperature, signal);
+                case 'openrouter':
+                    return this.callOpenRouter(finalMessages, temperature, maxTokens, signal);
+                case 'gemini':
+                    return this.callGemini(finalMessages, temperature, maxTokens, signal);
+                case 'local':
+                    return this.callLocal(finalMessages, temperature, signal);
+                default:
+                    throw new Error(`Unsupported provider: ${this.provider}`);
+            }
+        });
     }
     getApiKey() {
         // 2026-09-28: llama.cpp (本地 OpenAI 兼容服务) —— 声明 id 单独接 key, key 可空
@@ -1390,9 +1435,8 @@ export function initPiAI(config = {}) {
     const isLlamacpp = declared === LLAMACPP_PROVIDER_ID;
     const provider = isLlamacpp ? 'openai' : declared;
     const providerId = config.providerId || (isLlamacpp ? LLAMACPP_PROVIDER_ID : undefined);
-    const model = config.model
-        || (isLlamacpp ? (process.env.LLAMACPP_MODEL || LLAMACPP_DEFAULT_MODEL) : detectModel(provider));
-    let baseUrl = config.baseUrl || (isLlamacpp ? (process.env.LLAMACPP_BASE_URL || LLAMACPP_DEFAULT_BASE_URL) : undefined);
+    let model = config.model || undefined;
+    let baseUrl = config.baseUrl || undefined;
     console.log('[PiAIModel] Initializing with provider:', provider, 'model:', model);
     // 如果没有提供 apiKey，从配置文件读取
     let apiKey = config.apiKey;
@@ -1400,26 +1444,42 @@ export function initPiAI(config = {}) {
     //   否则"换 key"这种真变化不会重建实例, 指纹就失去意义)
     if (!apiKey && isLlamacpp)
         apiKey = process.env.LLAMACPP_API_KEY || undefined;
-    if (!apiKey) {
+    // ── 2026-10-06 技术债重构: 配置文件对所有 provider 生效 (不只 llamacpp) ──
+    //   用户是 200+ 模型 / 自适应 URL 的重度用户: 在配置里自定义 baseUrl/model 必须被尊重。
+    //   之前只有 llamacpp 走这条, 其他 provider 一律被 getBaseUrl()/mapModel() 的
+    //   内置默认 / env 覆盖掉 ⇒ 配置了自定义网关 URL 却打官方端点 (401 真实事故)。
+    //   优先级: 显式 config > 配置文件 > env > 内置默认 (getBaseUrl/mapModel 天然如此,
+    //   这里只把配置值塞进去, 让"配置文件"这一层对所有 provider 生效)。
+    {
         try {
             const configPath = resolveConfigPath();
             if (configPath) {
                 const configData = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-                const providerConfig = configData.providers[declared];
-                if (providerConfig?.apiKey) {
+                const providerConfig = configData.providers?.[declared];
+                if (!apiKey && providerConfig?.apiKey) {
                     apiKey = providerConfig.apiKey;
                     console.log('[PiAIModel] Loaded apiKey from config for', declared);
                 }
-                // 2026-09-28: 本地服务 (llamacpp) 的 baseUrl 常写在配置里 → 只对这一家多读一个字段
-                //   (别人保持"只读 apiKey"的老行为: 让 model/baseUrl 的优先级变动会牵连 llm-config 那条线)
-                if (isLlamacpp && !baseUrl && providerConfig?.baseUrl)
+                // 2026-10-06: baseUrl / model 不再只给 llamacpp —— 所有 provider 都尊重配置文件
+                //   (显式 config 优先; 配置里的值只作为"未显式指定"时的兜底)
+                if (!baseUrl && providerConfig?.baseUrl)
                     baseUrl = providerConfig.baseUrl;
+                if (!model && providerConfig?.model)
+                    model = providerConfig.model;
+                if (providerConfig?.baseUrl || providerConfig?.model) {
+                    console.log('[PiAIModel] Loaded baseUrl/model from config for', declared, baseUrl ? 'baseUrl=' + baseUrl : '', model ? 'model=' + model : '');
+                }
             }
         }
         catch (e) {
-            console.log('[PiAIModel] Error reading apiKey from config:', e);
+            console.log('[PiAIModel] Error reading config:', e);
         }
     }
+    // 兜底: 配置文件也没给 → 回落 llamacpp env / detectModel 内置默认 (老行为不变)
+    if (!model)
+        model = isLlamacpp ? (process.env.LLAMACPP_MODEL || LLAMACPP_DEFAULT_MODEL) : detectModel(provider);
+    if (!baseUrl)
+        baseUrl = isLlamacpp ? (process.env.LLAMACPP_BASE_URL || LLAMACPP_DEFAULT_BASE_URL) : undefined;
     // ── 2026-09-28: 按指纹幂等 ──────────────────────────────────────────────
     //   同一份配置重复 init (CLI 每轮 / web 每次请求 / 脚本多入口) **不再重建实例、不再清装配缓存**.
     //   之前每次 init 都清缓存 → 每轮重装 system → 前缀抖动 → 服务端前缀 KV 永远用不上.

package/dist/orbitdb/memory-sync.js

@@ -0,0 +1,70 @@
+/**
+ * memory-sync.ts — 记忆条目级 OrbitDB 复制 (P3, decentralized-memory-design §2.6)
+ *
+ * 在现有 CID 快照(整快照)之上加「条目级同步」:
+ *   - 保存: MemoryEntry.id (sha256) 作为经内容寻址的 key
+ *   - 存储: CIDDatabase type='memory', metadata 带 entryId + entryUpdatedAt
+ *   - 复制: OrbitDB pubsub 自动 (既有机制)
+ *   - 冲突: 同 entryId 冲突 → updatedAt 大者胜 (LWW), 平手比 content hash
+ *
+ * 诚实边界 (写死):
+ *   - 条目级复制依赖 OrbitDB 网络就绪 (getCIDDatabase 初始化); 网络不可用 /
+ *     初始化失败 → 静默跳过 (本地记忆仍是权威, 复制是增强不是阻塞)
+ *   - 本模块不建新 store, 复用既有 bolloon-cid-store (type='memory')
+ *   - 跨机器真同步需双节点 (设计文档 §5 已记「跨机读群未验证」, P3 只保证
+ *     条目可被 CID 化 + 可恢复; 真双节点验证是 P3b)
+ */
+import { getCIDDatabase } from './cid-database.js';
+/** 条目 → CID 记录的 metadata 常量键 */
+const META_ENTRY_ID = 'entryId';
+const META_ENTRY_UPDATED = 'entryUpdatedAt';
+/** 从 CID 记录还原 MemoryEntry (metadata 无 entryId 的旧记录 → null) */
+export function entryFromRecord(rec) {
+    if (!rec)
+        return null;
+    const meta = rec.metadata || {};
+    if (!meta[META_ENTRY_ID])
+        return null;
+    const e = rec.content;
+    if (!e || typeof e !== 'object' || !e.id || !e.agentId)
+        return null;
+    return e;
+}
+/**
+ * 同步入口: 把一条 MemoryEntry 写入 OrbitDB (条目级)。
+ * 失败静默 (本地记忆不受影响), 返回 CID 或 null。
+ */
+export async function syncMemoryEntryToOrbit(entry, db = getCIDDatabase()) {
+    try {
+        const rec = await db.save({
+            agentId: entry.agentId,
+            type: 'memory',
+            content: entry,
+            metadata: {
+                [META_ENTRY_ID]: entry.id,
+                [META_ENTRY_UPDATED]: entry.updatedAt,
+                kind: 'memory-entry',
+            },
+        });
+        return rec.id;
+    }
+    catch {
+        return null; // 网络/初始化失败静默 — 本地记忆仍权威
+    }
+}
+/**
+ * 拉取远端条目: 列出该 agent 的全部 memory type 记录, 还原成 MemoryEntry。
+ * 仅返回「本地没有 或 远端 updatedAt 更新」的条目 (LWW)。
+ * 不写本地 — 由调用方决定如何合并。
+ */
+export async function fetchRemoteEntries(agentId, db = getCIDDatabase()) {
+    try {
+        const recs = await db.list({ agentId, type: 'memory' });
+        return recs
+            .map((r) => entryFromRecord(r))
+            .filter((e) => e !== null);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/pi-ecosystem-judgment/adaptive-scan.js

@@ -18,7 +18,7 @@
 import * as fs from 'fs/promises';
 import * as os from 'os';
 import * as path from 'path';
-import { loadAllJudgments } from './human-value-store.js';
+import { loadAllJudgments, } from './human-value-store.js';
 // 用 getter 函数而非模块顶层 const: process.env.HOME 在测试 beforeAll 才设,
 // 模块顶层求值时还是真 home. 运行时求值才能正确响应测试 fixture.
 // 跨平台: 优先 process.env.HOME (测试可控), 然后 os.homedir() (Windows 上读 USERPROFILE).