@bolloon/bolloon-agent 0.1.35 → 0.1.36

package/dist/context-compaction/microcompact.js

@@ -0,0 +1,51 @@
+/**
+ * Microcompact — 第 3 层: cache-aware 细粒度压缩
+ *
+ * 论文: 总是跑 (时间触发), 关键作用是保留 prompt cache 命中
+ * 实现 (简化版): 把老的 toolResult 折叠为 "(tool result: <name>, N chars)"
+ *   - 保留最近 N 条 tool_result 完整 (默认 3)
+ *   - 之前的折叠
+ *
+ * 关键: 不破坏 messageHistory 内存结构
+ *
+ * 失败静默: 异常 → 返回原 history
+ */
+const DEFAULT_KEEP_RECENT = 3;
+export function microcompact(history, opts = {}) {
+    try {
+        if (opts.skip)
+            return { history, applied: false, detail: 'skipped' };
+        const keepRecent = opts.microcompactKeepRecent ?? DEFAULT_KEEP_RECENT;
+        // 找所有 tool 消息的索引
+        const toolIndices = [];
+        for (let i = 0; i < history.length; i++) {
+            if (history[i].role === 'tool')
+                toolIndices.push(i);
+        }
+        if (toolIndices.length <= keepRecent) {
+            return { history, applied: false, detail: 'no old tool_results to fold' };
+        }
+        // 要折叠的 = 前 (total - keepRecent) 条
+        const toFold = new Set(toolIndices.slice(0, toolIndices.length - keepRecent));
+        let changed = false;
+        const out = history.map((m, i) => {
+            if (toFold.has(i) && m.role === 'tool') {
+                changed = true;
+                // 尝试从相邻的 assistant 消息拿 tool name
+                const name = m.toolName || 'unknown';
+                const originalLen = m.content?.length || 0;
+                return {
+                    ...m,
+                    content: `(tool result: ${name}, ${originalLen} chars — folded by microcompact)`,
+                    toolResult: undefined,
+                };
+            }
+            return m;
+        });
+        return { history: out, applied: changed, detail: `folded ${toFold.size} old tool_results, kept last ${keepRecent}` };
+    }
+    catch (err) {
+        console.warn('[compactor] microcompact failed (silent, returning original):', err);
+        return { history, applied: false, detail: 'error' };
+    }
+}

package/dist/context-compaction/pipeline.js

@@ -0,0 +1,123 @@
+/**
+ * Context Compaction Pipeline — 5 层编排
+ *
+ * 严格对齐 Claude Code 论文: 每次 LLM call 前顺序执行 5 个 shaper, 由便宜到重, 任一层 fit 就短路.
+ *
+ *   1. Budget Reduction   (总是, 截断 > 阈值的单条消息)
+ *   2. Snip               (feature flag BOLLOON_SNIP_ENABLED)
+ *   3. Microcompact       (总是, 折叠老 tool_result)
+ *   4. Context Collapse   (feature flag BOLLOON_CONTEXT_COLLAPSE, 读时虚拟投影)
+ *   5. Auto-Compact       (LLM 摘要, 兜底)
+ *
+ * 短路: 任一层后 budget fit (< 0.8) → 返回该层结果, 不跑后续.
+ *
+ * 关键不变量:
+ *   - 任何异常 → 整 pipeline 返回原 history (与现状一致)
+ *   - 第 1-3 层不破坏 messageHistory 内存引用 (内容可改)
+ *   - 第 4 层读时投影, memory 不变
+ *   - 第 5 层破坏性, 折叠 N 对成 1 条
+ *
+ * 失败静默: 整 pipeline 用 try/catch 包, 任何 stage 失败不影响整体
+ */
+import { budgetGate } from './budget-gate.js';
+import { budgetReduce } from './budget-reduce.js';
+import { snip, isSnipEnabled } from './snip.js';
+import { microcompact } from './microcompact.js';
+import { contextCollapse, isContextCollapseEnabled } from './context-collapse.js';
+import { autoCompact } from './auto-compact.js';
+const DEFAULT_MAX_TOKENS = 8000;
+export async function compactPipeline(history, opts = {}) {
+    const maxTokens = opts.maxTokens ?? DEFAULT_MAX_TOKENS;
+    const ctx = {
+        inputHistory: history,
+        history,
+        estimatedTokens: 0,
+        opts,
+        stages: [],
+    };
+    try {
+        // Stage 1: Budget Reduction
+        let result = budgetReduce(history, opts);
+        ctx.history = result.history;
+        ctx.stages.push(stageRecord('budgetReduce', result, history));
+        let gate = budgetGate(ctx.history, maxTokens);
+        ctx.estimatedTokens = gate.estimatedTokens;
+        if (gate.fit)
+            return finalize(ctx, result.applied); // 短路但可能 budgetReduce 实际改了内容
+        // Stage 2: Snip (feature flag)
+        if (isSnipEnabled()) {
+            const before = ctx.history;
+            result = snip(ctx.history, opts);
+            ctx.history = result.history;
+            ctx.stages.push(stageRecord('snip', result, before));
+            gate = budgetGate(ctx.history, maxTokens);
+            ctx.estimatedTokens = gate.estimatedTokens;
+            if (gate.fit)
+                return finalize(ctx, true);
+        }
+        else {
+            ctx.stages.push({ stage: 'snip', applied: false, before: ctx.history.length, after: ctx.history.length, detail: 'feature flag off' });
+        }
+        // Stage 3: Microcompact
+        const before3 = ctx.history;
+        result = microcompact(ctx.history, opts);
+        ctx.history = result.history;
+        ctx.stages.push(stageRecord('microcompact', result, before3));
+        gate = budgetGate(ctx.history, maxTokens);
+        ctx.estimatedTokens = gate.estimatedTokens;
+        if (gate.fit)
+            return finalize(ctx, result.applied || true);
+        // Stage 4: Context Collapse (feature flag)
+        if (isContextCollapseEnabled()) {
+            const before4 = ctx.history;
+            result = contextCollapse(ctx.history, opts);
+            ctx.history = result.history;
+            ctx.stages.push(stageRecord('contextCollapse', result, before4));
+            gate = budgetGate(ctx.history, maxTokens);
+            ctx.estimatedTokens = gate.estimatedTokens;
+            if (gate.fit)
+                return finalize(ctx, true);
+        }
+        else {
+            ctx.stages.push({ stage: 'contextCollapse', applied: false, before: ctx.history.length, after: ctx.history.length, detail: 'feature flag off' });
+        }
+        // Stage 5: Auto-Compact (兜底)
+        const before5 = ctx.history;
+        result = await autoCompact(ctx.history, opts);
+        ctx.history = result.history;
+        ctx.stages.push(stageRecord('autoCompact', result, before5));
+        return finalize(ctx, true);
+    }
+    catch (err) {
+        console.warn('[compactor] pipeline failed (silent, returning original):', err);
+        return {
+            history,
+            estimatedTokens: 0,
+            stages: ctx.stages,
+            compacted: false,
+        };
+    }
+}
+function stageRecord(name, result, before) {
+    return {
+        stage: name,
+        applied: result.applied,
+        before: before.length,
+        after: result.history.length,
+        detail: result.detail,
+    };
+}
+function finalize(ctx, compacted) {
+    return {
+        history: ctx.history,
+        estimatedTokens: ctx.estimatedTokens,
+        stages: ctx.stages,
+        compacted,
+    };
+}
+// ============================================================
+// 测试钩子
+// ============================================================
+export function _resetPipelineForTest() {
+    // pipeline 是 stateless, 但保留 API 一致性
+}

package/dist/context-compaction/snip.js

@@ -0,0 +1,45 @@
+/**
+ * Snip — 第 2 层: 裁掉老 history
+ *
+ * 论文: feature flag 关闭 (默认), 用户开启后才生效
+ * 开启环境变量: BOLLOON_SNIP_ENABLED=1
+ *
+ * 行为: 只保留最近 N 对 user/assistant (默认 20 对)
+ * 工具结果消息按其所属 round 一起保留
+ *
+ * 失败静默: 异常 → 返回原 history
+ */
+const DEFAULT_KEEP_PAIRS = 20;
+export function isSnipEnabled() {
+    return process.env.BOLLOON_SNIP_ENABLED === '1';
+}
+export function snip(history, opts = {}) {
+    try {
+        if (opts.skip || !isSnipEnabled()) {
+            return { history, applied: false, detail: isSnipEnabled() ? 'skipped' : 'feature flag off' };
+        }
+        const keepPairs = opts.snipKeepPairs ?? DEFAULT_KEEP_PAIRS;
+        // 从后往前数 N 对 user/assistant 边界
+        let pairsFound = 0;
+        let cutFrom = -1;
+        for (let i = history.length - 1; i >= 0; i--) {
+            const m = history[i];
+            if (m.role === 'user') {
+                pairsFound++;
+                if (pairsFound >= keepPairs) {
+                    cutFrom = i;
+                    break;
+                }
+            }
+        }
+        if (cutFrom <= 0) {
+            return { history, applied: false, detail: 'history too short' };
+        }
+        const out = history.slice(cutFrom);
+        return { history: out, applied: true, detail: `kept last ${keepPairs} pairs, dropped ${cutFrom} older messages` };
+    }
+    catch (err) {
+        console.warn('[compactor] snip failed (silent, returning original):', err);
+        return { history, applied: false, detail: 'error' };
+    }
+}

package/dist/context-compaction/token-estimator.js

@@ -0,0 +1,35 @@
+/**
+ * Token Estimator — 4 字符 ≈ 1 token 的粗估
+ *
+ * 为什么不引 tiktoken 依赖:
+ * - bolloon 默认 npm 用户, 引依赖增加 install 体积
+ * - Claude Code 论文也指出: 精确 token 计数不是关键, 渐进压缩才是
+ * - 4 字符/token 在中文/英文混合场景下误差约 ±20%, 对预算判定足够
+ *
+ * 失败静默: 任何异常 → 返回估算值 (不抛错)
+ */
+const CHARS_PER_TOKEN = 4;
+export function estimateTokens(messages) {
+    let total = 0;
+    for (const m of messages) {
+        total += Math.ceil((m.content?.length || 0) / CHARS_PER_TOKEN);
+        if (m.toolResult) {
+            try {
+                const s = typeof m.toolResult === 'string' ? m.toolResult : JSON.stringify(m.toolResult);
+                total += Math.ceil(s.length / CHARS_PER_TOKEN);
+            }
+            catch { /* circular ref, ignore */ }
+        }
+        if (m.toolCall) {
+            try {
+                const s = typeof m.toolCall === 'string' ? m.toolCall : JSON.stringify(m.toolCall);
+                total += Math.ceil(s.length / CHARS_PER_TOKEN);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    return total;
+}
+export function estimateStringTokens(s) {
+    return Math.ceil(s.length / CHARS_PER_TOKEN);
+}

package/dist/context-compaction/types.js

@@ -0,0 +1,19 @@
+/**
+ * Context Compaction — 类型定义
+ *
+ * 严格对齐 Claude Code 论文 5 层压缩流水线:
+ *   1. Budget Reduction   (单条消息大小限制)
+ *   2. Snip               (裁掉老历史, feature flag 关闭)
+ *   3. Microcompact       (cache-aware 细粒度压缩, 老 tool_result 折叠)
+ *   4. Context Collapse   (读时虚拟投影, 非破坏)
+ *   5. Auto-Compact       (LLM 摘要, 兜底)
+ *
+ * 关键不变量:
+ *   - 第 1-3 层不破坏 messageHistory 内存结构, 只改 buildContext 输出
+ *   - 第 4 层读时投影, 绝不改 messageHistory
+ *   - 第 5 层破坏 messageHistory, 把 N 对折叠成 1 条 summary
+ *
+ * 类型设计: Message 在本模块内独立定义, 靠 structural typing 与 pi-sdk.ts 的 Message 兼容.
+ * 不 import pi-sdk 避免循环依赖.
+ */
+export {};

package/dist/heartbeat/HealthMonitor.js

@@ -231,9 +231,10 @@ export class HealthMonitor {
     async pingLLM(minimax) {
         const start = Date.now();
         try {
-            // 简单的 chat 测试
+            // 2026-06-15: signal 位置正确传 undefined (chat signature 是 (message, context?, signal?))
+            //   之前传 { maxTokens: 1 } 被当 signal, Node 22+ undici 强类型 AbortSignal 校验 throw
             if (minimax.chat) {
-                await minimax.chat('ping', 'test', { maxTokens: 1 });
+                await minimax.chat('ping', 'test', undefined);
             }
             else if (minimax.ping) {
                 await minimax.ping();

package/dist/index.js

@@ -978,6 +978,34 @@ async function runNonInteractive(args, comm) {
         console.log(`✅ 结果已保存到: ${output}`);
         return;
     }
+    if (tool === 'prompt' && prompt) {
+        // 2026-06-15: --prompt "text" 走直接调 a.prompt(prompt) 路径, 避开 runToolCommand
+        //   (case 'prompt' 内的 [text] = args 从 toolArgs 取值是空数组, 永远报"缺少 prompt 文本"是 CLI bug)
+        const startTime = Date.now();
+        const a = await getAgent();
+        try {
+            const response = await a.prompt(prompt);
+            const elapsed = Date.now() - startTime;
+            if (json) {
+                console.log(JSON.stringify({ success: true, response, elapsedMs: elapsed }, null, 2));
+            }
+            else {
+                console.log(response);
+                console.log(`\n耗时: ${elapsed}ms`);
+            }
+        }
+        catch (e) {
+            const error = e?.message || String(e);
+            if (json) {
+                console.log(JSON.stringify({ success: false, error }, null, 2));
+            }
+            else {
+                console.log(`\n错误: ${error}`);
+            }
+            process.exit(1);
+        }
+        return;
+    }
     if (tool) {
         await runToolCommand(tool, toolArgs, !!json, comm);
     }
@@ -1367,7 +1395,9 @@ async function main() {
     s.banner();
     s.section('系统初始化');
     const hasOpenAI = !!process.env.OPENAI_API_KEY;
-    const hasAnthropic = !!process.env.ANTHROPIC_API_KEY;
+    // 2026-06-15: 修复 — 之前 anthropic 401 是因为 shell env 残留的旧 ANTHROPIC_API_KEY 抢了 provider 选择
+    //   用 BOLLOON_LLM_PROVIDER env 显式覆盖, 否则还是按 env hasXxx 顺序自动选
+    const hasAnthropic = !!process.env.ANTHROPIC_API_KEY && !process.env.BOLLOON_LLM_PROVIDER;
     const hasMinimax = !!process.env.MINIMAX_API_KEY;
     const hasDeepSeek = !!process.env.DEEPSEEK_API_KEY;
     const hasKimi = !!(process.env.KIMI_API_KEY || process.env.MOONSHOT_API_KEY);
@@ -1447,9 +1477,15 @@ async function main() {
     s.divider();
     if (mode === 'web') {
         const port = parseInt(process.env.PORT || '54188');
+        // 2026-06-16: BOLLOON_DEV_MODE=1 或 selfImprove=true 启动项 → 开发者模式, 启用自迭代 (健康监控+自改总线)
+        // 默认用户模式: 不自迭代, 自改卡片不自动出现, 仍可 POST /api/self-improve/trigger 手动触发
+        const selfImprove = process.env.BOLLOON_DEV_MODE === '1' || process.env.BOLLOON_DEV_MODE === 'true';
+        if (selfImprove) {
+            console.log('[startup] BOLLOON_DEV_MODE=1, 开发者模式: 自迭代已启用');
+        }
         const { createWebServer, openBrowser } = await import('./web/server.js');
         s.info(`启动 Web 服务端口 ${port}...`);
-        const { port: actualPort } = await createWebServer(port);
+        const { port: actualPort } = await createWebServer(port, { selfImprove });
         s.success(`浏览器已打开 → http://localhost:${actualPort}`);
         openBrowser(`http://localhost:${actualPort}`);
     }

package/dist/llm/llm-judgment-client.js

@@ -6,19 +6,31 @@
  */
 import { llmConfigStore } from './config-store.js';
 import { PiAIModel } from './pi-ai.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const LAYERS_DIR = path.join(__dirname, 'system-prompt', 'layers');
+/**
+ * 从 layer 读 .md 文件作为系统 prompt
+ * 失败时降级到兜底字符串 (不挂)
+ */
+async function loadRoleLayer(layerId, fallback) {
+    const [group, ...rest] = layerId.split('.');
+    const path2md = path.join(LAYERS_DIR, group, `${rest.join('.')}.md`);
+    try {
+        return await fs.readFile(path2md, 'utf-8');
+    }
+    catch {
+        return fallback;
+    }
+}
 // 预定义的判断 Prompt 配置
 export const JUDGMENT_PROMPTS = {
     // 默认判断 Prompt
     default: {
-        systemPrompt: `你是一个专业的 AI 任务分析专家。你的职责是深入理解用户的问题，并给出精准的判断。
-
-核心原则：
-1. 第一性原理：追问问题的本质，而非表面现象
-2. 多角度思考：考虑不同视角和影响因素
-3. 上下文感知：理解对话历史和隐含意图
-4. 动态评估：根据实际情况判断复杂性
-
-你的判断会影响后续的智能体协作方式，请认真分析。`,
+        systemPrompt: '',
+        systemPromptResolver: () => loadRoleLayer('role.expert', '你是一个专业的 AI 任务分析专家. '),
         userPromptTemplate: `【当前输入】
 {user_input}
 
@@ -73,16 +85,8 @@ export const JUDGMENT_PROMPTS = {
     },
     // 架构相关问题
     architecture: {
-        systemPrompt: `你是一个经验丰富的系统架构师。你擅长：
-- 从需求中提取本质问题
-- 设计可扩展的系统架构
-- 权衡技术方案
-- 识别架构风险
-
-你相信：
-- 本质和实现必须分离
-- 好的架构从简单规则中生长
-- 复杂性应该被控制而非消除`,
+        systemPrompt: '',
+        systemPromptResolver: () => loadRoleLayer('role.architect', '你是一个经验丰富的系统架构师. '),
         userPromptTemplate: `【架构设计问题】
 {user_input}
 
@@ -108,11 +112,8 @@ export const JUDGMENT_PROMPTS = {
     },
     // 代码相关问题
     code: {
-        systemPrompt: `你是一个高效的代码实现专家。你擅长：
-- 快速理解和实现需求
-- 编写清晰、可维护的代码
-- 遵循最佳实践
-- 处理边界情况`,
+        systemPrompt: '',
+        systemPromptResolver: () => loadRoleLayer('role.implementer', '你是一个高效的代码实现专家. '),
         userPromptTemplate: `【代码问题】
 {user_input}
 
@@ -134,11 +135,8 @@ export const JUDGMENT_PROMPTS = {
     },
     // 安全相关问题
     security: {
-        systemPrompt: `你是一个严格的安全专家。你擅长：
-- 识别安全风险
-- 评估威胁模型
-- 设计安全方案
-- 遵循安全最佳实践`,
+        systemPrompt: '',
+        systemPromptResolver: () => loadRoleLayer('role.security', '你是一个严格的安全专家. '),
         userPromptTemplate: `【安全问题】
 {user_input}
 
@@ -221,8 +219,12 @@ export class LLMJudgmentClient {
         }
         try {
             // 调用 LLM
+            // 优先用 systemPromptResolver (从 layer 读), fallback 静态 systemPrompt
+            const systemPrompt = this.promptConfig.systemPromptResolver
+                ? await this.promptConfig.systemPromptResolver()
+                : this.promptConfig.systemPrompt;
             const messages = [
-                { role: 'system', content: this.promptConfig.systemPrompt },
+                { role: 'system', content: systemPrompt },
                 { role: 'user', content: userPrompt }
             ];
             const response = await this.model.chat(userPrompt);

package/dist/llm/pi-ai.js

@@ -1,5 +1,22 @@
 import * as path from 'path';
 import * as fs from 'fs';
+/**
+ * 外部 system 注入钩子.
+ * 调用方 (e.g. auto-evolve-loop) 用 setSystemPrependProvider() 注册一个返回字符串的函数,
+ * generateText 在拼 finalMessages 时, 把返回的字符串作为最前一个 system message.
+ *
+ * 用途: P2P 协作时把"行级 reserve 状态"实时塞给 LLM,
+ *       让 LLM 主动避开对方正在改的代码行.
+ *
+ * 返回 '' / null / undefined → 不注入.
+ */
+let _prependProvider = null;
+export function setSystemPrependProvider(p) {
+    _prependProvider = p;
+}
+export function getSystemPrependProvider() {
+    return _prependProvider;
+}
 export class PiAIModel {
     config;
     provider;
@@ -8,7 +25,7 @@ export class PiAIModel {
         this.provider = config.provider;
     }
     async chat(message, context, signal) {
-        const systemPrompt = this.buildSystemPrompt(context);
+        const systemPrompt = await this.buildSystemPromptAsync(context);
         const messages = [
             { role: 'system', content: systemPrompt },
             { role: 'user', content: message }
@@ -17,6 +34,7 @@ export class PiAIModel {
             const response = await this.generateText({
                 messages,
                 temperature: 0.8,
+                maxTokens: 8192, // 2026-06-15: 提到 8192, 避免长回答 (含表格/代码块) 被截断
                 signal,
             });
             return { reply: response };
@@ -27,7 +45,14 @@ export class PiAIModel {
                 throw error; // 上层 try/catch 处理
             }
             console.error('PiAI chat error:', error);
-            return { reply: '抱歉，AI服务暂时不可用。' };
+            // 2026-06-15: 真实 error 信息 + 明确告诉 LLM "这是 API 错, 不要 retry"
+            // 旧版: "抱歉，AI服务暂时不可用。" → LLM 看到 isTooShort=false(< 50 但 > 0),
+            //       needsMoreWork 不会触发, 但 hasError 模式 (含 "error" / "失败") 会判定要继续修
+            // 新版: 让 LLM 立即停止循环, 直接展示给用户
+            const errMsg = (error?.message || '').slice(0, 300);
+            return {
+                reply: `[AI 服务调用失败] ${errMsg}\n\n这是一个**底层 API 错误**（401 / 鉴权失败 / 网络中断 / 配额耗尽等），不是你的任务有问题。**请直接把这个错误消息回复给用户，不要再循环尝试。**`,
+            };
         }
     }
     async summarize(text, context) {
@@ -69,7 +94,39 @@ export class PiAIModel {
         }
     }
     async generateText(options) {
-        const { messages, temperature = 0.7, maxTokens = 4096, signal } = options;
+        const { messages, temperature = 0.7, maxTokens = 4096, signal, tools } = options;
+        // 工具清单: 代码侧 schema → 进 system prompt (作为额外 system message)
+        let finalMessages = messages;
+        // 1) 外部 prepend (e.g. P2P 行级 reserve 状态), 拼到最前
+        if (_prependProvider) {
+            try {
+                const pre = await _prependProvider();
+                if (pre && typeof pre === 'string' && pre.trim()) {
+                    finalMessages = [{ role: 'system', content: pre }, ...finalMessages];
+                }
+            }
+            catch (err) {
+                console.warn('[pi-ai] systemPrepend 失败:', err?.message?.slice(0, 100));
+            }
+        }
+        if (tools && tools.length > 0) {
+            try {
+                const { getToolManifest, formatForPrompt } = await import('./tool-manifest/index.js');
+                const manifests = tools
+                    .map((id) => getToolManifest(id))
+                    .filter((m) => m !== undefined);
+                if (manifests.length > 0) {
+                    const toolPrompt = formatForPrompt(manifests);
+                    finalMessages = [
+                        { role: 'system', content: toolPrompt },
+                        ...messages,
+                    ];
+                }
+            }
+            catch (err) {
+                console.warn('[pi-ai] tool-manifest 加载失败:', err.message?.slice(0, 100));
+            }
+        }
         switch (this.provider) {
             case 'openai':
             case 'minimax':
@@ -77,17 +134,17 @@ export class PiAIModel {
             case 'kimi':
             case 'glm':
             case 'qwen':
-                return this.callOpenAI(messages, temperature, maxTokens, signal);
+                return this.callOpenAI(finalMessages, temperature, maxTokens, signal);
             case 'anthropic':
-                return this.callAnthropic(messages, temperature, maxTokens, signal);
+                return this.callAnthropic(finalMessages, temperature, maxTokens, signal);
             case 'ollama':
-                return this.callOllama(messages, temperature, signal);
+                return this.callOllama(finalMessages, temperature, signal);
             case 'openrouter':
-                return this.callOpenRouter(messages, temperature, maxTokens, signal);
+                return this.callOpenRouter(finalMessages, temperature, maxTokens, signal);
             case 'gemini':
-                return this.callGemini(messages, temperature, maxTokens, signal);
+                return this.callGemini(finalMessages, temperature, maxTokens, signal);
             case 'local':
-                return this.callLocal(messages, temperature, signal);
+                return this.callLocal(finalMessages, temperature, signal);
             default:
                 throw new Error(`Unsupported provider: ${this.provider}`);
         }
@@ -152,19 +209,23 @@ export class PiAIModel {
         if (!apiKey) {
             throw new Error('OPENAI_API_KEY not set');
         }
+        const requestBody = {
+            model: this.mapModel(),
+            messages,
+            temperature,
+            max_tokens: maxTokens
+        };
         const response = await fetch(`${this.getBaseUrl()}/chat/completions`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
                 'Authorization': `Bearer ${apiKey}`
             },
-            body: JSON.stringify({
-                model: this.mapModel(),
-                messages,
-                temperature,
-                max_tokens: maxTokens
-            }),
-            signal,
+            body: JSON.stringify(requestBody),
+            // 2026-06-15: signal 字段防御 — Node 22+ undici 强类型 AbortSignal, 非 AbortSignal 实例
+            //   (e.g. 误传的 { maxTokens: 1 } 对象) 会 throw "Expected signal to be AbortSignal".
+            //   若不是 AbortSignal, 退到无 signal 调用, fetch 自然支持 timeout 由外层控制.
+            signal: signal instanceof AbortSignal ? signal : undefined,
         });
         if (!response.ok) {
             throw new Error(`OpenAI API error: ${response.status}`);
@@ -285,6 +346,32 @@ export class PiAIModel {
     async callLocal(messages, temperature, signal) {
         return this.callOllama(messages, temperature, signal);
     }
+    // 注: callLocal 直接代理 ollama. 工具清单由 generateText 在外层拼到 messages, 这里 messages 已是 finalMessages.
+    async buildSystemPromptAsync(context) {
+        // 走 layer registry: 装配所有相关 layer (身份/行为/工具/角色/渠道)
+        try {
+            const { assembleSystemPrompt, SYSTEM_PROMPT_VERSION } = await import('./system-prompt/registry.js').catch(() => import('./system-prompt/registry.js'));
+            // channel = 本机 (PI SDK 直接调就是 local)
+            // role = 由 prompt context 决定 (默认 expert)
+            const ctx = context ? { channel: 'local', role: 'expert' } : { channel: 'local', role: 'expert' };
+            const result = await assembleSystemPrompt(ctx);
+            return `${result.text}\n\n## User Working Directory\n${context || process.cwd()}\n\n## bolloon-runtime\n${SYSTEM_PROMPT_VERSION} · layers: ${result.layerIds.join(',')}`;
+        }
+        catch (err) {
+            // 降级: 旧硬编码 (layer registry 不可用时不挂)
+            console.warn('[pi-ai] layer registry 不可用, 降级:', err.message?.slice(0, 100));
+            const envDetails = this.getEnvironmentDetails();
+            return `You are a friendly AI assistant in a P2P document collaboration network.
+
+## User Working Directory
+${context || process.cwd()}
+
+## Environment
+${envDetails}`;
+        }
+    }
+    // 同步版: 旧调用点 (buildSystemPrompt 是同步)
+    // 保留但内部用 sync fallback; 后续可改成 async
     buildSystemPrompt(context) {
         const envDetails = this.getEnvironmentDetails();
         return `You are a friendly AI assistant in a P2P document collaboration network.