@bolloon/bolloon-agent 0.2.11 → 0.2.13

package/dist/agents/workflow-pivot-loop.js

@@ -77,14 +77,25 @@ export class WorkflowPivotLoop {
     tools;
     messageHistory;
     streamCallback;
+    // 2026-07-06: pivot 想看内部明细设 BOLLOON_VERBOSE=1 — 默认只保留 status 事件给 UI
+    verbose = typeof process !== 'undefined' && process.env?.BOLLOON_VERBOSE === '1';
+    vlog(msg) { if (this.verbose)
+        console.log(msg); }
+    onApproachingTokenBudget;
+    compactedThisRun = false; // 防止 pivot 单次 execute 反复触发 compact
+    // 2026-07-06: iter ≥ 2 时用简短 systemHeader 替代完整 systemPrompt
+    //   pivot 默认 moderate profile 是 30 iter, 每次调 llm 都重复装 11K persona+tools 装 + 25 layer
+    //   (pi-ai.ts buildSystemPromptAsync 重复读 .md) — 真没必要. 第一轮装全, 后续用锚句占位.
+    //   compactor 触发后 (旧 systemHeader 代表性弱化) 再重新装一次全量.
+    continuationSystemHeader = null;
     constructor(config) {
         this.tools = new Map();
         // Default configuration based on task complexity if not provided
         const defaults = {
-            maxIterations: config.maxIterations || 50,
+            maxIterations: config.maxIterations || 1000, // 2026-07-06: 持久循环 (旧 50)
             minIterations: config.minIterations || 2,
             qualityThreshold: config.qualityThreshold || 0.7,
-            maxConsecutiveNoProgress: config.maxConsecutiveNoProgress || 5,
+            maxConsecutiveNoProgress: config.maxConsecutiveNoProgress || 8,
             maxTokenBudget: config.maxTokenBudget || 50000,
             complexity: config.complexity || 'moderate'
         };
@@ -120,13 +131,33 @@ export class WorkflowPivotLoop {
     /**
      * Execute the pivot loop
      */
-    async execute(input, llm, systemPrompt, streamCallback) {
+    async execute(input, llm, systemPrompt, streamCallback, signal, 
+    /**
+     * 2026-07-06: token 预算接近上限时回调 — 让上层 (PiAgentSession) 跑 compactor
+     *   否者单纯报 "Token 预算超支" 直接 break, 用户消息丢失.
+     *   回调同步返回值 (newMessageHistory) 时替换 this.messageHistory 后继续.
+     *   异步: PiAgent 触发 compactPipeline, 这里 await 等折叠完再继续.
+     */
+    onApproachingTokenBudget) {
         this.streamCallback = streamCallback;
         this.state = this.createInitialState();
+        this.onApproachingTokenBudget = onApproachingTokenBudget;
+        // 2026-07-06: 准备短 systemHeader. iter ≥ 2 用它替代完整 systemPrompt
+        //   LLM 已经在 messageHistory 里看到全部历史, 不需要每次重装. compact 触发后下次再装全量.
+        this.continuationSystemHeader = this.buildContinuationHeader(systemPrompt);
+        // 重置 compact 状态 — 这次 execute 第一次 iter 仍用全量
+        this.compactedThisRun = false;
+        this.vlog(`[pivot] execute: input chars=${input.length}, systemPrompt chars=${systemPrompt.length}, signal=${!!signal}, continuationHeader chars=${this.continuationSystemHeader?.length ?? 0}`);
         this.messageHistory = [{ role: 'user', content: input }];
         // Analyze task complexity and adapt config
         const taskProfile = analyzeTaskComplexity(input);
         const effectiveConfig = this.adaptConfigForTask(taskProfile);
+        // 2026-06-18 (supervisor): taskProfile 算的 tokenBudget 只看 input 长度, 但 systemPrompt 53K 时不够
+        // 把 effectiveConfig.maxTokenBudget 提到 systemPrompt * 1.2 留余量, 简单问题也走完
+        // 2026-07-06: 但累计 totalTokens = systemPrompt + sum(replies), 每 iter LLM 反 ~3-10K
+        //   旧公式 budget=11K*1.2=13K, 5 iter 累计 5 × 11K + replies = ~70K → 12-13K 处直接 break.
+        //   修法: budget = systemPrompt × 1.2 × maxIterations, 容纳 N 次 prompt + N-1 次 reply.
+        effectiveConfig.maxTokenBudget = Math.max(effectiveConfig.maxTokenBudget, Math.ceil(systemPrompt.length * 1.2 * effectiveConfig.maxIterations));
         this.emit({
             type: 'status',
             content: `🔍 任务复杂度: ${taskProfile.complexity} (预估 ${taskProfile.estimatedSteps} 步)`,
@@ -139,6 +170,15 @@ export class WorkflowPivotLoop {
         });
         let response = '';
         while (this.shouldContinue(effectiveConfig)) {
+            // 2026-07-04: signal abort 让 pivot 提前退出 (防止 LLM hang)
+            if (signal?.aborted) {
+                this.emit({
+                    type: 'status',
+                    content: `⏹️ pivot loop 被 abort (iter=${this.state.iteration})`,
+                    tool: 'loop'
+                });
+                break;
+            }
             this.state.iteration++;
             this.emit({
                 type: 'status',
@@ -148,13 +188,57 @@ export class WorkflowPivotLoop {
             // Build context for LLM
             const context = this.buildContext();
             const fullPrompt = `${systemPrompt}\n\n${context}`;
+            // 2026-07-06: iter ≥ 2 改用 continuationHeader — messageHistory 已经载过全 persona/tools,
+            //   重装 11K + 25 layer 是浪费, 同时让 pi-ai.chat 走 < 2000 分支 (不重新装 system prompt).
+            //   compact 触发 → 这次 iter 之后下一 iter 恢复用 full.
+            let headerForThisIter = systemPrompt;
+            let usingContinuation = false;
+            const shouldUseContinuation = this.state.iteration >= 2 && !this.compactedThisRun && this.continuationSystemHeader;
+            if (shouldUseContinuation) {
+                headerForThisIter = this.continuationSystemHeader;
+                usingContinuation = true;
+            }
+            this.vlog(`[pivot] iter=${this.state.iteration} ctx=${context.length} fullPrompt=${fullPrompt.length} budget=${effectiveConfig.maxTokenBudget} iterHeader=${usingContinuation ? 'short' : 'full'} (${headerForThisIter.length}B)`);
             try {
                 // Call LLM
-                const llmResponse = await llm.chat(context, systemPrompt);
+                const t0 = Date.now();
+                const llmResponse = await llm.chat(context, headerForThisIter, signal);
                 const reply = llmResponse.reply.trim();
+                this.vlog(`[pivot] iter=${this.state.iteration} LLM took=${Date.now() - t0}ms reply=${reply.length} head=${reply.substring(0, 80).replace(/\n/g, ' ')}`);
                 this.emit({ type: 'token', content: reply.substring(0, 100) });
+                // 2026-07-06: 把完整 reply 推给前端 — 前端按需更新临时气泡
+                //   之前只 emit token(100B 截断), 前端拿到 100B 看不清. 现在 emit preview 带完整 content.
+                //   折叠 / 清洗交给前端的 message-renderer.addMessage (类型 ai 入口统一 strip).
+                this.emit({ type: 'reply-preview', content: reply, iteration: this.state.iteration });
                 // Estimate token usage
-                this.state.totalTokens += this.estimateTokens(fullPrompt) + this.estimateTokens(reply);
+                this.state.totalTokens += this.estimateTokens(headerForThisIter + '\n\n' + context) + this.estimateTokens(reply);
+                // 2026-07-06: token 接近预算时先尝试自动压缩, 而不是直接 break — 上层 PiAgentSession
+                //   通过 onApproachingTokenBudget 回调触发 compactPipeline (5 层短路)
+                const budgetRatio = this.state.totalTokens / effectiveConfig.maxTokenBudget;
+                if (budgetRatio > 0.7 && this.onApproachingTokenBudget && !this.compactedThisRun && this.messageHistory.length >= 6) {
+                    this.compactedThisRun = true;
+                    this.emit({
+                        type: 'status',
+                        content: `🗜️ token ${this.state.totalTokens} 接近预算 (${(budgetRatio * 100).toFixed(0)}%), 尝试自动压缩上下文`,
+                        tool: 'compactor',
+                    });
+                    try {
+                        await this.onApproachingTokenBudget();
+                        // 重置 totalTokens 因为 compactor 折叠后本来就不准
+                        this.state.totalTokens = Math.ceil(systemPrompt.length * 0.5); // 粗略剩余量
+                        this.emit({
+                            type: 'status',
+                            content: `🗜️ 自动压缩完成, 继续循环 (剩余估算 ${this.state.totalTokens} chars)`,
+                            tool: 'compactor',
+                        });
+                        // 继续 loop, 不 break
+                        continue;
+                    }
+                    catch (err) {
+                        console.warn('[pivot] onApproachingTokenBudget failed (non-fatal, 继续走 token 阈值):', String(err?.message || err).slice(0, 100));
+                        // compact 失败 → 回到原 check
+                    }
+                }
                 // Check token budget
                 if (this.state.totalTokens > effectiveConfig.maxTokenBudget) {
                     this.emit({
@@ -166,6 +250,39 @@ export class WorkflowPivotLoop {
                 // Check if this is a final response (no tool calls)
                 const pendingTools = this.extractPendingToolUses(reply);
                 if (pendingTools.length === 0) {
+                    // 2026-07-06: LLM 显式 <final gen> 标记 — pivot 立即退出, 不再走 quality/iter 流程
+                    //   这个 marker 之前和 思考/ 同义被忽略, 害得 "你好" 类问题跑 11 iter 还不见停
+                    //   加上之后 iter=1 收到 <final gen> 就 accept
+                    if (/<final\s+gen\s*\/?>|<\/final\s+gen>/i.test(reply)) {
+                        const cleaned = reply.replace(/<final\s+gen\s*\/?>|<\/final\s+gen>/gi, '').trim();
+                        response = cleaned || reply;
+                        this.emit({
+                            type: 'status',
+                            content: `✅ 检测到 <final gen> 结束标记, 立即退出 (iter=${this.state.iteration})`,
+                            tool: 'system',
+                        });
+                        return this.createResult(true, response, 'final_gen_marker');
+                    }
+                    // Check if the reply contains tool call intent but couldn't be parsed
+                    // 2026-07-06: 排除合法的 思考/<final gen> 这些 tag (它们是 sentinel 不是 tool call)
+                    const cleanedForIntentCheck = reply
+                        .replace(/<final\s+gen\s*\/?>|<\/final\s+gen>/gi, '')
+                        .replace(/<\/?think(?:ing)?>/gi, ''); // 移除
+                    const containsToolCallIntent = cleanedForIntentCheck.includes('调用工具') || cleanedForIntentCheck.includes('tool(') ||
+                        cleanedForIntentCheck.includes('使用工具') || cleanedForIntentCheck.includes('需要获取') || cleanedForIntentCheck.includes('需要查看') ||
+                        cleanedForIntentCheck.includes('tool =>') || cleanedForIntentCheck.includes('[TOOL_CALL]') ||
+                        // 仅匹配真工具调用 tag (tool_use / function_calls / tool_call / invoke / tool_code)
+                        /<\s*(tool_use|tool_call|function_calls?|tool_code|invoke)\s*>/i.test(cleanedForIntentCheck);
+                    // If there's tool call intent but no parsed tools, continue the loop
+                    if (containsToolCallIntent && this.state.iteration < effectiveConfig.maxIterations) {
+                        this.emit({
+                            type: 'status',
+                            content: `🔄 检测到工具调用意图但格式无法解析，继续循环...`,
+                            tool: 'system'
+                        });
+                        this.state.consecutiveNoProgress++;
+                        continue;
+                    }
                     // No pending tool uses - this is a normal completion
                     this.state.pendingToolUses = [];
                     // Evaluate quality before accepting
@@ -377,6 +494,29 @@ export class WorkflowPivotLoop {
                 }
             }
         }
+        // 2026-06-18 (supervisor): Claude Code 风格 <tool_call><tool_name>...</tool_call>
+        //   bolloon agent 之前一直被 model 教用这个格式, 但 pivot loop 只认 3 个旧 pattern.
+        //   现在加: <tool_call><invoke name="X"><parameter name="k">v</parameter></invoke></tool_call>
+        const toolCodeRe = /<tool_code>([\s\S]*?)<\/tool_code>/g;
+        while ((match = toolCodeRe.exec(content)) !== null) {
+            const block = match[1];
+            const invokeRe = /<invoke\s+name="(\w+)"\s*>([\s\S]*?)<\/invoke>/g;
+            let im;
+            while ((im = invokeRe.exec(block)) !== null) {
+                const name = im[1];
+                if (!this.tools.has(name))
+                    continue;
+                const args = {};
+                const paramRe = /<parameter\s+name="(\w+)"\s*>([\s\S]*?)<\/parameter>/g;
+                let pm;
+                while ((pm = paramRe.exec(im[2])) !== null) {
+                    args[pm[1]] = pm[2].trim().replace(/^["']|['"]$/g, '');
+                }
+                if (!pending.some(p => p.name === name)) {
+                    pending.push({ name, args, description: '', parameters: {} });
+                }
+            }
+        }
         // Pattern 1: Chinese format "调用工具: tool_name(args)"
         const pattern1 = /调用工具[：:]\s*(\w+)\s*\(([^)]*)\)/g;
         while ((match = pattern1.exec(content)) !== null) {
@@ -417,6 +557,31 @@ export class WorkflowPivotLoop {
         catch {
             // JSON parsing failed, ignore
         }
+        // Pattern 4: Single JSON tool call format {"name": "tool_name", "arguments": {...}}
+        try {
+            const singleJsonRe = /\{\s*"name"\s*:\s*"(\w+)"\s*,\s*"arguments"\s*:\s*(\{[\s\S]*?\})\s*\}/g;
+            let singleMatch;
+            while ((singleMatch = singleJsonRe.exec(content)) !== null) {
+                const name = singleMatch[1];
+                if (pending.some(p => p.name === name))
+                    continue;
+                if (!this.tools.has(name))
+                    continue;
+                try {
+                    const args = JSON.parse(singleMatch[2]);
+                    if (args && typeof args === 'object') {
+                        const normalizedArgs = this.normalizeArgs(args);
+                        pending.push({ name, args: normalizedArgs, description: '', parameters: {} });
+                    }
+                }
+                catch {
+                    // JSON parsing failed, skip
+                }
+            }
+        }
+        catch {
+            // Pattern matching failed, ignore
+        }
         return pending;
     }
     /**
@@ -493,25 +658,21 @@ export class WorkflowPivotLoop {
      * Evaluate response quality
      */
     evaluateQuality(response) {
-        let score = 0.5;
-        // Length-based scoring
+        let score = 0.7; // 2026-07-06: 起点 0.7 — 短回复不应被当成低质量打回去重跑
+        // Length bonus
         if (response.length > 100)
-            score += 0.1;
+            score += 0.05;
         if (response.length > 500)
             score += 0.1;
-        if (response.length < 30)
-            score -= 0.2;
-        // Structure indicators
+        // Structure
         if (response.includes('\n'))
             score += 0.05;
-        if (response.includes('-') || response.includes('•'))
-            score += 0.05;
         if (response.includes('```'))
             score += 0.1;
-        // Content quality indicators
-        const conclusionWords = ['完成', '结果', '总结', '所以', '因此', '答案', '推荐', '建议'];
+        // Conclusion language
+        const conclusionWords = ['完成', '总结', '所以', '因此', '答案', '推荐', '建议'];
         if (conclusionWords.some(w => response.includes(w)))
-            score += 0.1;
+            score += 0.05;
         // Negative indicators
         if (response.includes('调用工具') || response.includes('tool('))
             score -= 0.15;
@@ -546,6 +707,20 @@ export class WorkflowPivotLoop {
         // Rough estimate: ~4 characters per token for Chinese/English mix
         return Math.ceil(text.length / 4);
     }
+    /**
+     * 2026-07-06: build continuation header — iter ≥ 2 的短 system 头部
+     *   LLM 已在 messageHistory 里, 不需要每次 11K persona+tools 重装.
+     *   短头告诉 LLM: "你已经看过首轮; 继续 conversation, 详情见历史".
+     */
+    buildContinuationHeader(fullSystemPrompt) {
+        // 从 fullSystemPrompt 提取关键锚句: identity persona 第 1 行 + 工作模式 head 段
+        //   完整重装只在 iter=1 和 compact 之后两次
+        const lines = fullSystemPrompt.split('\n');
+        const identityLine = lines.find((l) => l.includes('你是') && !l.includes('(续)')) ?? '';
+        return `[continuation] 你的 persona + tools + judgments 已在首轮 messageHistory 中.
+${identityLine ? identityLine + '\n' : ''}当前 step 别再读 persona 全文, 继续推进任务即可.
+> <final gen> 只在真完成时输出.`;
+    }
     /**
      * Create result object
      */
@@ -607,26 +782,29 @@ export class WorkflowPivotLoop {
  * Factory to create a default pivot loop configuration
  */
 export function createDefaultPivotConfig(complexity) {
+    // 2026-07-06: maxIterations 默认大幅上调 — LLM 自己约束结束时机, 持久循环.
+    //   真实停止由 LLM emit <final gen> / 质量达标 / 连续无进展 / user abort 触发.
+    //   旧 30/60 iter 在长任务 (eg. 大文档改写) 太短, 现在跑到 N 次也不报超时.
     const profiles = {
         simple: {
-            maxIterations: 15,
+            maxIterations: 200,
             minIterations: 1,
             qualityThreshold: 0.6,
-            maxConsecutiveNoProgress: 3,
+            maxConsecutiveNoProgress: 5,
             maxTokenBudget: 10000
         },
         moderate: {
-            maxIterations: 30,
+            maxIterations: 1000,
             minIterations: 2,
             qualityThreshold: 0.7,
-            maxConsecutiveNoProgress: 5,
+            maxConsecutiveNoProgress: 8,
             maxTokenBudget: 30000
         },
         complex: {
-            maxIterations: 60,
+            maxIterations: 2000,
             minIterations: 3,
             qualityThreshold: 0.75,
-            maxConsecutiveNoProgress: 8,
+            maxConsecutiveNoProgress: 12,
             maxTokenBudget: 60000
         }
     };

package/dist/bollharness/src/scripts/context_router.js

@@ -1,5 +1,12 @@
 import * as fs from "fs";
 import * as path from "path";
+import { fileURLToPath } from "url";
+// ESM compatibility: root package.json has "type": "module" so bare `__dirname`
+// is undefined at module-eval time (this module is re-exported via
+// dist/bollharness-integration/index.js which dist/index.js imports unconditionally,
+// so the crash fires before --web/--cli even reaches parseArgs).
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 export const FRAGMENTS_DIR = path.join(__dirname, "..", "context-fragments");
 export const CONTEXT_MAP = {
     "bridge_agent/": ["bridge-constitution"],

package/dist/bollharness/src/scripts/deploy-guard.js

@@ -104,17 +104,17 @@ function checkRsync(cmd) {
 function block(reason, host = null) {
     let guidance;
     if (host === PROD_IP) {
-        guidance = `请使用标准部署流程：
-  后端: bash scripts/deploy.sh --yes
-  Demo 正式: bash scripts/deploy-demo.sh <name> --channel prod --yes
-  Demo 内测: bash scripts/deploy-demo.sh <name> --channel preview --yes
-  Edge/Nginx: bash scripts/deploy-edge.sh --yes
+        guidance = `请使用标准部署流程：
+  后端: bash scripts/deploy.sh --yes
+  Demo 正式: bash scripts/deploy-demo.sh <name> --channel prod --yes
+  Demo 内测: bash scripts/deploy-demo.sh <name> --channel preview --yes
+  Edge/Nginx: bash scripts/deploy-edge.sh --yes
 详见 Bolloon.md Development Commands。`;
     }
     else if (BRIDGE_VPS_HOSTS.includes(host ?? "")) {
-        guidance = `Bridge VPS 必须走 git pull 更新路径：
-  ssh root@${host} 'sudo -u boll git -C /opt/boll pull --ff-only'
-  scp/rsync 直传会重新制造 orphan worktree。
+        guidance = `Bridge VPS 必须走 git pull 更新路径：
+  ssh root@${host} 'sudo -u boll git -C /opt/boll pull --ff-only'
+  scp/rsync 直传会重新制造 orphan worktree。
   详见 docs/issues/guard-20260408-0445-bridge-vps-orphan-worktree.md。`;
     }
     else {

package/dist/bollharness-integration/context-router-judgment.js

@@ -253,9 +253,9 @@ export async function generateJudgmentInjection(filePath, gate, options = {}) {
     const header = gate === 3
         ? '# Plan Freeze - Decision Principles'
         : `# Gate ${gate} - Active Judgments`;
-    return `${header}
-# Path: ${filePath}
-# Confidence: ${(result.confidence * 100).toFixed(0)}%
-
+    return `${header}
+# Path: ${filePath}
+# Confidence: ${(result.confidence * 100).toFixed(0)}%
+
 ${result.contextYaml}`;
 }