@bolloon/bolloon-agent 0.2.12 → 0.2.13

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;
     }
     /**

package/dist/bollharness-integration/llm-judgment-engine.js

@@ -19,101 +19,101 @@ import { getPiSDKConfig } from '../llm/config-store.js';
 /**
  * 判断用的 Prompt 模板（可以从 YAML 加载）
  */
-export const JUDGMENT_PROMPT_TEMPLATE = `你是一个专业的 AI 任务分析专家。你的职责是深入理解用户的问题，并给出精准的判断。
-
-【输入】
-{user_input}
-
-【历史上下文】
-{history_context}
-
-请分析以上输入，回答以下问题：
-
-## 1. 问题理解
-
-**问题本质**：用户真正想要什么？这是什么类型的问题？
-- how-to: 寻求操作指导
-- why: 寻求解释
-- what: 寻求定义
-- should: 寻求建议
-- feasibility: 寻求可行性评估
-
-**核心需求**：用户最想要的结果是什么？
-
-**隐含信息**：有什么用户没有明确说但需要考虑的因素？
-- 时间压力？
-- 质量要求？
-- 风险限制？
-- 团队协作？
-
-## 2. 复杂性评估
-
-**复杂性等级**：这个问题有多复杂？
-- simple: 简单任务，直接可答
-- moderate: 中等复杂，需要一定思考
-- complex: 复杂问题，需要深入分析
-- profound: 深刻问题，需要本质性思考
-
-**评估理由**：为什么认为这是这个复杂性等级？
-
-**深度**：需要多深的理解？
-- surface: 表面理解即可
-- deeper: 需要分析
-- fundamental: 需要本质性思考
-
-## 3. 处理决策
-
-**推荐方式**：
-- answer: 直接回答
-- analyze: 深入分析
-- design: 设计方案
-- implement: 实现代码
-- coordinate: 协调多智能体
-
-**决策理由**：为什么推荐这个处理方式？
-
-## 4. 路由决策
-
-**应该调用的 Skills**（可选多个）：
-- arch: 架构设计
-- harness-dev: 开发实现
-- guardian-fixer: 代码审查
-- harness-eng: 工程协调
-- harness-eng-test: 测试工程
-- task-arch: 任务分解
-- crystal-learn: 反思学习
-
-**参与智能体**（可选）：
-- architect: 架构师
-- developer: 开发者
-- reviewer: 审查员
-- coordinator: 协调者
-
-**协作模式**：
-- solo: 单独处理
-- pair: 配对协作
-- team: 团队协作
-
-## 5. 产出要求
-
-**需要的产物**：
-- 问题分析
-- 方案设计
-- 代码实现
-- 测试用例
-- 其他
-
-**Gate 建议**（如果有）：
-- Gate 0: 问题锁定
-- Gate 1: 架构设计
-- Gate 2: 架构审查
-- Gate 3: 计划制定
-- Gate 4: 计划审查
-- Gate 5: 任务分解
-- Gate 6: 任务审查
-- Gate 7: 代码实现
-- Gate 8: 测试验证
-
+export const JUDGMENT_PROMPT_TEMPLATE = `你是一个专业的 AI 任务分析专家。你的职责是深入理解用户的问题，并给出精准的判断。
+
+【输入】
+{user_input}
+
+【历史上下文】
+{history_context}
+
+请分析以上输入，回答以下问题：
+
+## 1. 问题理解
+
+**问题本质**：用户真正想要什么？这是什么类型的问题？
+- how-to: 寻求操作指导
+- why: 寻求解释
+- what: 寻求定义
+- should: 寻求建议
+- feasibility: 寻求可行性评估
+
+**核心需求**：用户最想要的结果是什么？
+
+**隐含信息**：有什么用户没有明确说但需要考虑的因素？
+- 时间压力？
+- 质量要求？
+- 风险限制？
+- 团队协作？
+
+## 2. 复杂性评估
+
+**复杂性等级**：这个问题有多复杂？
+- simple: 简单任务，直接可答
+- moderate: 中等复杂，需要一定思考
+- complex: 复杂问题，需要深入分析
+- profound: 深刻问题，需要本质性思考
+
+**评估理由**：为什么认为这是这个复杂性等级？
+
+**深度**：需要多深的理解？
+- surface: 表面理解即可
+- deeper: 需要分析
+- fundamental: 需要本质性思考
+
+## 3. 处理决策
+
+**推荐方式**：
+- answer: 直接回答
+- analyze: 深入分析
+- design: 设计方案
+- implement: 实现代码
+- coordinate: 协调多智能体
+
+**决策理由**：为什么推荐这个处理方式？
+
+## 4. 路由决策
+
+**应该调用的 Skills**（可选多个）：
+- arch: 架构设计
+- harness-dev: 开发实现
+- guardian-fixer: 代码审查
+- harness-eng: 工程协调
+- harness-eng-test: 测试工程
+- task-arch: 任务分解
+- crystal-learn: 反思学习
+
+**参与智能体**（可选）：
+- architect: 架构师
+- developer: 开发者
+- reviewer: 审查员
+- coordinator: 协调者
+
+**协作模式**：
+- solo: 单独处理
+- pair: 配对协作
+- team: 团队协作
+
+## 5. 产出要求
+
+**需要的产物**：
+- 问题分析
+- 方案设计
+- 代码实现
+- 测试用例
+- 其他
+
+**Gate 建议**（如果有）：
+- Gate 0: 问题锁定
+- Gate 1: 架构设计
+- Gate 2: 架构审查
+- Gate 3: 计划制定
+- Gate 4: 计划审查
+- Gate 5: 任务分解
+- Gate 6: 任务审查
+- Gate 7: 代码实现
+- Gate 8: 测试验证
+
 请用 JSON 格式输出分析结果。`;
 /**
  * LLM-native Judgment Engine
@@ -434,20 +434,20 @@ export const SKILL_PROMPTS = {
     arch: {
         name: 'arch',
         description: '架构设计专家',
-        systemPrompt: `你是一个经验丰富的系统架构师。你擅长：
-- 从需求中提取本质问题
-- 设计可扩展的系统架构
-- 权衡技术方案
-- 识别架构风险
-
-你相信：
-- 本质和实现必须分离
-- 好的架构从简单规则中生长
+        systemPrompt: `你是一个经验丰富的系统架构师。你擅长：
+- 从需求中提取本质问题
+- 设计可扩展的系统架构
+- 权衡技术方案
+- 识别架构风险
+
+你相信：
+- 本质和实现必须分离
+- 好的架构从简单规则中生长
 - 复杂性应该被控制而非消除`,
-        userPromptTemplate: `用户需求：{user_input}
-
-{context}
-
+        userPromptTemplate: `用户需求：{user_input}
+
+{context}
+
 请进行架构分析：`,
         examples: [
             {
@@ -460,40 +460,40 @@ export const SKILL_PROMPTS = {
     'harness-dev': {
         name: 'harness-dev',
         description: '开发实现专家',
-        systemPrompt: `你是一个高效的代码实现专家。你擅长：
-- 快速理解和实现需求
-- 编写清晰、可维护的代码
-- 遵循最佳实践
-- 处理边界情况
-
-你相信：
-- 代码即文档
-- 测试是代码的一部分
+        systemPrompt: `你是一个高效的代码实现专家。你擅长：
+- 快速理解和实现需求
+- 编写清晰、可维护的代码
+- 遵循最佳实践
+- 处理边界情况
+
+你相信：
+- 代码即文档
+- 测试是代码的一部分
 - 简单优于复杂`,
-        userPromptTemplate: `任务：{user_input}
-
-技术栈：{tech_stack}
-
+        userPromptTemplate: `任务：{user_input}
+
+技术栈：{tech_stack}
+
 请实现代码：`,
         outputFormat: 'code'
     },
     'guardian-fixer': {
         name: 'guardian-fixer',
         description: '代码审查专家',
-        systemPrompt: `你是一个严格的代码审查专家。你擅长：
-- 发现潜在问题
-- 提出改进建议
-- 确保代码质量
-- 平衡效率和安全性
-
-你相信：
-- 细节决定成败
-- 代码审查是质量保障的最后防线
+        systemPrompt: `你是一个严格的代码审查专家。你擅长：
+- 发现潜在问题
+- 提出改进建议
+- 确保代码质量
+- 平衡效率和安全性
+
+你相信：
+- 细节决定成败
+- 代码审查是质量保障的最后防线
 - 建设性批评比否定更有价值`,
-        userPromptTemplate: `代码：\n{code}
-
-审查范围：{scope}
-
+        userPromptTemplate: `代码：\n{code}
+
+审查范围：{scope}
+
 请进行审查：`,
         outputFormat: 'structured'
     }

package/dist/bollharness-integration/skill-adapter.js

@@ -88,6 +88,10 @@ function loadAllHarnessSkills() {
  * Base skill class for bollharness-compatible skills
  */
 export class BaseSkill {
+    static llm = null;
+    static setLlm(instance) {
+        BaseSkill.llm = instance;
+    }
     log(message, level = 'info') {
         const prefix = level === 'error' ? '❌' : level === 'warn' ? '⚠️' : 'ℹ️';
         console.log(`${prefix} [${this.name}] ${message}`);
@@ -95,6 +99,33 @@ export class BaseSkill {
     formatOutput(output) {
         return JSON.stringify(output, null, 2);
     }
+    async callLm(system, user) {
+        let llm = BaseSkill.llm;
+        if (!llm) {
+            try {
+                const { getMinimax } = await import('../llm/pi-ai.js');
+                const m = getMinimax();
+                if (m && typeof m.chat === 'function') {
+                    BaseSkill.setLlm(m);
+                    llm = m;
+                }
+            }
+            catch {
+                return this.formatOutput({ warning: 'LLM 未注入', name: this.name });
+            }
+        }
+        if (!llm) {
+            return this.formatOutput({ warning: 'LLM 未注入', name: this.name });
+        }
+        try {
+            const res = await llm.chat([{ role: 'user', content: user }], system);
+            return res.reply || '(空回复)';
+        }
+        catch (err) {
+            this.log(`LLM 调用失败: ${err.message}`, 'error');
+            return this.formatOutput({ error: `LLM 调用失败: ${err.message}` });
+        }
+    }
 }
 /**
  * Architecture Skill - Project architect for architecture decisions
@@ -103,58 +134,12 @@ export class ArchSkill extends BaseSkill {
     name = 'arch';
     description = 'Project architect. Responsible for architecture decisions, scheme comparison, and boundary freezing.';
     async execute(params) {
-        const task = params.task || params.description;
+        const task = (params.task || params.description || params.action || '');
         this.log('Analyzing architecture task');
-        // Extract essence
-        const essence = this.extractEssence(task);
-        // Find tensions
-        const tensions = this.identifyTensions(task);
-        // Compare alternatives
-        const alternatives = this.compareAlternatives(task);
-        // Identify boundaries to freeze
-        const boundaries = this.identifyBoundaries(task);
-        return this.formatOutput({
-            essence,
-            tensions,
-            alternatives,
-            boundaries,
-            recommendation: this.makeRecommendation(task, alternatives),
-        });
-    }
-    extractEssence(task) {
-        // Simplified essence extraction
-        return `The core challenge is: ${task}`;
-    }
-    identifyTensions(task) {
-        return [
-            'Simplicity vs Flexibility',
-            'Performance vs Maintainability',
-            'Coupling vs Cohesion',
-        ];
-    }
-    compareAlternatives(task) {
-        return [
-            {
-                name: 'Option A: Direct Implementation',
-                tradeoffs: ['Fast to implement', 'May not scale'],
-                recommendation: 'Suitable for MVP',
-            },
-            {
-                name: 'Option B: Abstraction Layer',
-                tradeoffs: ['More upfront work', 'Better for extension'],
-                recommendation: 'Suitable for long-term',
-            },
-        ];
-    }
-    identifyBoundaries(task) {
-        return [
-            'API contract boundaries',
-            'Data format boundaries',
-            'Capability boundaries',
-        ];
-    }
-    makeRecommendation(task, alternatives) {
-        return alternatives[1]?.recommendation || 'Consider abstraction layer for long-term maintainability';
+        if (!task) {
+            return this.formatOutput({ warning: '未提供任务', usage: '--harness-skill arch "你的架构任务"' });
+        }
+        return this.callLm('You are a senior software architect. Analyze the task and output structured JSON with fields: essence, tensions, alternatives, boundaries, recommendation.', `Architecture task: ${task}`);
     }
 }
 /**
@@ -221,18 +206,9 @@ export class LeadSkill extends BaseSkill {
             gate_pack: this.getGatePack(),
         });
     }
-    classifyChange(params) {
+    async classifyChange(params) {
         const description = params.description || '';
-        // Simplified classification
-        const isPolicy = description.includes('policy') || description.includes('boundary');
-        const isContract = description.includes('API') || description.includes('contract') || description.includes('schema');
-        const isImplementation = !isPolicy && !isContract;
-        return this.formatOutput({
-            classification: isPolicy ? 'policy' : isContract ? 'contract' : 'implementation',
-            description,
-            minimum_gate_path: isPolicy ? '0→8 (full)' : isContract ? '0→8 (full + consumers)' : '0→7 (fast track eligible)',
-            fast_track_eligible: isImplementation,
-        });
+        return this.callLm('You are a change classifier. Given a description, classify the change as policy, contract, or implementation. Output JSON: { classification, description, minimum_gate_path, fast_track_eligible }.', `Classify this change: ${description}`);
     }
 }
 /**
@@ -242,44 +218,12 @@ export class TaskArchSkill extends BaseSkill {
     name = 'task-arch';
     description = 'Task decomposition. Breaks down PLAN into parallelizable work packages (WP).';
     async execute(params) {
-        const plan = params.plan;
+        const plan = (params.plan || params.task || params.description || params.action || '');
         this.log('Decomposing plan into work packages');
-        // Extract work packages
-        const workPackages = this.extractWorkPackages(plan);
-        // Identify seams
-        const seams = this.identifySeams(workPackages);
-        // Identify integration points
-        const integration = this.identifyIntegration(workPackages);
-        return this.formatOutput({
-            work_packages: workPackages,
-            seams,
-            integration,
-            seam_owners: this.assignSeamOwners(seams),
-        });
-    }
-    extractWorkPackages(plan) {
-        // Simplified WP extraction
-        return [
-            { id: 'WP-1', description: 'Core implementation', files: ['src/agents/*.ts'] },
-            { id: 'WP-2', description: 'Network layer', files: ['src/network/*.ts'] },
-            { id: 'WP-3', description: 'Testing', files: ['src/test/*.ts'] },
-        ];
-    }
-    identifySeams(packages) {
-        return [
-            { from: 'WP-1', to: 'WP-2', interface: 'P2PNetwork interface' },
-            { from: 'WP-1', to: 'WP-3', interface: 'Test fixtures' },
-        ];
-    }
-    identifyIntegration(packages) {
-        return ['Integration test at WP-1/WP-2 boundary'];
-    }
-    assignSeamOwners(seams) {
-        const owners = {};
-        for (const seam of seams) {
-            owners[`${seam.from}/${seam.to}`] = 'integration-owner';
+        if (!plan) {
+            return this.formatOutput({ warning: '未提供 plan', usage: '--harness-skill task-arch "你的开发计划"' });
         }
-        return owners;
+        return this.callLm('You are a task decomposition specialist. Given a plan, break it down into work packages (WP) with seams and integration points. Output JSON: { work_packages, seams, integration }.', `Plan: ${plan}`);
     }
 }
 /**
@@ -398,35 +342,12 @@ export class CrystalLearnSkill extends BaseSkill {
     name = 'crystal-learn';
     description = 'Extracts failure patterns and maintains invariants.';
     async execute(params) {
-        const task = params.task;
-        this.log('Extracting failure patterns');
-        // Identify failure modes
-        const failures = this.identifyFailures(task);
-        // Extract patterns
-        const patterns = this.extractPatterns(failures);
-        // Generate invariants
-        const invariants = this.generateInvariants(patterns);
-        return this.formatOutput({
-            failure_modes: failures,
-            patterns,
-            invariants,
-        });
-    }
-    identifyFailures(task) {
-        return [
-            'Truth source split',
-            'Verification decay',
-            'Orphaned seams',
-        ];
-    }
-    extractPatterns(failures) {
-        return failures.map(f => ({
-            pattern: f,
-            prevention: `Implement guard to prevent ${f}`,
-        }));
-    }
-    generateInvariants(patterns) {
-        return patterns.map(p => `INV: ${p.pattern} must not occur`);
+        const task = (params.task || params.description || params.action || '');
+        this.log('Extracting failure patterns from: ' + (task || '(空)'));
+        if (!task) {
+            return this.formatOutput({ warning: '未提供任务', usage: '--harness-skill crystal-learn "你的任务描述"' });
+        }
+        return this.callLm('You are a failure pattern analyst. Extract failure modes, patterns, and invariants from the task description. Output structured JSON with failure_modes, patterns, invariants.', `Task: ${task}`);
     }
 }
 /**
@@ -482,6 +403,10 @@ export class SkillAdapter {
     getSkill(name) {
         return this.registry.get(name);
     }
+    injectLlm(llm) {
+        BaseSkill.setLlm(llm);
+        this.log('LLM 已注入到所有 BaseSkill');
+    }
     listSkills() {
         return this.registry.list();
     }
@@ -492,6 +417,11 @@ export class SkillAdapter {
         return this.registry.execute(name, params);
     }
     log(message, level = 'info') {
+        // 2026-07-06: info 默认静音 — 14 条 [SkillAdapter] Loaded/Registered 日志刷屏 web.log
+        //   调试时设 BOLLOON_VERBOSE=1 临时开起来. warn/error 仍正常打.
+        const VERBOSE = typeof process !== 'undefined' && process.env?.BOLLOON_VERBOSE === '1';
+        if (level === 'info' && !VERBOSE)
+            return;
         const prefix = level === 'error' ? '❌' : level === 'warn' ? '⚠️' : 'ℹ️';
         console.log(`${prefix} [SkillAdapter] ${message}`);
     }