@bolloon/bolloon-agent 0.3.52 → 0.4.0

package/dist/test/global-shared-context.test.js

@@ -0,0 +1,315 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { GlobalSharedContextManager, resetGlobalSharedContext } from '../social/global-shared-context.js';
+const TEST_CONTEXT_PATH = path.join('/tmp', '.bolloon-test', 'sessions', 'test-global-context.json');
+describe('GlobalSharedContext', () => {
+    let contextManager;
+    beforeEach(async () => {
+        resetGlobalSharedContext();
+        contextManager = new GlobalSharedContextManager(TEST_CONTEXT_PATH);
+        try {
+            await fs.rm(path.dirname(TEST_CONTEXT_PATH), { recursive: true, force: true });
+        }
+        catch { }
+    });
+    describe('SharedMemory - recentActions', () => {
+        it('should add user action', async () => {
+            await contextManager.initialize();
+            await contextManager.addUserAction('用户要求总结文档', 'agent1', 'channel1', 8);
+            const actions = await contextManager.getRecentActions();
+            expect(actions).toHaveLength(1);
+            expect(actions[0].content).toBe('用户要求总结文档');
+            expect(actions[0].agentId).toBe('agent1');
+            expect(actions[0].channelId).toBe('channel1');
+            expect(actions[0].importance).toBe(8);
+        });
+        it('should limit recent actions to 50', async () => {
+            await contextManager.initialize();
+            for (let i = 0; i < 60; i++) {
+                await contextManager.addUserAction(`Action ${i}`);
+            }
+            const actions = await contextManager.getRecentActions(60);
+            expect(actions).toHaveLength(50);
+        });
+        it('should return formatted summary', async () => {
+            await contextManager.initialize();
+            await contextManager.addUserAction('测试行动1');
+            await contextManager.addUserAction('测试行动2');
+            const summary = await contextManager.getRecentActionsSummary(10);
+            expect(summary).toContain('测试行动1');
+            expect(summary).toContain('测试行动2');
+        });
+    });
+    describe('SharedMemory - sharedKnowledge', () => {
+        it('should add shared knowledge', async () => {
+            await contextManager.initialize();
+            await contextManager.addSharedKnowledge('这是一个重要的跨Agent共享知识');
+            const knowledge = await contextManager.getSharedKnowledge();
+            expect(knowledge).toContain('这是一个重要的跨Agent共享知识');
+        });
+        it('should not duplicate knowledge', async () => {
+            await contextManager.initialize();
+            await contextManager.addSharedKnowledge('共享知识');
+            await contextManager.addSharedKnowledge('共享知识');
+            const knowledge = await contextManager.getSharedKnowledge();
+            expect(knowledge.filter(k => k === '共享知识')).toHaveLength(1);
+        });
+        it('should limit shared knowledge to 100', async () => {
+            await contextManager.initialize();
+            for (let i = 0; i < 110; i++) {
+                await contextManager.addSharedKnowledge(`Knowledge ${i}`);
+            }
+            const knowledge = await contextManager.getSharedKnowledge();
+            expect(knowledge).toHaveLength(100);
+        });
+    });
+    describe('SharedMemory - currentTask', () => {
+        it('should set and get current task', async () => {
+            await contextManager.initialize();
+            const task = await contextManager.setCurrentTask({
+                description: '完成文档总结',
+                status: 'in_progress'
+            });
+            expect(task.id).toBeDefined();
+            expect(task.description).toBe('完成文档总结');
+            expect(task.status).toBe('in_progress');
+            expect(task.createdAt).toBeDefined();
+            const currentTask = await contextManager.getCurrentTask();
+            expect(currentTask?.description).toBe('完成文档总结');
+        });
+        it('should complete current task', async () => {
+            await contextManager.initialize();
+            await contextManager.setCurrentTask({
+                description: '完成文档总结',
+                status: 'in_progress'
+            });
+            await contextManager.completeCurrentTask('文档总结已完成');
+            const currentTask = await contextManager.getCurrentTask();
+            expect(currentTask?.status).toBe('completed');
+            expect(currentTask?.result).toBe('文档总结已完成');
+            expect(currentTask?.completedAt).toBeDefined();
+        });
+    });
+    describe('AgentRegistry', () => {
+        it('should register agent', async () => {
+            await contextManager.initialize();
+            await contextManager.registerAgent({
+                agentId: 'agent-001',
+                sessionId: 'session-001',
+                channelId: 'channel-001',
+                capabilities: ['coding', 'writing'],
+                status: 'active',
+                name: 'TestAgent'
+            });
+            const agent = await contextManager.getAgent('agent-001');
+            expect(agent).toBeDefined();
+            expect(agent?.name).toBe('TestAgent');
+            expect(agent?.capabilities).toEqual(['coding', 'writing']);
+            expect(agent?.status).toBe('active');
+        });
+        it('should update agent status', async () => {
+            await contextManager.initialize();
+            await contextManager.registerAgent({
+                agentId: 'agent-001',
+                sessionId: 'session-001',
+                channelId: 'channel-001',
+                capabilities: ['coding'],
+                status: 'active'
+            });
+            await contextManager.updateAgentStatus('agent-001', 'busy');
+            const agent = await contextManager.getAgent('agent-001');
+            expect(agent?.status).toBe('busy');
+        });
+        it('should get all agents', async () => {
+            await contextManager.initialize();
+            await contextManager.registerAgent({
+                agentId: 'agent-001',
+                sessionId: 'session-001',
+                channelId: 'channel-001',
+                capabilities: ['coding'],
+                status: 'active'
+            });
+            await contextManager.registerAgent({
+                agentId: 'agent-002',
+                sessionId: 'session-002',
+                channelId: 'channel-002',
+                capabilities: ['writing'],
+                status: 'idle'
+            });
+            const agents = await contextManager.getAllAgents();
+            expect(agents).toHaveLength(2);
+        });
+        it('should find agents by capability', async () => {
+            await contextManager.initialize();
+            await contextManager.registerAgent({
+                agentId: 'agent-001',
+                sessionId: 'session-001',
+                channelId: 'channel-001',
+                capabilities: ['coding', 'debugging'],
+                status: 'active'
+            });
+            await contextManager.registerAgent({
+                agentId: 'agent-002',
+                sessionId: 'session-002',
+                channelId: 'channel-002',
+                capabilities: ['writing', 'editing'],
+                status: 'active'
+            });
+            const codingAgents = await contextManager.findAgentByCapability('coding');
+            expect(codingAgents).toHaveLength(1);
+            expect(codingAgents[0].agentId).toBe('agent-001');
+        });
+        it('should get active agents', async () => {
+            await contextManager.initialize();
+            await contextManager.registerAgent({
+                agentId: 'agent-001',
+                sessionId: 'session-001',
+                channelId: 'channel-001',
+                capabilities: ['coding'],
+                status: 'active'
+            });
+            await contextManager.registerAgent({
+                agentId: 'agent-002',
+                sessionId: 'session-002',
+                channelId: 'channel-002',
+                capabilities: ['writing'],
+                status: 'idle'
+            });
+            const activeAgents = await contextManager.getActiveAgents();
+            expect(activeAgents).toHaveLength(1);
+            expect(activeAgents[0].agentId).toBe('agent-001');
+        });
+        it('should unregister agent', async () => {
+            await contextManager.initialize();
+            await contextManager.registerAgent({
+                agentId: 'agent-001',
+                sessionId: 'session-001',
+                channelId: 'channel-001',
+                capabilities: ['coding'],
+                status: 'active'
+            });
+            await contextManager.unregisterAgent('agent-001');
+            const agent = await contextManager.getAgent('agent-001');
+            expect(agent).toBeUndefined();
+        });
+    });
+    describe('CooperationQueue', () => {
+        it('should create cooperation task', async () => {
+            await contextManager.initialize();
+            const cooperation = await contextManager.createCooperation('consult', 'agent-001', '请帮我分析这段代码', 'agent-002', 'context here');
+            expect(cooperation.id).toBeDefined();
+            expect(cooperation.type).toBe('consult');
+            expect(cooperation.fromAgentId).toBe('agent-001');
+            expect(cooperation.toAgentId).toBe('agent-002');
+            expect(cooperation.task).toBe('请帮我分析这段代码');
+            expect(cooperation.context).toBe('context here');
+            expect(cooperation.status).toBe('pending');
+        });
+        it('should update cooperation status', async () => {
+            await contextManager.initialize();
+            const cooperation = await contextManager.createCooperation('delegate', 'agent-001', '完成这个任务');
+            await contextManager.updateCooperationStatus(cooperation.id, 'in_progress');
+            const updated = await contextManager.getCooperation(cooperation.id);
+            expect(updated?.status).toBe('in_progress');
+        });
+        it('should get pending cooperations for agent', async () => {
+            await contextManager.initialize();
+            await contextManager.createCooperation('consult', 'agent-001', 'Task 1', 'agent-002');
+            await contextManager.createCooperation('delegate', 'agent-001', 'Task 2');
+            const pending = await contextManager.getPendingCooperations('agent-001');
+            expect(pending).toHaveLength(2);
+        });
+        it('should get cooperations for specific agent', async () => {
+            await contextManager.initialize();
+            await contextManager.createCooperation('consult', 'agent-001', 'Task for agent-002', 'agent-002');
+            await contextManager.createCooperation('delegate', 'agent-003', 'Task for agent-003', 'agent-003');
+            const agent002Coops = await contextManager.getCooperationsForAgent('agent-002');
+            expect(agent002Coops).toHaveLength(1);
+            expect(agent002Coops[0].task).toBe('Task for agent-002');
+        });
+        it('should add result to cooperation', async () => {
+            await contextManager.initialize();
+            const cooperation = await contextManager.createCooperation('consult', 'agent-001', '请分析');
+            await contextManager.updateCooperationStatus(cooperation.id, 'done', '分析结果：代码有bug');
+            const updated = await contextManager.getCooperation(cooperation.id);
+            expect(updated?.status).toBe('done');
+            expect(updated?.result).toBe('分析结果：代码有bug');
+        });
+    });
+    describe('Full context', () => {
+        it('should get full context', async () => {
+            await contextManager.initialize();
+            await contextManager.addUserAction('Test action');
+            await contextManager.addSharedKnowledge('Test knowledge');
+            await contextManager.registerAgent({
+                agentId: 'agent-001',
+                sessionId: 'session-001',
+                channelId: 'channel-001',
+                capabilities: ['coding'],
+                status: 'active'
+            });
+            const fullContext = await contextManager.getFullContext();
+            expect(fullContext.memory.recentActions).toHaveLength(1);
+            expect(fullContext.memory.sharedKnowledge).toHaveLength(1);
+            expect(fullContext.agentRegistry['agent-001']).toBeDefined();
+        });
+        it('should get context summary', async () => {
+            await contextManager.initialize();
+            await contextManager.addUserAction('用户执行了操作A');
+            await contextManager.registerAgent({
+                agentId: 'agent-001',
+                sessionId: 'session-001',
+                channelId: 'channel-001',
+                capabilities: ['coding'],
+                status: 'active',
+                name: '编码助手'
+            });
+            const summary = await contextManager.getContextSummary();
+            expect(summary).toContain('全局共享上下文');
+            expect(summary).toContain('最近行动');
+            expect(summary).toContain('用户执行了操作A');
+            expect(summary).toContain('Agent 注册');
+            expect(summary).toContain('编码助手');
+        });
+    });
+    describe('Persistence', () => {
+        it('should persist and reload context', async () => {
+            await contextManager.initialize();
+            await contextManager.addUserAction('持久化测试');
+            await contextManager.registerAgent({
+                agentId: 'agent-001',
+                sessionId: 'session-001',
+                channelId: 'channel-001',
+                capabilities: ['coding'],
+                status: 'active'
+            });
+            const newManager = new GlobalSharedContextManager(TEST_CONTEXT_PATH);
+            await newManager.initialize();
+            const actions = await newManager.getRecentActions();
+            expect(actions).toHaveLength(1);
+            expect(actions[0].content).toBe('持久化测试');
+            const agent = await newManager.getAgent('agent-001');
+            expect(agent).toBeDefined();
+        });
+    });
+    describe('Clear', () => {
+        it('should clear all data', async () => {
+            await contextManager.initialize();
+            await contextManager.addUserAction('Test action');
+            await contextManager.addSharedKnowledge('Test knowledge');
+            await contextManager.registerAgent({
+                agentId: 'agent-001',
+                sessionId: 'session-001',
+                channelId: 'channel-001',
+                capabilities: ['coding'],
+                status: 'active'
+            });
+            await contextManager.clear();
+            const context = await contextManager.getFullContext();
+            expect(context.memory.recentActions).toHaveLength(0);
+            expect(context.memory.sharedKnowledge).toHaveLength(0);
+            expect(Object.keys(context.agentRegistry)).toHaveLength(0);
+        });
+    });
+});

package/dist/test/harness-judgment-injection.test.js

@@ -0,0 +1,246 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { generateJudgmentInjection, getCoreJudgmentsForSession, getJudgmentsForPath, getJudgmentsForFragment, getJudgmentsForContextRequest, } from '../bollharness-integration/context-router-judgment.js';
+import * as judgmentModule from '../pi-ecosystem-judgment/index.js';
+describe('Harness Judgment Injection - Gate Integration', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('Gate-specific judgment injection', () => {
+        it('should inject core judgments at Gate 0 (session start)', async () => {
+            const injection = await generateJudgmentInjection('src/agents/', 0);
+            expect(injection).toContain('# User Core Values');
+            expect(injection).toContain('core_judgments:');
+            expect(injection).toContain('confidence: 0.9');
+        });
+        it('should inject path judgments at Gate 3 (plan freeze)', async () => {
+            const injection = await generateJudgmentInjection('src/agents/', 3);
+            expect(injection).toContain('# Plan Freeze');
+            expect(injection).toContain('active_judgments:');
+        });
+        it('should return path judgments for Gate 1 (not core)', async () => {
+            const injection = await generateJudgmentInjection('src/agents/', 1);
+            expect(injection).toContain('# Gate 1');
+            expect(injection).not.toContain('core_judgments:');
+        });
+        it('should include confidence in injection header', async () => {
+            const injection = await generateJudgmentInjection('src/agents/', 3);
+            expect(injection).toMatch(/# Confidence: \d+%/);
+        });
+        it('should include file path in injection header', async () => {
+            const injection = await generateJudgmentInjection('src/agents/', 3);
+            expect(injection).toContain('# Path: src/agents/');
+        });
+    });
+    describe('Path-based judgment routing', () => {
+        it('should route src/agents/ to agent-related fragments', async () => {
+            const result = await getJudgmentsForPath('src/agents/');
+            expect(result.fragments).toBeDefined();
+            expect(Array.isArray(result.fragments)).toBe(true);
+        });
+        it('should return judgments sorted by confidence', async () => {
+            const result = await getJudgmentsForPath('src/agents/');
+            if (result.judgments.length > 1) {
+                for (let i = 1; i < result.judgments.length; i++) {
+                    expect(result.judgments[i - 1].confidence).toBeGreaterThanOrEqual(result.judgments[i].confidence);
+                }
+            }
+        });
+        it('should filter judgments by minimum confidence', async () => {
+            const result = await getJudgmentsForPath('src/agents/', { minConfidence: 0.9 });
+            for (const j of result.judgments) {
+                expect(j.confidence).toBeGreaterThanOrEqual(0.9);
+            }
+        });
+        it('should limit number of judgments', async () => {
+            const result = await getJudgmentsForPath('src/agents/', { maxJudgments: 3 });
+            expect(result.judgments.length).toBeLessThanOrEqual(3);
+        });
+        it('should calculate overall confidence for path', async () => {
+            const result = await getJudgmentsForPath('src/agents/');
+            expect(typeof result.confidence).toBe('number');
+            expect(result.confidence).toBeGreaterThanOrEqual(0);
+            expect(result.confidence).toBeLessThanOrEqual(1);
+        });
+    });
+    describe('Fragment to judgment mapping', () => {
+        it('should map agent-architecture fragment to agent contexts', async () => {
+            const judgments = await getJudgmentsForFragment('agent-architecture');
+            expect(Array.isArray(judgments)).toBe(true);
+        });
+        it('should map testing-patterns fragment to testing contexts', async () => {
+            const judgments = await getJudgmentsForFragment('testing-patterns');
+            expect(Array.isArray(judgments)).toBe(true);
+        });
+        it('should return empty for unknown fragment', async () => {
+            const judgments = await getJudgmentsForFragment('unknown-fragment-xyz');
+            expect(Array.isArray(judgments)).toBe(true);
+        });
+        it('should deduplicate judgments across fragments', async () => {
+            const result = await getJudgmentsForPath('src/agents/');
+            const ids = result.judgments.map(j => j.id);
+            const uniqueIds = new Set(ids);
+            expect(ids.length).toBe(uniqueIds.size);
+        });
+    });
+    describe('Core judgments for session', () => {
+        it('should only include human source judgments', async () => {
+            const injection = await getCoreJudgmentsForSession(0.9);
+            if (injection.length > 0) {
+                expect(injection).toContain('core_judgments:');
+            }
+        });
+        it('should filter by minimum confidence', async () => {
+            const injection = await getCoreJudgmentsForSession(0.95);
+            if (injection.length > 0) {
+                expect(injection).toContain('confidence: 0.95');
+            }
+        });
+        it('should limit to 10 judgments', async () => {
+            const injection = await getCoreJudgmentsForSession(0.5);
+            const matches = injection.match(/principle:/g);
+            if (matches) {
+                expect(matches.length).toBeLessThanOrEqual(10);
+            }
+        });
+        it('should return empty string when no judgments meet threshold', async () => {
+            const injection = await getCoreJudgmentsForSession(1.0);
+            expect(typeof injection).toBe('string');
+        });
+    });
+    describe('Judgment formatting', () => {
+        it('should format judgments as YAML by default', async () => {
+            const result = await getJudgmentsForPath('src/agents/', { format: 'yaml' });
+            expect(result.contextYaml).toContain('active_judgments:');
+        });
+        it('should format judgments as JSON', async () => {
+            const result = await getJudgmentsForPath('src/agents/', { format: 'json' });
+            expect(result.contextYaml).toContain('[');
+            expect(() => JSON.parse(result.contextYaml)).not.toThrow();
+        });
+        it('should format judgments as text', async () => {
+            const result = await getJudgmentsForPath('src/agents/', { format: 'text' });
+            expect(result.contextYaml).toMatch(/\[\d+%\]/);
+        });
+        it('should escape YAML strings correctly', async () => {
+            const result = await getJudgmentsForPath('src/agents/', { format: 'yaml' });
+            expect(result.contextYaml).not.toContain('\n"');
+        });
+    });
+    describe('Context-specific judgment requests', () => {
+        it('should get judgments for explicit context', async () => {
+            const result = await getJudgmentsForContextRequest('typescript');
+            expect(result).toHaveProperty('judgments');
+            expect(result).toHaveProperty('confidence');
+            expect(result).toHaveProperty('contextYaml');
+        });
+        it('should filter by context match', async () => {
+            const result = await getJudgmentsForContextRequest('code-quality');
+            for (const j of result.judgments) {
+                const hasMatch = j.context?.toLowerCase().includes('code-quality') ||
+                    j.context?.toLowerCase().includes('quality') ||
+                    j.context?.toLowerCase().includes('development');
+                expect(hasMatch).toBeTruthy();
+            }
+        });
+    });
+});
+describe('Harness Judgment Injection - Multi-Agent Scenarios', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('Decision level with harness context', () => {
+        it('should route consult_internal to colony_ant and subagent', async () => {
+            vi.spyOn(judgmentModule, 'calculateConfidence').mockReturnValueOnce(0.5);
+            const { evaluateDecision } = await import('../pi-ecosystem-judgment/decision.js');
+            const request = await evaluateDecision('Delegate task to colony ant', 'delegation', 'agent-001', 0.7);
+            expect(request.targets).toContain('colony_ant');
+            expect(request.targets).toContain('subagent');
+            expect(request.targets).not.toContain('p2p_agent');
+        });
+        it('should route consult_external to p2p_agent', async () => {
+            vi.spyOn(judgmentModule, 'calculateConfidence').mockReturnValueOnce(0.35);
+            const { evaluateDecision } = await import('../pi-ecosystem-judgment/decision.js');
+            const request = await evaluateDecision('Cross-system protocol negotiation', 'protocol', 'agent-001', 0.7);
+            expect(request.targets).toContain('p2p_agent');
+            expect(request.targets).toContain('colony_ant');
+            expect(request.targets).toContain('subagent');
+        });
+        it('should escalate to human for strategic decisions', async () => {
+            vi.spyOn(judgmentModule, 'calculateConfidence').mockReturnValueOnce(0.2);
+            const { evaluateDecision } = await import('../pi-ecosystem-judgment/decision.js');
+            const request = await evaluateDecision('Strategic pivot decision', 'strategy', 'agent-001', 0.7);
+            expect(request.targets).toEqual(['human']);
+        });
+    });
+    describe('Judgment confidence propagation', () => {
+        it('should use harness path confidence for decision routing', async () => {
+            const result = await getJudgmentsForPath('src/agents/');
+            vi.spyOn(judgmentModule, 'calculateConfidence').mockReturnValueOnce(result.confidence);
+            const { evaluateDecision } = await import('../pi-ecosystem-judgment/decision.js');
+            const request = await evaluateDecision('Agent architecture decision', 'architecture', 'agent-001', 0.7);
+            if (result.confidence >= 0.7) {
+                expect(request.level).toBe('autonomous');
+            }
+            else if (result.confidence >= 0.49) {
+                expect(request.level).toBe('consult_internal');
+            }
+            else if (result.confidence >= 0.28) {
+                expect(request.level).toBe('consult_external');
+            }
+            else {
+                expect(request.level).toBe('require_human');
+            }
+        });
+    });
+});
+describe('Harness Judgment Injection - Gate Confidence Thresholds', () => {
+    const gateThresholds = [
+        { gate: 0, expectedMinConfidence: 0.9, description: 'Session start - highest bar' },
+        { gate: 1, expectedMinConfidence: 0.8, description: 'Architecture design' },
+        { gate: 2, expectedMinConfidence: 0.75, description: 'Review' },
+        { gate: 3, expectedMinConfidence: 0.8, description: 'Plan freeze' },
+        { gate: 5, expectedMinConfidence: 0.7, description: 'Task architecture' },
+        { gate: 7, expectedMinConfidence: 0.7, description: 'Execution' },
+    ];
+    it.each(gateThresholds)('Gate $gate ($description) should use minConfidence $expectedMinConfidence', async ({ gate, expectedMinConfidence }) => {
+        const injection = await generateJudgmentInjection('src/agents/', gate);
+        if (gate === 0 || gate === 1 || gate === 2 || gate === 3 || gate === 5 || gate === 7) {
+            expect(injection).toBeDefined();
+            expect(typeof injection).toBe('string');
+        }
+    });
+    it('should return path judgments for all non-zero gates', async () => {
+        for (const gate of [1, 2, 4, 5, 6, 8, 9]) {
+            const injection = await generateJudgmentInjection('src/agents/', gate);
+            expect(typeof injection).toBe('string');
+        }
+    });
+});
+describe('Harness Judgment Injection - End-to-End Flow', () => {
+    it('should produce injectable YAML for agent context', async () => {
+        const injection = await generateJudgmentInjection('src/agents/', 0);
+        const hasValidYamlStructure = injection.includes('core_judgments:') ||
+            injection.includes('active_judgments:') ||
+            injection.includes('# User Core Values');
+        expect(hasValidYamlStructure).toBeTruthy();
+    });
+    it('should format judgments for LLM consumption', async () => {
+        const result = await getJudgmentsForPath('src/agents/', { format: 'yaml' });
+        const lines = result.contextYaml.split('\n');
+        const hasPrinciple = lines.some(line => line.includes('principle:'));
+        const hasConfidence = lines.some(line => line.includes('confidence:'));
+        expect(hasPrinciple || hasConfidence).toBeTruthy();
+    });
+    it('should fallback to general-dev-principles for unknown paths', async () => {
+        const result = await getJudgmentsForPath('/nonexistent/path/that/matches/nothing');
+        expect(result).toHaveProperty('judgments');
+        expect(result).toHaveProperty('confidence');
+        expect(result.fragments).toContain('general-dev-principles');
+    });
+    it('should provide traceability from path to fragment to judgment', async () => {
+        const result = await getJudgmentsForPath('src/agents/');
+        expect(result.fragments.length).toBeGreaterThan(0);
+        expect(result.judgments.length).toBeGreaterThanOrEqual(0);
+        expect(typeof result.confidence).toBe('number');
+    });
+});