@bolloon/bolloon-agent 0.2.9 → 0.2.10

package/dist/social/ant-colony/PheromoneEngine.js

@@ -0,0 +1,227 @@
+/**
+ * PheromoneEngine - 信息素管理引擎
+ *
+ * 模拟蚂蚁的信息素系统，用于引导智能体发现和路由决策
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { PheromoneType, DEFAULT_PHEROMONE_CONFIG, } from './types.js';
+export { PheromoneType };
+const PHEROMONE_DB_PATH = path.join(process.env.HOME || '/tmp', '.bolloon', 'ant-colony', 'pheromones.json');
+export class PheromoneEngine {
+    trails = new Map();
+    fields = new Map();
+    evaporationTimer = null;
+    saveTimer = null;
+    dirty = false;
+    async initialize() {
+        await fs.mkdir(path.dirname(PHEROMONE_DB_PATH), { recursive: true });
+        await this.load();
+        this.startEvaporation();
+        this.startAutoSave();
+    }
+    startEvaporation() {
+        this.evaporationTimer = setInterval(() => {
+            this.evaporate();
+        }, DEFAULT_PHEROMONE_CONFIG.evaporationInterval);
+    }
+    startAutoSave() {
+        this.saveTimer = setInterval(() => {
+            if (this.dirty) {
+                this.save().catch(console.error);
+                this.dirty = false;
+            }
+        }, 30000);
+    }
+    /**
+     * 放置信息素
+     */
+    async deposit(type, sourceDid, targetDid, strength = 0.5, options) {
+        const key = this.getTrailKey(type, sourceDid, targetDid);
+        const existing = this.trails.get(key);
+        const newStrength = existing
+            ? Math.min(1, existing.strength + strength * 0.3)
+            : Math.min(1, strength);
+        const trail = {
+            id: key,
+            type,
+            sourceDid,
+            targetDid,
+            strength: newStrength,
+            decayRate: DEFAULT_PHEROMONE_CONFIG.decayRate,
+            createdAt: existing?.createdAt || Date.now(),
+            lastUpdate: Date.now(),
+            capability: options?.capability,
+            qualityScore: options?.qualityScore,
+        };
+        this.trails.set(key, trail);
+        this.dirty = true;
+        if (options?.capability) {
+            this.updateField(type, targetDid, options.capability);
+        }
+    }
+    /**
+     * 读取某方向的信息素强度
+     */
+    getStrength(type, targetDid) {
+        let totalStrength = 0;
+        let count = 0;
+        for (const trail of this.trails.values()) {
+            if (trail.type === type && trail.targetDid === targetDid) {
+                totalStrength += trail.strength;
+                count++;
+            }
+        }
+        return count > 0 ? totalStrength / count : 0;
+    }
+    /**
+     * 查询特定能力的最佳节点
+     */
+    queryByCapability(capability, limit = 5) {
+        const field = this.fields.get(capability);
+        if (!field)
+            return [];
+        const candidates = [];
+        for (const trail of this.trails.values()) {
+            if (trail.type === PheromoneType.CAPABILITY &&
+                trail.capability?.includes(capability)) {
+                const score = trail.strength * (trail.qualityScore || 0.5);
+                candidates.push({ did: trail.targetDid, strength: score });
+            }
+        }
+        candidates.sort((a, b) => b.strength - a.strength);
+        return candidates.slice(0, limit).map((c) => c.did);
+    }
+    /**
+     * 获取到达某节点的最佳下一跳
+     */
+    getNextHop(targetDid, excludeDids = []) {
+        let bestHop = null;
+        let bestStrength = 0;
+        for (const trail of this.trails.values()) {
+            if (trail.targetDid === targetDid && trail.strength > bestStrength) {
+                if (!excludeDids.includes(trail.sourceDid)) {
+                    bestHop = trail.sourceDid;
+                    bestStrength = trail.strength;
+                }
+            }
+        }
+        return bestHop;
+    }
+    /**
+     * 获取所有已知节点及其信息素强度
+     */
+    getAllNodeStrengths() {
+        const result = new Map();
+        for (const trail of this.trails.values()) {
+            const current = result.get(trail.targetDid) || 0;
+            result.set(trail.targetDid, Math.max(current, trail.strength));
+        }
+        return result;
+    }
+    /**
+     * 获取信息素统计
+     */
+    getStats() {
+        let totalStrength = 0;
+        for (const trail of this.trails.values()) {
+            totalStrength += trail.strength;
+        }
+        return {
+            totalTrails: this.trails.size,
+            avgStrength: this.trails.size > 0 ? totalStrength / this.trails.size : 0,
+            capabilityCount: this.fields.size,
+        };
+    }
+    getTrailKey(type, source, target) {
+        return `${type}:${source}:${target}`;
+    }
+    updateField(type, targetDid, capability) {
+        if (!capability)
+            return;
+        for (const cap of capability) {
+            let field = this.fields.get(cap);
+            if (!field) {
+                field = {
+                    capability: cap,
+                    avgStrength: 0,
+                    nodeCount: 0,
+                    lastUpdate: Date.now(),
+                };
+                this.fields.set(cap, field);
+            }
+            const trails = Array.from(this.trails.values()).filter((t) => t.type === type && t.capability?.includes(cap));
+            field.avgStrength =
+                trails.reduce((sum, t) => sum + t.strength, 0) / (trails.length || 1);
+            field.nodeCount = new Set(trails.map((t) => t.targetDid)).size;
+            field.lastUpdate = Date.now();
+        }
+    }
+    evaporate() {
+        const now = Date.now();
+        const toDelete = [];
+        for (const [key, trail] of this.trails.entries()) {
+            const ageHours = (now - trail.lastUpdate) / (1000 * 60 * 60);
+            const decayFactor = Math.pow(1 - trail.decayRate, ageHours);
+            trail.strength = trail.strength * decayFactor;
+            if (trail.strength < DEFAULT_PHEROMONE_CONFIG.minStrength ||
+                now - trail.createdAt > DEFAULT_PHEROMONE_CONFIG.maxTrailAge) {
+                toDelete.push(key);
+            }
+            else {
+                trail.lastUpdate = now;
+            }
+        }
+        for (const key of toDelete) {
+            this.trails.delete(key);
+        }
+        if (toDelete.length > 0) {
+            this.dirty = true;
+            this.save().catch(console.error);
+        }
+    }
+    async save() {
+        try {
+            const data = {
+                trails: Array.from(this.trails.values()),
+                fields: Array.from(this.fields.entries()),
+            };
+            await fs.writeFile(PHEROMONE_DB_PATH, JSON.stringify(data, null, 2));
+        }
+        catch (e) {
+            console.warn('[PheromoneEngine] Save failed:', e);
+        }
+    }
+    async load() {
+        try {
+            const data = await fs.readFile(PHEROMONE_DB_PATH, 'utf-8');
+            const parsed = JSON.parse(data);
+            this.trails.clear();
+            for (const t of parsed.trails || []) {
+                this.trails.set(t.id, t);
+            }
+            this.fields.clear();
+            for (const [cap, field] of parsed.fields || []) {
+                this.fields.set(cap, field);
+            }
+            console.log(`[PheromoneEngine] Loaded ${this.trails.size} trails, ${this.fields.size} fields`);
+        }
+        catch {
+            console.log('[PheromoneEngine] No existing pheromone data, starting fresh');
+        }
+    }
+    shutdown() {
+        if (this.evaporationTimer) {
+            clearInterval(this.evaporationTimer);
+        }
+        if (this.saveTimer) {
+            clearInterval(this.saveTimer);
+        }
+        if (this.dirty) {
+            this.save()
+                .then(() => console.log('[PheromoneEngine] Saved on shutdown'))
+                .catch(console.error);
+        }
+    }
+}
+export const pheromoneEngine = new PheromoneEngine();

package/dist/social/ant-colony/index.js

@@ -0,0 +1,6 @@
+/**
+ * Ant Colony Module - 蚁群心跳系统核心模块
+ */
+export { PheromoneType, DEFAULT_PHEROMONE_CONFIG, DEFAULT_ADAPTIVE_CONFIG, } from './types.js';
+export { PheromoneEngine, pheromoneEngine } from './PheromoneEngine.js';
+export { AdaptiveHeartbeat } from './AdaptiveHeartbeat.js';

package/dist/social/ant-colony/types.js

@@ -0,0 +1,24 @@
+/**
+ * Ant Colony Types - 信息素系统类型定义
+ */
+export var PheromoneType;
+(function (PheromoneType) {
+    PheromoneType["DISCOVERY"] = "discovery";
+    PheromoneType["CAPABILITY"] = "capability";
+})(PheromoneType || (PheromoneType = {}));
+export const DEFAULT_PHEROMONE_CONFIG = {
+    decayRate: 0.05,
+    evaporationInterval: 5 * 60 * 1000,
+    maxTrailAge: 24 * 60 * 60 * 1000,
+    minStrength: 0.05,
+    maxStrength: 1.0,
+};
+export const DEFAULT_ADAPTIVE_CONFIG = {
+    minInterval: 10 * 1000,
+    maxInterval: 120 * 1000,
+    baseInterval: 30 * 1000,
+    lowActivityThreshold: 0.5,
+    highActivityThreshold: 5,
+    pheromoneBoostFactor: 0.3,
+    discoveryBoostFactor: 0.4,
+};

package/dist/test/ai-judgment-test.js

@@ -0,0 +1,80 @@
+/**
+ * AI + 判断力注入 测试
+ * 验证 AI 调用和价值观注入功能
+ */
+import { createAgentSession } from '../agents/pi-sdk.js';
+import { generateValueInjection } from '../pi-ecosystem-judgment/value-injection.js';
+import { storeHumanJudgment, initializeValueStore, getValueStats } from '../pi-ecosystem-judgment/human-value-store.js';
+async function main() {
+    console.log('╔═══════════════════════════════════════════════════╗');
+    console.log('║     AI + 判断力注入测试                       ║');
+    console.log('╚═══════════════════════════════════════════════════╝');
+    // 1. 初始化
+    console.log('\n[1] 初始化...');
+    await initializeValueStore();
+    console.log('  ✅ 判断力存储就绪');
+    // 2. 存储一些测试判断
+    console.log('\n[2] 存储测试判断...');
+    await storeHumanJudgment({
+        decision: '代码安全性比性能更重要',
+        decision_type: 'approve',
+        reasons: ['防止被攻击', '用户数据保护'],
+        values_derived: [
+            { category: 'safety', value: 'security-first', weight: 0.9 }
+        ],
+        context: {
+            domain: 'code',
+            complexity: 'moderate',
+            stakes: 'high',
+            time_pressure: 'low'
+        },
+        outcome: { approved: true },
+        metadata: {
+            source: 'explicit',
+            confidence: 0.85,
+            revisable: true
+        }
+    });
+    console.log('  ✅ 判断已存储');
+    // 3. 查看统计
+    console.log('\n[3] 判断力统计...');
+    const stats = await getValueStats();
+    console.log(`  总判断数: ${stats.total_judgments}`);
+    console.log(`  顶级价值观: ${stats.top_values.slice(0, 3).map(v => v.value).join(', ')}`);
+    // 4. 生成价值观注入
+    console.log('\n[4] 生成价值观注入...');
+    const injection = await generateValueInjection('代码安全问题', {
+        mode: 'standard',
+        maxTokens: 400,
+        includeExamples: true,
+        includeRules: true
+    });
+    console.log(`  注入内容长度: ${injection.length} 字符`);
+    if (injection) {
+        console.log('  ✅ 价值观注入已生成');
+    }
+    // 5. 调用 AI
+    console.log('\n[5] 调用 AI...');
+    const session = await createAgentSession({ cwd: process.cwd() });
+    const prompt = injection
+        ? `${injection}
+
+---
+【当前问题】
+用户问：如何确保 API 接口的安全性？
+
+请基于上面的价值观回复用户。`
+        : '用户问：如何确保 API 接口的安全性？请给出建议。';
+    console.log('\n[6] 发送请求到 AI...');
+    const response = await session.prompt(prompt);
+    console.log('\n═══════════════════════════════════════════════════════');
+    console.log('  AI 回复:');
+    console.log('═══════════════════════════════════════════════════════');
+    console.log(response);
+    console.log('═══════════════════════════════════════════════════════\n');
+    console.log('✅ 测试完成！');
+}
+main().catch(e => {
+    console.error('❌ 测试失败:', e);
+    process.exit(1);
+});

package/dist/test/bollharness-integration.test.js

@@ -0,0 +1,318 @@
+/**
+ * Bollharness Integration Tests - Standalone Component Tests
+ *
+ * These tests verify the core bollharness integration components
+ * without requiring full constraint-runtime dependency chain.
+ */
+import { describe, it, expect } from 'vitest';
+const GATE_CONFIGS = {
+    0: { entryCondition: '用户提出需求', requiredArtifact: '问题陈述', requiredNextSkill: 'arch', isReviewGate: false },
+    1: { entryCondition: 'Gate 0 产物存在', requiredArtifact: 'ADR草稿', requiredNextSkill: 'arch', isReviewGate: false },
+    2: { entryCondition: 'ADR草稿完成', requiredArtifact: '审查报告', requiredNextSkill: 'review', requiredReviewSubstrate: 'ref-review-sop.md', isReviewGate: true },
+    3: { entryCondition: 'Gate 2 PASS', requiredArtifact: 'PLAN文档', requiredNextSkill: 'harness-eng', isReviewGate: false },
+    4: { entryCondition: 'PLAN vN-final冻结', requiredArtifact: '审查报告', requiredNextSkill: 'review', requiredReviewSubstrate: 'ref-review-sop.md', isReviewGate: true },
+    5: { entryCondition: 'Gate 4 PASS', requiredArtifact: 'WP拆分+TASK.md', requiredNextSkill: 'task-arch', isReviewGate: false },
+    6: { entryCondition: '全部TASK.md完成', requiredArtifact: '审查报告', requiredNextSkill: 'review', requiredReviewSubstrate: 'ref-review-sop.md', isReviewGate: true },
+    7: { entryCondition: 'Gate 6 PASS', requiredArtifact: '代码+LOG.md', requiredNextSkill: 'harness-eng', isReviewGate: false },
+    8: { entryCondition: '全部WP代码+LOG.md存在', requiredArtifact: '审查报告', requiredNextSkill: 'harness-eng-test', requiredReviewSubstrate: 'ref-review-sop.md', isReviewGate: true },
+};
+describe('GateStateMachine', () => {
+    let currentGate = 0;
+    let artifacts = new Map();
+    describe('initialization', () => {
+        it('should start at gate 0', () => {
+            currentGate = 0;
+            expect(currentGate).toBe(0);
+        });
+        it('should have correct gate 0 config', () => {
+            const config = GATE_CONFIGS[0];
+            expect(config.requiredArtifact).toBeDefined();
+            expect(config.isReviewGate).toBe(false);
+        });
+    });
+    describe('gate configs', () => {
+        it('should have 9 gates defined', () => {
+            expect(Object.keys(GATE_CONFIGS).length).toBe(9);
+        });
+        it('should have 4 review gates (2,4,6,8)', () => {
+            expect(GATE_CONFIGS[2].isReviewGate).toBe(true);
+            expect(GATE_CONFIGS[4].isReviewGate).toBe(true);
+            expect(GATE_CONFIGS[6].isReviewGate).toBe(true);
+            expect(GATE_CONFIGS[8].isReviewGate).toBe(true);
+        });
+        it('should have correct next skill for each gate', () => {
+            expect(GATE_CONFIGS[0].requiredNextSkill).toBe('arch');
+            expect(GATE_CONFIGS[5].requiredNextSkill).toBe('task-arch');
+        });
+    });
+    describe('artifacts', () => {
+        it('should be able to submit artifacts', () => {
+            artifacts.set('test', { data: 'test' });
+            expect(artifacts.has('test')).toBe(true);
+        });
+        it('should retrieve submitted artifacts', () => {
+            artifacts.set('adr', { content: 'ADR draft' });
+            const artifact = artifacts.get('adr');
+            expect(artifact).toBeDefined();
+        });
+    });
+});
+// ==================== Guard Router Tests ====================
+const GUARD_MAP = {
+    'src/agents/': ['check_api_types', 'check_skill_parity'],
+    'src/documents/': ['check_doc_freshness', 'check_api_types'],
+    'src/network/': ['check_api_types', 'check_versions'],
+    'docs/': ['check_doc_freshness', 'check_doc_links'],
+    'CLAUDE.md': ['check_doc_freshness', 'check_artifact_link'],
+    'docs/decisions/': ['check_artifact_link', 'check_versions'],
+    'src/test/': ['check_api_types', 'check_versions'],
+};
+function route(filePath) {
+    const matched = [];
+    const sortedPatterns = Object.keys(GUARD_MAP).sort((a, b) => b.length - a.length);
+    for (const pattern of sortedPatterns) {
+        if (filePath.startsWith(pattern) || filePath === pattern.replace(/\/$/, '')) {
+            matched.push(...GUARD_MAP[pattern]);
+        }
+    }
+    return [...new Set(matched)];
+}
+describe('GuardRouter', () => {
+    describe('routing', () => {
+        it('should route agents path to check_api_types', () => {
+            const guards = route('src/agents/pi-sdk.ts');
+            expect(guards).toContain('check_api_types');
+        });
+        it('should route docs path to doc freshness', () => {
+            const guards = route('docs/guide.md');
+            expect(guards).toContain('check_doc_freshness');
+        });
+        it('should route decisions to artifact link check', () => {
+            const guards = route('docs/decisions/adr-001.md');
+            expect(guards).toContain('check_artifact_link');
+        });
+        it('should route test files to version check', () => {
+            const guards = route('src/test/pi-sdk.test.ts');
+            expect(guards).toContain('check_versions');
+        });
+        it('should return empty array for unknown paths', () => {
+            const guards = route('src/unknown/file.ts');
+            expect(guards.length).toBe(0);
+        });
+        it('should handle CLAUDE.md special case', () => {
+            const guards = route('CLAUDE.md');
+            expect(guards).toContain('check_doc_freshness');
+            expect(guards).toContain('check_artifact_link');
+        });
+    });
+    describe('deduplication', () => {
+        it('should deduplicate guard names', () => {
+            const guards = route('src/agents/pi-sdk.ts');
+            const uniqueGuards = [...new Set(guards)];
+            expect(guards.length).toBe(uniqueGuards.length);
+        });
+    });
+});
+// ==================== Context Router Tests ====================
+const CONTEXT_MAP = {
+    'src/agents/': ['agent-architecture', 'multi-agent-patterns'],
+    'src/documents/': ['document-processing', 'parser-patterns'],
+    'src/network/': ['p2p-protocols', 'connection-patterns'],
+    'docs/': ['documentation-standards'],
+    'docs/decisions/': ['decision-tracking', 'adr-patterns'],
+    'src/test/': ['testing-patterns', 'quality-standards'],
+    'CLAUDE.md': ['project-governance', 'truth-source-hierarchy'],
+};
+const FALLBACK_FRAGMENTS = ['general-dev-principles', 'code-quality'];
+function match(filePath) {
+    if (!filePath)
+        return [];
+    const normalized = filePath.replace(/\\/g, '/');
+    const matched = [];
+    const sortedPatterns = Object.keys(CONTEXT_MAP).sort((a, b) => b.length - a.length);
+    for (const pattern of sortedPatterns) {
+        if (normalized.startsWith(pattern) || normalized.endsWith(pattern)) {
+            matched.push(...CONTEXT_MAP[pattern]);
+        }
+    }
+    return [...new Set(matched)];
+}
+describe('ContextRouter', () => {
+    describe('matching', () => {
+        it('should match agents path', () => {
+            const fragments = match('src/agents/protocol.ts');
+            expect(fragments).toContain('agent-architecture');
+            expect(fragments).toContain('multi-agent-patterns');
+        });
+        it('should match docs path', () => {
+            const fragments = match('docs/api.md');
+            expect(fragments).toContain('documentation-standards');
+        });
+        it('should match decisions path', () => {
+            const fragments = match('docs/decisions/adr-001.md');
+            expect(fragments).toContain('decision-tracking');
+            expect(fragments).toContain('adr-patterns');
+        });
+        it('should match CLAUDE.md', () => {
+            const fragments = match('CLAUDE.md');
+            expect(fragments).toContain('project-governance');
+        });
+        it('should return empty for invalid paths', () => {
+            const fragments = match('');
+            expect(fragments.length).toBe(0);
+        });
+    });
+    describe('fallback fragments', () => {
+        it('should have fallback fragments defined', () => {
+            expect(FALLBACK_FRAGMENTS).toContain('general-dev-principles');
+            expect(FALLBACK_FRAGMENTS).toContain('code-quality');
+        });
+    });
+});
+// Mock skills for testing
+const skills = {
+    arch: {
+        name: 'arch',
+        description: 'Project architect. Architecture decisions and boundary freezing.',
+        async execute(params) {
+            const essence = `Core challenge: ${params.task || 'unspecified'}`;
+            const tensions = ['Simplicity vs Flexibility', 'Performance vs Maintainability'];
+            const alternatives = [
+                { name: 'Option A', tradeoffs: ['Fast', 'Limited'], recommendation: 'MVP' },
+                { name: 'Option B', tradeoffs: ['More work', 'Extensible'], recommendation: 'Long-term' }
+            ];
+            return JSON.stringify({ essence, tensions, alternatives }, null, 2);
+        }
+    },
+    lead: {
+        name: 'lead',
+        description: 'Development workflow commander. Fail-closed state machine.',
+        async execute(params) {
+            const action = params.action;
+            if (action === 'get_gate') {
+                return JSON.stringify({ current_gate: 0, gate_name: 'Problem Lock', required_artifact: '问题陈述' }, null, 2);
+            }
+            if (action === 'classify') {
+                const desc = params.description || '';
+                const isPolicy = desc.includes('policy');
+                const isContract = desc.includes('API') || desc.includes('contract');
+                return JSON.stringify({
+                    classification: isPolicy ? 'policy' : isContract ? 'contract' : 'implementation',
+                    fast_track: !isPolicy && !isContract
+                }, null, 2);
+            }
+            return JSON.stringify({ current_gate: 0 });
+        }
+    },
+    task_arch: {
+        name: 'task-arch',
+        description: 'Task decomposition. Breaks down PLAN into work packages.',
+        async execute(params) {
+            const workPackages = [
+                { id: 'WP-1', description: 'Core implementation', files: ['src/agents/*.ts'] },
+                { id: 'WP-2', description: 'Network layer', files: ['src/network/*.ts'] }
+            ];
+            return JSON.stringify({ workPackages }, null, 2);
+        }
+    }
+};
+describe('Skills', () => {
+    describe('arch skill', () => {
+        it('should have correct name and description', () => {
+            expect(skills.arch.name).toBe('arch');
+            expect(skills.arch.description).toContain('architect');
+        });
+        it('should execute and return analysis', async () => {
+            const result = await skills.arch.execute({ task: 'design new feature' });
+            const parsed = JSON.parse(result);
+            expect(parsed.essence).toBeDefined();
+            expect(parsed.tensions).toHaveLength(2);
+            expect(parsed.alternatives).toHaveLength(2);
+        });
+    });
+    describe('lead skill', () => {
+        it('should have correct name', () => {
+            expect(skills.lead.name).toBe('lead');
+        });
+        it('should get gate pack', async () => {
+            const result = await skills.lead.execute({ action: 'get_gate' });
+            const parsed = JSON.parse(result);
+            expect(parsed.current_gate).toBe(0);
+        });
+        it('should classify policy changes', async () => {
+            const result = await skills.lead.execute({ action: 'classify', description: 'change policy boundary' });
+            const parsed = JSON.parse(result);
+            expect(parsed.classification).toBe('policy');
+        });
+        it('should classify contract changes', async () => {
+            const result = await skills.lead.execute({ action: 'classify', description: 'change API contract' });
+            const parsed = JSON.parse(result);
+            expect(parsed.classification).toBe('contract');
+        });
+        it('should classify implementation changes as fast-track eligible', async () => {
+            const result = await skills.lead.execute({ action: 'classify', description: 'fix bug' });
+            const parsed = JSON.parse(result);
+            expect(parsed.classification).toBe('implementation');
+            expect(parsed.fast_track).toBe(true);
+        });
+    });
+    describe('task-arch skill', () => {
+        it('should decompose plan into work packages', async () => {
+            const result = await skills.task_arch.execute({ plan: 'implement feature' });
+            const parsed = JSON.parse(result);
+            expect(parsed.workPackages).toHaveLength(2);
+            expect(parsed.workPackages[0].id).toBe('WP-1');
+        });
+    });
+});
+// ==================== Change Classification Tests ====================
+describe('Change Classification', () => {
+    function classifyChange(description) {
+        const isPolicy = description.includes('policy') || description.includes('boundary');
+        const isContract = description.includes('API') || description.includes('contract') || description.includes('schema');
+        const isImplementation = !isPolicy && !isContract;
+        return {
+            classification: isPolicy ? 'policy' : isContract ? 'contract' : 'implementation',
+            fast_track: isImplementation
+        };
+    }
+    it('should classify policy changes', () => {
+        const result = classifyChange('change policy boundary');
+        expect(result.classification).toBe('policy');
+        expect(result.fast_track).toBe(false);
+    });
+    it('should classify contract changes', () => {
+        const result = classifyChange('change API contract');
+        expect(result.classification).toBe('contract');
+        expect(result.fast_track).toBe(false);
+    });
+    it('should classify implementation changes', () => {
+        const result = classifyChange('fix bug in code');
+        expect(result.classification).toBe('implementation');
+        expect(result.fast_track).toBe(true);
+    });
+    it('should classify schema changes as contract', () => {
+        const result = classifyChange('update database schema');
+        expect(result.classification).toBe('contract');
+    });
+});
+// ==================== Integration Configuration Tests ====================
+describe('BollharnessConfig', () => {
+    function createDefaultConfig() {
+        return {
+            enabled: true,
+            guardsEnabled: true,
+            contextEnabled: true,
+            skillsEnabled: true,
+            gatesEnabled: true,
+        };
+    }
+    it('should have default config with all features enabled', () => {
+        const config = createDefaultConfig();
+        expect(config.enabled).toBe(true);
+        expect(config.guardsEnabled).toBe(true);
+        expect(config.contextEnabled).toBe(true);
+        expect(config.skillsEnabled).toBe(true);
+        expect(config.gatesEnabled).toBe(true);
+    });
+});