@bolloon/bolloon-agent 0.2.9 → 0.2.11

package/dist/bollharness-integration/integration.js

@@ -11,8 +11,6 @@ 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
  */
@@ -31,76 +29,11 @@ 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
@@ -195,14 +128,12 @@ 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,
@@ -315,7 +246,6 @@ export class BollharnessIntegration {
         };
         this.sessionArchives.push(archive);
         this.currentSessionId = id;
-        this.saveState();
         return archive;
     }
     /**
@@ -403,7 +333,6 @@ 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,10 +88,6 @@ 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}`);
@@ -99,33 +95,6 @@ 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
@@ -134,12 +103,58 @@ 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 || params.action || '');
+        const task = params.task || params.description;
         this.log('Analyzing architecture task');
-        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}`);
+        // 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';
     }
 }
 /**
@@ -206,9 +221,18 @@ export class LeadSkill extends BaseSkill {
             gate_pack: this.getGatePack(),
         });
     }
-    async classifyChange(params) {
+    classifyChange(params) {
         const description = params.description || '';
-        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}`);
+        // 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,
+        });
     }
 }
 /**
@@ -218,12 +242,44 @@ 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 || params.task || params.description || params.action || '');
+        const plan = params.plan;
         this.log('Decomposing plan into work packages');
-        if (!plan) {
-            return this.formatOutput({ warning: '未提供 plan', usage: '--harness-skill task-arch "你的开发计划"' });
+        // 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';
         }
-        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}`);
+        return owners;
     }
 }
 /**
@@ -342,12 +398,35 @@ export class CrystalLearnSkill extends BaseSkill {
     name = 'crystal-learn';
     description = 'Extracts failure patterns and maintains invariants.';
     async execute(params) {
-        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}`);
+        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`);
     }
 }
 /**
@@ -403,10 +482,6 @@ export class SkillAdapter {
     getSkill(name) {
         return this.registry.get(name);
     }
-    injectLlm(llm) {
-        BaseSkill.setLlm(llm);
-        this.log('LLM 已注入到所有 BaseSkill');
-    }
     listSkills() {
         return this.registry.list();
     }

package/dist/bootstrap/context-collector.js

@@ -136,13 +136,10 @@ async function collectJudgmentsSummary(topN) {
         topValues,
     };
 }
-async function collectSkills(projectCwd) {
+async function collectSkills() {
     const home = process.env.HOME || os.homedir() || '/tmp';
     const userSkillsDir = path.join(home, '.bolloon', 'skills');
-    // 2026-07-04: 用 opts.cwd 而不是 process.cwd(), 让 collectBolloonContext({cwd})
-    //   在测试或子进程里能正确隔离项目级 skill 目录 (之前 process.cwd() 会读到
-    //   caller 的 cwd, 测试空目录时泄漏真实项目 skills).
-    const projectSkillsDir = path.join(projectCwd || process.cwd(), '.bolloon', 'skills');
+    const projectSkillsDir = path.join(process.cwd(), '.bolloon', 'skills');
     const out = [];
     const seen = new Set();
     for (const dir of [userSkillsDir, projectSkillsDir]) {
@@ -276,7 +273,7 @@ export async function collectBolloonContext(opts) {
         collectProject(cwd, bolloonMdMaxBytes),
         collectGit(cwd, gitCommitLimit),
         collectPersona(),
-        collectSkills(cwd),
+        collectSkills(),
         Promise.resolve(collectEnv()),
         collectPending(opts),
         collectHierarchy(cwd),