@bolloon/bolloon-agent 0.3.51 → 0.4.0

package/dist/agents/shell-guard.js

@@ -44,6 +44,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
+import { t as i18nT } from '../web/i18n.js';
 // ============================================================================
 // 硬编码兜底 (策略文件读不到时, 用这套)
 // 这是**最后一道防线** - AI 即便能改 ~/.bolloon/ 也没法删这个常量
@@ -357,6 +358,15 @@ const TERMINAL_DENY_PATTERNS = [
     /\bgit\s+push\b[^|]*\s+(-f|--force)/, // 强推
     /\bgit\s+reset\s+--hard\b/,
     /\bkill\s+-9\s+\d+\b/, // 杀进程 (保留给用户)
+    // 2026-08-11 (Hermes cron/lifecycle_guard 模式): 自生命周期命令 — agent 通过 terminal
+    // 重启/杀掉自己宿主服务 (bolloon) 会形成复活循环: 服务死 → supervisor 复活 → 自动 resume
+    // → 同一命令再自杀. 策略: 命令形状锚定 (只匹配真实命令标识符, 不匹配散文, 误报率低).
+    /\b(bolloon|bolloon-agent|bolloon-agent-service)\s+(restart|stop|kill|quit|shutdown)\b/i,
+    /\bpm2\s+(restart|stop|delete|kill)\s+[\w./-]*bolloon\b/i,
+    /\b(systemctl|service)\s+(restart|stop|kill)\s+[\w.-]*bolloon\b/i,
+    /\bpkill\s+(-[a-z]+\s+)*(-f\s+)?[\w./-]*bolloon\b/i,
+    /\btaskkill\s+[^|]*\/IM\s+[\w-]*bolloon\b/i,
+    /\btaskkill\s+[^|]*\/FI\s+"?[^"]*bolloon/i,
 ];
 /** 检查完整 shell 命令 (terminal 工具用). denylist-only: 命中高危模式即拒, 否则放行. */
 export function checkTerminalCommand(rawCmd) {
@@ -366,7 +376,18 @@ export function checkTerminalCommand(rawCmd) {
     for (const pattern of TERMINAL_DENY_PATTERNS) {
         if (pattern.test(cmd)) {
             auditShellCall('denied', cmd, [], `terminal 高危模式 ${pattern}`);
-            return { allowed: false, reason: `命令命中高危护栏 ${pattern} (核心不碰: 提权/格式化/删根/.bolloon 数据). 换一条安全命令.`, matchedBy: 'arg-denylist' };
+            // 2026-08-11: 用户可见静态文案走 i18n 目录 (Hermes locales 模式); 目录不可用时中文直出
+            let reason;
+            try {
+                const isSelfLifecycle = /(bolloon|pm2|systemctl|service|pkill|taskkill)/.test(pattern.source);
+                reason = isSelfLifecycle
+                    ? i18nT('guard.self_lifecycle_reason', undefined, { pattern: String(pattern) })
+                    : i18nT('guard.deny_reason', undefined, { pattern: String(pattern) });
+            }
+            catch {
+                reason = `命令命中高危护栏 ${pattern} (核心不碰: 提权/格式化/删根/.bolloon 数据). 换一条安全命令.`;
+            }
+            return { allowed: false, reason, matchedBy: 'arg-denylist' };
         }
     }
     auditShellCall('allowed', cmd, []);

package/dist/agents/skill-organizer.js

@@ -143,25 +143,25 @@ export async function scanLeftoverSkills(opts = {}) {
 // ───────────────────────── B. 经验进化 (LLM 完整总结) ─────────────────────────
 /** 把候选的工具调用记录扩写成完整经验 — LLM prompt (结构化 JSON 输出) */
 export function buildEvolvePrompt(c) {
-    return `你是经验总结专家。下面是 Bolloon 智能体在一轮运行中连续成功调用的工具记录 (已运行 ${c.runs || 1} 次)。
-
-工具记录:
-名称: ${c.name}
-描述: ${c.description}
-原始记录:
-${String(c.body || '').slice(0, 4000)}
-
-请把这份"工具调用记录"扩写成一份完整的、可复用的经验文档, 要求:
-1. name: 一个简短的小写英文名 (字母数字连字符, 概括这套操作)
-2. description: 一句话描述 (什么场景用)
-3. body: 完整经验正文, 按以下结构:
-   ## 背景 — 这套操作在什么场景下用, 解决什么问题
-   ## 触发条件 — 什么信号/需求出现时应该使用
-   ## 流程 — 具体步骤 (保留原始工具名), 每步说明目的
-   ## 注意事项 — 易错点 / 边界情况 / 已知坑
-   ## 验证 — 怎么确认结果正确
-
-只输出一个 JSON 对象, 不要任何其他文字:
+    return `你是经验总结专家。下面是 Bolloon 智能体在一轮运行中连续成功调用的工具记录 (已运行 ${c.runs || 1} 次)。
+
+工具记录:
+名称: ${c.name}
+描述: ${c.description}
+原始记录:
+${String(c.body || '').slice(0, 4000)}
+
+请把这份"工具调用记录"扩写成一份完整的、可复用的经验文档, 要求:
+1. name: 一个简短的小写英文名 (字母数字连字符, 概括这套操作)
+2. description: 一句话描述 (什么场景用)
+3. body: 完整经验正文, 按以下结构:
+   ## 背景 — 这套操作在什么场景下用, 解决什么问题
+   ## 触发条件 — 什么信号/需求出现时应该使用
+   ## 流程 — 具体步骤 (保留原始工具名), 每步说明目的
+   ## 注意事项 — 易错点 / 边界情况 / 已知坑
+   ## 验证 — 怎么确认结果正确
+
+只输出一个 JSON 对象, 不要任何其他文字:
 {"name": "...", "description": "...", "body": "..."}`;
 }
 /** 解析 LLM 返回的 JSON (容错: 剥 markdown 代码块, 取第一个 {...}) */

package/dist/agents/verify-recipe.js

@@ -0,0 +1,84 @@
+/**
+ * verify-recipe.ts — 项目验证配方 (借鉴 Hermes agent/verify/recipes.py:
+ *   从项目自己的 package.json scripts 提取验证命令, 依序执行 build→test)
+ *
+ * 用途: agent 完成修改后跑 verify_project 工具 → 完成契约 (B7) 要求的证据落地 —
+ *   "宣布完成前展示具体证据 (命令输出/测试结果)" 有了工具支撑.
+ * 纯函数 + runner 分离, 可单测.
+ */
+import { spawn } from 'child_process';
+/**
+ * 从 package.json scripts 提取验证命令 (Hermes _detect_node_recipe 逻辑):
+ *   build 阶段: build, typecheck (存在才加, 按序)
+ *   test 阶段:  test, check, lint (存在才加, 按序)
+ * runner: npm run <script> (pnpm/bun/yarn 时对应前缀)
+ */
+export function extractVerifyCommands(scripts, packageManager) {
+    if (!scripts || typeof scripts !== 'object')
+        return [];
+    const runner = (entry) => {
+        if (packageManager === 'pnpm')
+            return `pnpm ${entry}`;
+        if (packageManager === 'bun')
+            return `bun run ${entry}`;
+        if (packageManager === 'yarn')
+            return `yarn ${entry}`;
+        return `npm run ${entry}`;
+    };
+    const out = [];
+    for (const name of ['build', 'typecheck', 'test', 'check', 'lint']) {
+        if (typeof scripts[name] === 'string') {
+            out.push({ name, command: runner(name) });
+        }
+    }
+    return out;
+}
+/** 从 lockfile 检测包管理器 (Hermes detect_package_manager) */
+export function detectPackageManager(files) {
+    if (files.includes('pnpm-lock.yaml'))
+        return 'pnpm';
+    if (files.includes('bun.lockb') || files.includes('bun.lock'))
+        return 'bun';
+    if (files.includes('yarn.lock'))
+        return 'yarn';
+    if (files.includes('package-lock.json'))
+        return 'npm';
+    return undefined;
+}
+/** 依序执行验证命令; 任一步失败不中断 (收集全量结果), 全部 exit 0 才算通过 */
+export async function runVerifyCommands(opts) {
+    const stepTimeoutMs = opts.stepTimeoutMs ?? 5 * 60 * 1000;
+    const steps = [];
+    for (const cmd of opts.commands) {
+        const t0 = Date.now();
+        const result = await new Promise((resolve) => {
+            const child = spawn(cmd.command, { cwd: opts.cwd, shell: true, env: process.env });
+            let output = '';
+            let timedOut = false;
+            const timer = setTimeout(() => {
+                timedOut = true;
+                child.kill('SIGTERM');
+            }, stepTimeoutMs);
+            child.stdout?.on('data', (d) => {
+                output += d.toString();
+                if (output.length > 20_000)
+                    output = output.slice(-20_000);
+            });
+            child.stderr?.on('data', (d) => {
+                output += d.toString();
+                if (output.length > 20_000)
+                    output = output.slice(-20_000);
+            });
+            child.on('close', (code) => {
+                clearTimeout(timer);
+                resolve({ exitCode: code, durationMs: Date.now() - t0, outputTail: output.slice(-2000), timedOut });
+            });
+            child.on('error', (err) => {
+                clearTimeout(timer);
+                resolve({ exitCode: null, durationMs: Date.now() - t0, outputTail: `spawn 失败: ${err.message}`, timedOut });
+            });
+        });
+        steps.push({ name: cmd.name, command: cmd.command, ...result });
+    }
+    return { steps, allPassed: steps.every((s) => s.exitCode === 0 && !s.timedOut) };
+}

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

@@ -12,6 +12,55 @@
  * - Consecutive invalid iteration detection
  * - Token budget awareness
  */
+import { detectRepeatingCalls, toolCallArgsHash } from './loop-review.js';
+/**
+ * 2026-08-11 (借鉴 Hermes `_canonicalize_tool_call_arguments`): 工具参数规范化 —
+ * LLM 返回的 arguments 常带尾随散文/尾逗号/代码围栏, 直接 JSON.parse 失败会丢整个工具调用.
+ * 策略: 直接解析 → 截到最后一个闭合 } → 去代码围栏, 逐级降级; 结果必须是非数组对象.
+ */
+export function canonicalizeToolCallArguments(argStr) {
+    if (typeof argStr !== 'string')
+        return {};
+    const s = argStr.trim();
+    if (!s)
+        return {};
+    const tryParse = (text) => {
+        try {
+            const parsed = JSON.parse(text);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+                return parsed;
+        }
+        catch { /* 下一级 */ }
+        return null;
+    };
+    const direct = tryParse(s);
+    if (direct)
+        return direct;
+    // LLM 在 JSON 后追加散文 — 截到最后一个闭合 } 再试
+    const lastClose = s.lastIndexOf('}');
+    if (lastClose > 0) {
+        const truncated = tryParse(s.slice(0, lastClose + 1));
+        if (truncated)
+            return truncated;
+    }
+    // 代码围栏包裹
+    const fenced = s.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '').trim();
+    if (fenced && fenced !== s) {
+        const unfenced = tryParse(fenced);
+        if (unfenced)
+            return unfenced;
+    }
+    return {};
+}
+/** 2026-08-11 (Hermes build_worker_context 全限幅): 工具输出进 LLM 上下文的上限 */
+export const TOOL_RESULT_MAX_CHARS = 12_000;
+/** 截断工具输出 (纯函数, 可单测): 超限 → 保留前 max + 可见省略标记 */
+export function truncateToolOutput(output, max = TOOL_RESULT_MAX_CHARS) {
+    const s = output ?? '';
+    if (s.length <= max)
+        return s;
+    return s.slice(0, max) + `\n… [truncated, ${s.length - max} chars omitted]`;
+}
 /**
  * Analyze input to determine task complexity
  */
@@ -81,6 +130,10 @@ export class WorkflowPivotLoop {
     verbose = typeof process !== 'undefined' && process.env?.BOLLOON_VERBOSE === '1';
     vlog(msg) { if (this.verbose)
         console.log(msg); }
+    pushContinuationHint(hint) {
+        if (!this.continuationHints.includes(hint))
+            this.continuationHints.push(hint);
+    }
     onApproachingTokenBudget;
     compactedThisRun = false; // 防止 pivot 单次 execute 反复触发 compact
     // 2026-07-06: iter ≥ 2 时用简短 systemHeader 替代完整 systemPrompt
@@ -88,6 +141,11 @@ export class WorkflowPivotLoop {
     //   (pi-ai.ts buildSystemPromptAsync 重复读 .md) — 真没必要. 第一轮装全, 后续用锚句占位.
     //   compactor 触发后 (旧 systemHeader 代表性弱化) 再重新装一次全量.
     continuationSystemHeader = null;
+    // 2026-08-11 (Hermes `_get_continuation_prompt` 模式): 本轮工具执行的结构性问题
+    // (未知工具被跳过/输出过大) → 下轮注入显式续跑提示, LLM 不会静默忽略.
+    continuationHints = [];
+    // 2026-08-11 (循环工作流检测): 最近工具调用记录 (name+argsHash), 连续相同 = 有活动无进展
+    recentToolCalls = [];
     constructor(config) {
         this.tools = new Map();
         // Default configuration based on task complexity if not provided
@@ -167,16 +225,11 @@ export class WorkflowPivotLoop {
             if (!fn || !fn.name)
                 continue;
             const name = fn.name;
-            if (!this.tools.has(name))
+            if (!this.tools.has(name)) {
+                this.pushContinuationHint(`工具 ${name} 未注册/不存在, 调用已跳过 — 请换用已提供的工具`);
                 continue;
-            let args = {};
-            try {
-                const parsed = JSON.parse(fn.arguments || '{}');
-                if (parsed && typeof parsed === 'object')
-                    args = parsed;
             }
-            catch { /* args 保持空 */ }
-            out.push({ name, args: this.normalizeArgs(args), description: '', parameters: {} });
+            out.push({ name, args: this.normalizeArgs(canonicalizeToolCallArguments(fn.arguments)), description: '', parameters: {} });
         }
         return out;
     }
@@ -238,7 +291,13 @@ export class WorkflowPivotLoop {
                 tool: 'loop'
             });
             // Build context for LLM
-            const context = this.buildContext();
+            let context = this.buildContext();
+            // 2026-08-11: 注入工具续跑提示 (Hermes continuation prompt 模式) — 结构性问题显式告知,
+            //   用完即清 (只对下一轮 LLM 可见一次)
+            if (this.continuationHints.length > 0) {
+                context += `\n\n【工具续跑提示】\n${this.continuationHints.map((h) => `- ${h}`).join('\n')}\n请基于以上信息继续推进任务, 不要重复已失败的调用。`;
+                this.continuationHints = [];
+            }
             const fullPrompt = `${systemPrompt}\n\n${context}`;
             // 2026-07-06: iter ≥ 2 改用 continuationHeader — messageHistory 已经载过全 persona/tools,
             //   重装 11K + 25 layer 是浪费, 同时让 pi-ai.chat 走 < 2000 分支 (不重新装 system prompt).
@@ -415,7 +474,29 @@ export class WorkflowPivotLoop {
                         args: toolCall.args || {},
                     });
                     try {
+                        // 2026-08-11 (Hermes wedged-loop 检测): 连续 3 次相同工具+相同参数 = 疑似循环工作流 —
+                        //   计入 no-progress (达到上限由 determineExitReason 中断), 注入续跑提示让 LLM 换策略
+                        const argsHash = toolCallArgsHash(toolCall.args);
+                        this.recentToolCalls.push({ name: toolCall.name, argsHash });
+                        if (this.recentToolCalls.length > 8)
+                            this.recentToolCalls.shift();
+                        const rep = detectRepeatingCalls(this.recentToolCalls);
+                        if (rep.repeating) {
+                            this.state.consecutiveNoProgress++;
+                            this.pushContinuationHint(`检测到重复工具调用 ${rep.name} (连续 ${this.recentToolCalls.slice(-3).length} 次相同参数) — 疑似循环, 请换一种策略或缩小范围, 不要重复同一调用`);
+                            this.emit({
+                                type: 'error',
+                                content: `⚠ 检测到重复工具调用 ${rep.name} (连续 3 次相同参数) — 疑似循环工作流, 已计入无进展`,
+                                tool: 'loop-guard',
+                            });
+                        }
                         const result = await tool.execute(toolCall.args ?? {});
+                        // 2026-08-11: 输出过大 → 续跑提示 (Hermes dropped-tools continuation 模式),
+                        //   上下文后续可能被压缩, 提醒 LLM 需要精确数据时缩小范围重查
+                        const outLen = (result.output || '').length;
+                        if (outLen > 12_000) {
+                            this.pushContinuationHint(`工具 ${toolCall.name} 输出过长 (${outLen} 字符), 上下文后续可能被压缩 — 如需精确数据请缩小范围重查`);
+                        }
                         // 2026-06-15: step-timeline — 关闭节点 (success / error)
                         this.emit({
                             type: result.success ? 'step_done' : 'step_error',
@@ -437,7 +518,11 @@ export class WorkflowPivotLoop {
                             role: 'assistant',
                             content: reply,
                             toolCall,
-                            toolResult: result
+                            // 2026-08-11 (Hermes 全限幅): 存进 LLM 上下文的工具输出截断到 12K,
+                            //   前端 step_done emit 仍用完整 output (不影响 UI)
+                            toolResult: outLen > TOOL_RESULT_MAX_CHARS
+                                ? { ...result, output: truncateToolOutput(result.output) }
+                                : result
                         });
                         // Record quality from tool result
                         const toolQuality = this.evaluateToolResult(result);
@@ -519,9 +604,12 @@ export class WorkflowPivotLoop {
             try {
                 const obj = JSON.parse(match[1]);
                 if (obj && obj.name && this.tools.has(obj.name)) {
-                    const args = this.normalizeArgs(obj.arguments || {});
+                    const args = this.normalizeArgs(canonicalizeToolCallArguments(obj.arguments));
                     pending.push({ name: obj.name, args, description: '', parameters: {} });
                 }
+                else if (obj && obj.name && !this.tools.has(obj.name)) {
+                    this.pushContinuationHint(`工具 ${obj.name} 未注册/不存在, 调用已跳过 — 请换用已提供的工具`);
+                }
             }
             catch (e) {
                 // JSON 解析失败, 继续下一 match
@@ -778,8 +866,8 @@ export class WorkflowPivotLoop {
         //   完整重装只在 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 全文, 继续推进任务即可.
+        return `[continuation] 你的 persona + tools + judgments 已在首轮 messageHistory 中.
+${identityLine ? identityLine + '\n' : ''}当前 step 别再读 persona 全文, 继续推进任务即可.
 > <final gen> 只在真完成时输出.`;
     }
     /**

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}`;
 }