@bolloon/bolloon-agent 0.1.40 → 0.1.42

package/dist/agents/pre-tool-validator.js

@@ -116,7 +116,8 @@ function shellGuardGate(tool, args, mode) {
         // 只对**写/删/改**类命令生效 (rm, cp, mv, sed -i, echo >); 读类命令 (cat, head, tail, ls) 跳过
         const READ_BINS = new Set(['cat', 'head', 'tail', 'wc', 'ls', 'echo', 'pwd', 'date', 'mkdir', 'touch', 'find', 'grep', 'git', 'node', 'npm', 'npx', 'tsx', 'tsc', 'vitest']);
         const FILENAME_DENYLIST = [
-            'pi-sdk.ts', 'shell-guard.ts', 'shell-tool.ts',
+            // 2026-06-17 (Q2-B): 解除 pi-sdk.ts — agent 可改自己源码
+            'shell-guard.ts', 'shell-tool.ts',
             '.env', 'package.json', 'tsconfig.json',
         ];
         const isReadOperation = READ_BINS.has(bin);

package/dist/agents/shell-guard.js

@@ -51,7 +51,10 @@ import * as os from 'os';
 const FALLBACK_COMMAND_ALLOWLIST = new Set([
     'git', 'node', 'npm', 'npx', 'tsx', 'tsc', 'vitest',
     'cat', 'head', 'tail', 'wc', 'ls', 'echo', 'pwd', 'date',
-    'mkdir', 'touch'
+    'mkdir', 'touch',
+    // M3.5 (2026-06-17): Windows cmd 内置命令 (cmd.exe shell 模式)
+    //   'cat'/'ls' 在 Git Bash 才存在, Windows 原生 cmd 用 'type'/'dir'
+    'type', 'dir', 'cd', 'where', 'set', 'echo.',
 ]);
 const FALLBACK_PATH_ALLOWLIST = [
     // 自由区: AI 可以改
@@ -66,7 +69,9 @@ const FALLBACK_PATH_ALLOWLIST = [
     'README.md'
 ];
 const FALLBACK_PATH_DENYLIST = [
-    /(^|\/)src\/agents\/pi-sdk\.ts$/, // LLM 抽象层
+    // 2026-06-17 (Q2-B): 解除 pi-sdk.ts denylist — 现在允许 agent 改自己源码以自进化
+    //   原屏蔽理由: "LLM 抽象层" — 但 owner 决定 auto-evolve 需要这个能力
+    //   仍保留: shell-guard.ts / shell-tool.ts — 改这两个等于改护栏本身, fail-open 风险太高
     /(^|\/)src\/agents\/shell-guard\.ts$/, // 护栏本身
     /(^|\/)src\/agents\/shell-tool\.ts$/, // shell 工具实现
     /(^|\/)src\/heartbeat\//, // 心跳
@@ -79,7 +84,8 @@ const FALLBACK_PATH_DENYLIST = [
     /(^|\/)\.git\//,
     /(^|\/)\.bolloon\//, // 策略文件 / sessions / persona
     /(^|\/)dist\//,
-    /(^|\/)node_modules\//,
+    // 2026-06-17: node_modules 不再 denylist, 因为 M3.4 自动 commit 阶段需要 npm install / npx vitest
+    //   通过 allowlist 限定 agent 只能 npm install, 不能 rm node_modules (shell arg denylist 仍禁 rm -rf)
 ];
 const FALLBACK_ARG_DENYLIST = [
     /^\s*push\s+(-f|--force)/i,

package/dist/agents/shell-tool.js

@@ -9,8 +9,18 @@
  * 禁区列表在 shell-guard.ts, AI 改不了那个文件.
  */
 import { spawn } from 'child_process';
-import * as fs from 'fs';
-import { checkCommand, checkWritePath, getSandboxCwd } from './shell-guard.js';
+import { checkCommand, checkWritePath } from './shell-guard.js';
+/**
+ * 把参数 quote 一下,避免 shell 元字符注入 (&& | ; ` > < 等).
+ * Windows: 用双引号包, 内部双引号转义.
+ */
+function shellQuoteArgs(arg) {
+    if (process.platform !== 'win32')
+        return arg; // POSIX shell 由 checkCommand 防护
+    if (!/[\s"&|<>^()%!`]/.test(arg))
+        return arg;
+    return `"${arg.replace(/"/g, '""')}"`;
+}
 /**
  * 在沙箱里跑一条命令
  * @param cmd  可执行文件名, 必须命中白名单
@@ -41,20 +51,25 @@ export async function shellExec(cmd, args = [], opts = {}) {
             }
         }
     }
-    // 3. 确保沙箱存在
-    const sandboxCwd = getSandboxCwd();
-    try {
-        fs.mkdirSync(sandboxCwd, { recursive: true });
-    }
-    catch {
-        // 已经存在则忽略
-    }
+    // 3. 确定运行 cwd
+    // M3.5 (2026-06-17 + 2026-06-18): 全部走 process.cwd() (即 agent 实际工作目录).
+    //   老逻辑写命令走 sandbox 反而出问题 — sandbox 是个独立 git 目录,
+    //   在里面 git add/commit/push 看不到外面的 working tree,
+    //   agent 看到的 status 是 sandbox 自己的, 容易误判.
+    //   现在全部走 cwd. (注: 老逻辑 `getSandboxCwd()` 已废弃, 不再使用)
+    const cwd = process.cwd();
     // 4. 跑命令
+    // M3.5 (2026-06-17): Windows 上 ls/cat/pwd 不在 PATH, 必须用 cmd 内置命令 (dir/type/cd)
+    //   但 cmd 内置命令不能在 shell: false 下跑, 切到 shell: true (Windows shell: cmd.exe, POSIX shell: /bin/sh)
+    //   风险: 元字符注入 — 通过 checkCommand + arg denylist 防护, 加 shellQuoteArgs() 转义
+    const isWindows = process.platform === 'win32';
+    const needsShell = isWindows; // Windows: 必须用 shell 才能跑 cmd 内置
+    const quotedArgs = isWindows ? args.map(shellQuoteArgs) : args;
     return new Promise((resolve) => {
-        const proc = spawn(cmd, args, {
-            cwd: sandboxCwd,
+        const proc = spawn(cmd, quotedArgs, {
+            cwd,
             env: { ...process.env, GIT_TERMINAL_PROMPT: '0' }, // 禁止 git 弹交互
-            shell: false, // **关键**: 禁用 shell, 防止元字符注入
+            shell: needsShell,
             windowsHide: true
         });
         let stdout = '';

package/dist/agents/task-state.js

@@ -0,0 +1,224 @@
+/**
+ * Task State Machine — M3.2 (2026-06-17)
+ *
+ * 长期项目响应的核心: agent 能跟踪一个多步任务的进度, 跨 loop / 跨 session 持久化
+ *
+ * 设计:
+ * - 状态写入 ~/.bolloon/tasks/<task-id>.yaml
+ * - task-id 由 LLM 在 user request 进来时生成 (或由 intent-classifier 自动给)
+ * - 每个 plan 步骤有 status: pending | running | done | failed | skipped
+ * - 写盘后 agent 在每个 loop iter 读 plan, 选下一个 pending step
+ *
+ * 简化版: 不强制 LLM 生成 plan (M3.1 已把 task plan 作为可选项, LLM 走 multi_step intent 时
+ *   主动 plan), 只提供 plan 状态机 + 持久化 + 给 agent 的 API
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import * as crypto from 'crypto';
+const TASK_DIR = path.join(os.homedir(), '.bolloon', 'tasks');
+async function ensureDir() {
+    await fs.mkdir(TASK_DIR, { recursive: true });
+}
+export function generateTaskId() {
+    return `task-${Date.now()}-${crypto.randomBytes(3).toString('hex')}`;
+}
+/**
+ * YAML 简单序列化 (避免拉 js-yaml 进 task 模块)
+ * 只支持 Task schema
+ */
+function serializeTask(t) {
+    const lines = [
+        `id: ${t.id}`,
+        `goal: ${JSON.stringify(t.goal)}`,
+        `createdAt: ${t.createdAt}`,
+        `updatedAt: ${t.updatedAt}`,
+        `status: ${t.status}`,
+        `branch: ${t.branch || ''}`,
+        `sessionKey: ${t.sessionKey || ''}`,
+        `steps:`,
+    ];
+    for (const s of t.steps) {
+        lines.push(`  - id: ${s.id}`);
+        lines.push(`    description: ${JSON.stringify(s.description)}`);
+        lines.push(`    status: ${s.status}`);
+        if (s.startedAt)
+            lines.push(`    startedAt: ${s.startedAt}`);
+        if (s.finishedAt)
+            lines.push(`    finishedAt: ${s.finishedAt}`);
+        if (s.resultSummary)
+            lines.push(`    resultSummary: ${JSON.stringify(s.resultSummary)}`);
+        if (s.error)
+            lines.push(`    error: ${JSON.stringify(s.error)}`);
+    }
+    return lines.join('\n') + '\n';
+}
+function parseTask(content) {
+    try {
+        const lines = content.split('\n');
+        const task = {
+            id: '', goal: '', createdAt: '', updatedAt: '', status: 'planning', steps: [],
+        };
+        let currentStep = null;
+        for (const line of lines) {
+            const trimmed = line.trimEnd();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            if (trimmed.startsWith('- id:')) {
+                if (currentStep)
+                    task.steps.push(currentStep);
+                currentStep = { id: trimmed.slice(6).trim(), description: '', status: 'pending' };
+                continue;
+            }
+            if (currentStep && trimmed.startsWith('description:')) {
+                currentStep.description = JSON.parse(trimmed.slice(12).trim());
+                continue;
+            }
+            if (currentStep && trimmed.startsWith('status:')) {
+                currentStep.status = trimmed.slice(7).trim();
+                continue;
+            }
+            if (currentStep && trimmed.startsWith('startedAt:')) {
+                currentStep.startedAt = trimmed.slice(10).trim();
+                continue;
+            }
+            if (currentStep && trimmed.startsWith('finishedAt:')) {
+                currentStep.finishedAt = trimmed.slice(12).trim();
+                continue;
+            }
+            if (currentStep && trimmed.startsWith('resultSummary:')) {
+                currentStep.resultSummary = JSON.parse(trimmed.slice(15).trim());
+                continue;
+            }
+            if (currentStep && trimmed.startsWith('error:')) {
+                currentStep.error = JSON.parse(trimmed.slice(7).trim());
+                continue;
+            }
+            if (trimmed.startsWith('id:')) {
+                task.id = trimmed.slice(3).trim();
+            }
+            else if (trimmed.startsWith('goal:')) {
+                task.goal = JSON.parse(trimmed.slice(5).trim());
+            }
+            else if (trimmed.startsWith('createdAt:')) {
+                task.createdAt = trimmed.slice(10).trim();
+            }
+            else if (trimmed.startsWith('updatedAt:')) {
+                task.updatedAt = trimmed.slice(10).trim();
+            }
+            else if (trimmed.startsWith('status:')) {
+                task.status = trimmed.slice(7).trim();
+            }
+            else if (trimmed.startsWith('branch:')) {
+                const v = trimmed.slice(7).trim();
+                if (v)
+                    task.branch = v;
+            }
+            else if (trimmed.startsWith('sessionKey:')) {
+                const v = trimmed.slice(11).trim();
+                if (v)
+                    task.sessionKey = v;
+            }
+        }
+        if (currentStep)
+            task.steps.push(currentStep);
+        if (!task.id)
+            return null;
+        return task;
+    }
+    catch {
+        return null;
+    }
+}
+async function taskPath(id) {
+    await ensureDir();
+    return path.join(TASK_DIR, `${id}.yaml`);
+}
+export async function createTask(opts) {
+    const now = new Date().toISOString();
+    const task = {
+        id: generateTaskId(),
+        goal: opts.goal,
+        createdAt: now,
+        updatedAt: now,
+        status: 'running',
+        branch: opts.branch,
+        sessionKey: opts.sessionKey,
+        steps: (opts.steps || []).map((desc, i) => ({
+            id: `step-${i + 1}`,
+            description: desc,
+            status: i === 0 ? 'running' : 'pending',
+            startedAt: i === 0 ? now : undefined,
+        })),
+    };
+    const p = await taskPath(task.id);
+    await fs.writeFile(p, serializeTask(task), 'utf-8');
+    return task;
+}
+export async function getTask(id) {
+    try {
+        const p = await taskPath(id);
+        const content = await fs.readFile(p, 'utf-8');
+        return parseTask(content);
+    }
+    catch {
+        return null;
+    }
+}
+export async function updateTask(id, patch) {
+    const t = await getTask(id);
+    if (!t)
+        return null;
+    Object.assign(t, patch, { updatedAt: new Date().toISOString() });
+    const p = await taskPath(id);
+    await fs.writeFile(p, serializeTask(t), 'utf-8');
+    return t;
+}
+export async function updateStep(taskId, stepId, patch) {
+    const t = await getTask(taskId);
+    if (!t)
+        return null;
+    const step = t.steps.find((s) => s.id === stepId);
+    if (!step)
+        return null;
+    Object.assign(step, patch);
+    // 推进下一步: 当前 step done → 下一个 pending 变 running
+    if (patch.status === 'done' || patch.status === 'failed' || patch.status === 'skipped') {
+        step.finishedAt = step.finishedAt || new Date().toISOString();
+        const nextPending = t.steps.find((s) => s.status === 'pending');
+        if (nextPending && patch.status === 'done') {
+            nextPending.status = 'running';
+            nextPending.startedAt = new Date().toISOString();
+        }
+    }
+    // 检查整 task 是否完成
+    if (t.steps.every((s) => s.status === 'done' || s.status === 'skipped')) {
+        t.status = 'completed';
+    }
+    else if (t.steps.some((s) => s.status === 'failed')) {
+        // 不立即置 failed, 留个机会让 LLM 调整
+    }
+    t.updatedAt = new Date().toISOString();
+    const p = await taskPath(taskId);
+    await fs.writeFile(p, serializeTask(t), 'utf-8');
+    return t;
+}
+export async function listTasks(limit = 20) {
+    try {
+        await ensureDir();
+        const files = await fs.readdir(TASK_DIR);
+        const tasks = [];
+        for (const f of files) {
+            if (!f.endsWith('.yaml'))
+                continue;
+            const content = await fs.readFile(path.join(TASK_DIR, f), 'utf-8');
+            const t = parseTask(content);
+            if (t)
+                tasks.push(t);
+        }
+        return tasks.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)).slice(0, limit);
+    }
+    catch {
+        return [];
+    }
+}

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

@@ -123,10 +123,14 @@ export class WorkflowPivotLoop {
     async execute(input, llm, systemPrompt, streamCallback) {
         this.streamCallback = streamCallback;
         this.state = this.createInitialState();
+        console.log(`[pivot] execute: input chars=${input.length}, systemPrompt chars=${systemPrompt.length}`);
         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 留余量, 简单问题也走完
+        effectiveConfig.maxTokenBudget = Math.max(effectiveConfig.maxTokenBudget, Math.ceil(systemPrompt.length * 1.2));
         this.emit({
             type: 'status',
             content: `🔍 任务复杂度: ${taskProfile.complexity} (预估 ${taskProfile.estimatedSteps} 步)`,
@@ -148,10 +152,13 @@ export class WorkflowPivotLoop {
             // Build context for LLM
             const context = this.buildContext();
             const fullPrompt = `${systemPrompt}\n\n${context}`;
+            console.log(`[pivot] iter=${this.state.iteration} ctx=${context.length} fullPrompt=${fullPrompt.length} budget=${effectiveConfig.maxTokenBudget}`);
             try {
                 // Call LLM
+                const t0 = Date.now();
                 const llmResponse = await llm.chat(context, systemPrompt);
                 const reply = llmResponse.reply.trim();
+                console.log(`[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) });
                 // Estimate token usage
                 this.state.totalTokens += this.estimateTokens(fullPrompt) + this.estimateTokens(reply);
@@ -377,6 +384,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) {

package/dist/bollharness-integration/gate-state-machine.js

@@ -106,6 +106,19 @@ export class GateStateMachine {
     getState() {
         return { ...this.state, artifacts: new Map(this.state.artifacts), conversationHistory: [...this.state.conversationHistory] };
     }
+    restore(state) {
+        this.state = {
+            currentGate: state.currentGate,
+            entrySatisfied: state.entrySatisfied,
+            blockers: [...state.blockers],
+            requiredArtifact: state.requiredArtifact,
+            requiredNextSkill: state.requiredNextSkill,
+            requiredReviewSubstrate: state.requiredReviewSubstrate,
+            valueInjection: state.valueInjection,
+            artifacts: new Map(state.artifacts),
+            conversationHistory: [...state.conversationHistory],
+        };
+    }
     getCurrentGate() {
         return this.state.currentGate;
     }

package/dist/bollharness-integration/integration.js

@@ -11,6 +11,8 @@ import { GateStateMachine } from './gate-state-machine.js';
 import { GuardChecker, runGuards } from './guard-checker.js';
 import { ContextRouter } from './context-router.js';
 import { createSkillAdapter } from './skill-adapter.js';
+import * as fs from 'fs';
+import * as path from 'path';
 /**
  * Main integration class
  */
@@ -29,11 +31,76 @@ export class BollharnessIntegration {
             contextEnabled: config.contextEnabled ?? true,
             skillsEnabled: config.skillsEnabled ?? true,
             gatesEnabled: config.gatesEnabled ?? true,
+            persistencePath: config.persistencePath,
         };
         this.gateMachine = new GateStateMachine();
         this.guardChecker = new GuardChecker();
         this.contextRouter = new ContextRouter();
         this.skillAdapter = createSkillAdapter();
+        if (this.config.persistencePath) {
+            this.loadState();
+        }
+    }
+    saveState() {
+        if (!this.config.persistencePath)
+            return;
+        try {
+            const gateState = this.gateMachine.getState();
+            const data = JSON.stringify({
+                gateState: {
+                    currentGate: gateState.currentGate,
+                    entrySatisfied: gateState.entrySatisfied,
+                    blockers: gateState.blockers,
+                    requiredArtifact: gateState.requiredArtifact,
+                    requiredNextSkill: gateState.requiredNextSkill,
+                    valueInjection: gateState.valueInjection,
+                    artifacts: Array.from(gateState.artifacts.entries()),
+                    conversationHistory: gateState.conversationHistory,
+                },
+                sessionArchives: this.sessionArchives,
+                currentSessionId: this.currentSessionId,
+            }, null, 2);
+            const dir = path.dirname(this.config.persistencePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(this.config.persistencePath, data, 'utf-8');
+        }
+        catch (err) {
+            console.warn(`[BollharnessIntegration] 持久化失败: ${err.message}`);
+        }
+    }
+    loadState() {
+        if (!this.config.persistencePath)
+            return;
+        try {
+            if (!fs.existsSync(this.config.persistencePath))
+                return;
+            const raw = fs.readFileSync(this.config.persistencePath, 'utf-8');
+            const data = JSON.parse(raw);
+            if (data.gateState) {
+                this.gateMachine.restore({
+                    currentGate: data.gateState.currentGate,
+                    entrySatisfied: data.gateState.entrySatisfied,
+                    blockers: data.gateState.blockers,
+                    requiredArtifact: data.gateState.requiredArtifact,
+                    requiredNextSkill: data.gateState.requiredNextSkill,
+                    requiredReviewSubstrate: undefined,
+                    valueInjection: data.gateState.valueInjection || '',
+                    artifacts: new Map(data.gateState.artifacts || []),
+                    conversationHistory: data.gateState.conversationHistory || [],
+                });
+            }
+            if (data.sessionArchives) {
+                this.sessionArchives = data.sessionArchives;
+            }
+            if (data.currentSessionId) {
+                this.currentSessionId = data.currentSessionId;
+            }
+        }
+        catch (err) {
+            console.warn(`[BollharnessIntegration] 状态恢复失败: ${err.message}`);
+        }
     }
     /**
      * Process a file edit with all enabled checks
@@ -128,12 +195,14 @@ export class BollharnessIntegration {
      */
     submitGateArtifact(name, artifact) {
         this.gateMachine.submitArtifact(name, artifact);
+        this.saveState();
     }
     /**
      * Attempt gate transition
      */
     async transitionGate(reviewResult) {
         const transition = await this.gateMachine.transition(reviewResult);
+        this.saveState();
         return {
             success: transition.blockers.length === 0,
             transition,
@@ -246,6 +315,7 @@ export class BollharnessIntegration {
         };
         this.sessionArchives.push(archive);
         this.currentSessionId = id;
+        this.saveState();
         return archive;
     }
     /**
@@ -333,6 +403,7 @@ export class BollharnessIntegration {
      */
     startNewSession() {
         this.currentSessionId = `session_${Date.now()}`;
+        this.saveState();
         return this.currentSessionId;
     }
     /**