@holoscript/framework 6.0.3 → 6.0.4

package/src/__tests__/framework.test.ts

@@ -27,11 +27,15 @@ describe('defineAgent', () => {
   });
 
   it('throws on invalid role', () => {
-    expect(() => defineAgent({ ...validAgent, role: 'wizard' as unknown as AgentConfig['role'] })).toThrow('Invalid role');
+    expect(() =>
+      defineAgent({ ...validAgent, role: 'wizard' as unknown as AgentConfig['role'] })
+    ).toThrow('Invalid role');
   });
 
   it('throws on missing model', () => {
-    expect(() => defineAgent({ ...validAgent, model: { provider: 'anthropic', model: '' } })).toThrow('model');
+    expect(() =>
+      defineAgent({ ...validAgent, model: { provider: 'anthropic', model: '' } })
+    ).toThrow('model');
   });
 
   it('throws on empty capabilities', () => {
@@ -80,7 +84,9 @@ describe('defineTeam', () => {
   });
 
   it('throws when agents exceed max slots', () => {
-    expect(() => defineTeam({ name: 'test', agents: [coder, reviewer], maxSlots: 1 })).toThrow('slots');
+    expect(() => defineTeam({ name: 'test', agents: [coder, reviewer], maxSlots: 1 })).toThrow(
+      'slots'
+    );
   });
 });
 
@@ -90,11 +96,15 @@ describe('Team.addTasks', () => {
   it('adds tasks and deduplicates', async () => {
     const team = defineTeam({
       name: 'board-test',
-      agents: [defineAgent({
-        name: 'A', role: 'coder',
-        model: { provider: 'anthropic', model: 'claude-sonnet-4' },
-        capabilities: ['c'], claimFilter: { roles: ['coder'], maxPriority: 10 },
-      })],
+      agents: [
+        defineAgent({
+          name: 'A',
+          role: 'coder',
+          model: { provider: 'anthropic', model: 'claude-sonnet-4' },
+          capabilities: ['c'],
+          claimFilter: { roles: ['coder'], maxPriority: 10 },
+        }),
+      ],
     });
 
     const added1 = await team.addTasks([
@@ -116,11 +126,15 @@ describe('Team.addTasks', () => {
   it('sorts open tasks by priority', async () => {
     const team = defineTeam({
       name: 'priority-test',
-      agents: [defineAgent({
-        name: 'A', role: 'coder',
-        model: { provider: 'anthropic', model: 'claude-sonnet-4' },
-        capabilities: ['c'], claimFilter: { roles: ['coder'], maxPriority: 10 },
-      })],
+      agents: [
+        defineAgent({
+          name: 'A',
+          role: 'coder',
+          model: { provider: 'anthropic', model: 'claude-sonnet-4' },
+          capabilities: ['c'],
+          claimFilter: { roles: ['coder'], maxPriority: 10 },
+        }),
+      ],
     });
 
     await team.addTasks([
@@ -142,11 +156,15 @@ describe('Team.scoutFromTodos', () => {
   it('parses grep output into tasks', async () => {
     const team = defineTeam({
       name: 'scout-test',
-      agents: [defineAgent({
-        name: 'A', role: 'coder',
-        model: { provider: 'anthropic', model: 'claude-sonnet-4' },
-        capabilities: ['c'], claimFilter: { roles: ['coder'], maxPriority: 10 },
-      })],
+      agents: [
+        defineAgent({
+          name: 'A',
+          role: 'coder',
+          model: { provider: 'anthropic', model: 'claude-sonnet-4' },
+          capabilities: ['c'],
+          claimFilter: { roles: ['coder'], maxPriority: 10 },
+        }),
+      ],
     });
 
     const grepOutput = [
@@ -173,9 +191,36 @@ describe('KnowledgeStore', () => {
   it('publishes and searches entries', () => {
     const store = new KnowledgeStore({ persist: false });
 
-    store.publish({ type: 'pattern', content: 'Use JWT for stateless auth', domain: 'security', confidence: 0.9, source: 'Coder' }, 'Coder');
-    store.publish({ type: 'gotcha', content: 'Never store tokens in localStorage', domain: 'security', confidence: 0.95, source: 'Reviewer' }, 'Reviewer');
-    store.publish({ type: 'wisdom', content: 'GraphQL reduces over-fetching', domain: 'api', confidence: 0.7, source: 'Researcher' }, 'Researcher');
+    store.publish(
+      {
+        type: 'pattern',
+        content: 'Use JWT for stateless auth',
+        domain: 'security',
+        confidence: 0.9,
+        source: 'Coder',
+      },
+      'Coder'
+    );
+    store.publish(
+      {
+        type: 'gotcha',
+        content: 'Never store tokens in localStorage',
+        domain: 'security',
+        confidence: 0.95,
+        source: 'Reviewer',
+      },
+      'Reviewer'
+    );
+    store.publish(
+      {
+        type: 'wisdom',
+        content: 'GraphQL reduces over-fetching',
+        domain: 'api',
+        confidence: 0.7,
+        source: 'Researcher',
+      },
+      'Researcher'
+    );
 
     expect(store.size).toBe(3);
 
@@ -190,8 +235,26 @@ describe('KnowledgeStore', () => {
   it('deduplicates identical content', () => {
     const store = new KnowledgeStore({ persist: false });
 
-    const e1 = store.publish({ type: 'wisdom', content: 'Test your code', domain: 'general', confidence: 0.8, source: 'A' }, 'A');
-    const e2 = store.publish({ type: 'wisdom', content: 'Test your code', domain: 'general', confidence: 0.8, source: 'B' }, 'B');
+    const e1 = store.publish(
+      {
+        type: 'wisdom',
+        content: 'Test your code',
+        domain: 'general',
+        confidence: 0.8,
+        source: 'A',
+      },
+      'A'
+    );
+    const e2 = store.publish(
+      {
+        type: 'wisdom',
+        content: 'Test your code',
+        domain: 'general',
+        confidence: 0.8,
+        source: 'B',
+      },
+      'B'
+    );
 
     expect(e1.id).toBe(e2.id); // same entry returned
     expect(store.size).toBe(1);
@@ -200,11 +263,35 @@ describe('KnowledgeStore', () => {
   it('compounds cross-domain insights', () => {
     const store = new KnowledgeStore({ persist: false });
 
-    store.publish({ type: 'pattern', content: 'Rate limiting prevents abuse', domain: 'security', confidence: 0.9, source: 'A' }, 'A');
-    store.publish({ type: 'pattern', content: 'Cache invalidation is hard', domain: 'performance', confidence: 0.8, source: 'B' }, 'B');
+    store.publish(
+      {
+        type: 'pattern',
+        content: 'Rate limiting prevents abuse',
+        domain: 'security',
+        confidence: 0.9,
+        source: 'A',
+      },
+      'A'
+    );
+    store.publish(
+      {
+        type: 'pattern',
+        content: 'Cache invalidation is hard',
+        domain: 'performance',
+        confidence: 0.8,
+        source: 'B',
+      },
+      'B'
+    );
 
     const crossRefs = store.compound([
-      { type: 'wisdom', content: 'Rate limiting and caching need coordination', domain: 'architecture', confidence: 0.7, source: 'C' },
+      {
+        type: 'wisdom',
+        content: 'Rate limiting and caching need coordination',
+        domain: 'architecture',
+        confidence: 0.7,
+        source: 'C',
+      },
     ]);
 
     expect(crossRefs).toBeGreaterThan(0);
@@ -216,10 +303,7 @@ describe('KnowledgeStore', () => {
 describe('Behavior Tree', () => {
   it('Sequence succeeds when all children succeed', () => {
     const tree = new BehaviorTree(
-      new SequenceNode([
-        new ActionNode('a', () => 'success'),
-        new ActionNode('b', () => 'success'),
-      ])
+      new SequenceNode([new ActionNode('a', () => 'success'), new ActionNode('b', () => 'success')])
     );
     expect(tree.tick(0)).toBe('success');
   });
@@ -229,7 +313,10 @@ describe('Behavior Tree', () => {
     const tree = new BehaviorTree(
       new SequenceNode([
         new ActionNode('a', () => 'failure'),
-        new ActionNode('b', () => { bRan = true; return 'success'; }),
+        new ActionNode('b', () => {
+          bRan = true;
+          return 'success';
+        }),
       ])
     );
     expect(tree.tick(0)).toBe('failure');
@@ -252,7 +339,10 @@ describe('Behavior Tree', () => {
     const tree = new BehaviorTree(
       new SequenceNode([
         new ConditionNode('check', () => true),
-        new ActionNode('do', () => { executed = true; return 'success'; }),
+        new ActionNode('do', () => {
+          executed = true;
+          return 'success';
+        }),
       ])
     );
     tree.tick(0);
@@ -273,7 +363,13 @@ vi.mock('../protocol-agent', () => ({
   runProtocolCycle: vi.fn().mockResolvedValue({
     summary: 'Completed synthesized task',
     insights: [
-      { type: 'wisdom', content: 'Autonomous goals keep agents productive', domain: 'security', confidence: 0.7, source: 'Coder' },
+      {
+        type: 'wisdom',
+        content: 'Autonomous goals keep agents productive',
+        domain: 'security',
+        confidence: 0.7,
+        source: 'Coder',
+      },
     ],
   }),
 }));
@@ -346,9 +442,11 @@ describe('Goal Synthesis (empty board)', () => {
 
 describe('Team remote facade methods', () => {
   const agent = defineAgent({
-    name: 'A', role: 'coder',
+    name: 'A',
+    role: 'coder',
     model: { provider: 'anthropic', model: 'claude-sonnet-4' },
-    capabilities: ['c'], claimFilter: { roles: ['coder'], maxPriority: 10 },
+    capabilities: ['c'],
+    claimFilter: { roles: ['coder'], maxPriority: 10 },
   });
 
   // Helper: create a local-only team (no boardUrl)
@@ -375,8 +473,14 @@ describe('Team remote facade methods', () => {
 
   describe('suggest() remote', () => {
     it('calls POST /suggestions with correct body', async () => {
-      const { team, fetchSpy } = remoteTeam({ suggestion: { id: 's1', title: 'idea', status: 'open', votes: 0, createdAt: '2026-01-01' } });
-      const result = await team.suggest('idea', { description: 'desc', category: 'ux', evidence: 'data' });
+      const { team, fetchSpy } = remoteTeam({
+        suggestion: { id: 's1', title: 'idea', status: 'open', votes: 0, createdAt: '2026-01-01' },
+      });
+      const result = await team.suggest('idea', {
+        description: 'desc',
+        category: 'ux',
+        evidence: 'data',
+      });
       expect(result.suggestion.id).toBe('s1');
       expect(fetchSpy).toHaveBeenCalledTimes(1);
       const [url, opts] = fetchSpy.mock.calls[0];
@@ -401,7 +505,9 @@ describe('Team remote facade methods', () => {
 
   describe('vote() remote', () => {
     it('calls PATCH /suggestions/:id with vote action', async () => {
-      const { team, fetchSpy } = remoteTeam({ suggestion: { id: 's1', title: 'idea', status: 'open', votes: 1, createdAt: '2026-01-01' } });
+      const { team, fetchSpy } = remoteTeam({
+        suggestion: { id: 's1', title: 'idea', status: 'open', votes: 1, createdAt: '2026-01-01' },
+      });
       const result = await team.vote('s1', 1, 'good idea');
       expect(result.suggestion.votes).toBe(1);
       const [url, opts] = fetchSpy.mock.calls[0];
@@ -494,7 +600,9 @@ describe('Team remote facade methods', () => {
     });
 
     it('calls GET /slots', async () => {
-      const { team, fetchSpy } = remoteTeam({ slots: [{ agentName: 'A', role: 'coder', status: 'active' }] });
+      const { team, fetchSpy } = remoteTeam({
+        slots: [{ agentName: 'A', role: 'coder', status: 'active' }],
+      });
       const result = await team.presence();
       expect(result.slots).toHaveLength(1);
       expect(result.slots[0].agentName).toBe('A');
@@ -541,14 +649,18 @@ describe('Team remote facade methods', () => {
 
 describe('Team local suggestions', () => {
   const agent1 = defineAgent({
-    name: 'Alice', role: 'coder',
+    name: 'Alice',
+    role: 'coder',
     model: { provider: 'anthropic', model: 'claude-sonnet-4' },
-    capabilities: ['code-generation'], claimFilter: { roles: ['coder'], maxPriority: 10 },
+    capabilities: ['code-generation'],
+    claimFilter: { roles: ['coder'], maxPriority: 10 },
   });
   const agent2 = defineAgent({
-    name: 'Bob', role: 'researcher',
+    name: 'Bob',
+    role: 'researcher',
     model: { provider: 'anthropic', model: 'claude-sonnet-4' },
-    capabilities: ['research'], claimFilter: { roles: ['researcher'], maxPriority: 10 },
+    capabilities: ['research'],
+    claimFilter: { roles: ['researcher'], maxPriority: 10 },
   });
 
   function makeTeam() {
@@ -599,7 +711,7 @@ describe('Team local suggestions', () => {
 
     it('allows resubmission after dismiss', async () => {
       const team = makeTeam();
-      const { suggestion } = (await team.suggest('Add caching'));
+      const { suggestion } = await team.suggest('Add caching');
       team.dismissSuggestion(suggestion.id);
       // Should not throw — dismissed suggestions don't block new ones
       const result = await team.suggest('Add caching');
@@ -659,7 +771,7 @@ describe('Team local suggestions', () => {
       expect(result.promotedTaskId).toBeDefined();
       expect(result.promotedTaskId).toMatch(/^task_/);
       // Verify task was added to board
-      expect(team.openTasks.some(t => t.source === `suggestion:${suggestion.id}`)).toBe(true);
+      expect(team.openTasks.some((t) => t.source === `suggestion:${suggestion.id}`)).toBe(true);
     });
 
     it('auto-dismisses when downvotes reach threshold', async () => {
@@ -733,7 +845,7 @@ describe('Team local suggestions', () => {
       const result = await team.promoteSuggestion(suggestion.id, 'Bob');
       expect(result.suggestion.status).toBe('promoted');
       expect(result.promotedTaskId).toBeDefined();
-      const task = team.openTasks.find(t => t.id === result.promotedTaskId);
+      const task = team.openTasks.find((t) => t.id === result.promotedTaskId);
       expect(task).toBeDefined();
       expect(task!.title).toBe('Build widget');
       expect(task!.description).toContain('Promoted by Bob');
@@ -756,7 +868,7 @@ describe('Team local suggestions', () => {
       const team = makeTeam();
       const { suggestion } = await team.suggest('Restructure', { category: 'architecture' });
       const result = await team.promoteSuggestion(suggestion.id);
-      const task = team.openTasks.find(t => t.id === result.promotedTaskId);
+      const task = team.openTasks.find((t) => t.id === result.promotedTaskId);
       expect(task!.priority).toBe(2);
     });
 
@@ -764,7 +876,7 @@ describe('Team local suggestions', () => {
       const team = makeTeam();
       const { suggestion } = await team.suggest('Add tests', { category: 'testing' });
       const result = await team.promoteSuggestion(suggestion.id);
-      const task = team.openTasks.find(t => t.id === result.promotedTaskId);
+      const task = team.openTasks.find((t) => t.id === result.promotedTaskId);
       expect(task!.priority).toBe(3);
     });
   });
@@ -787,8 +899,10 @@ describe('Team local suggestions', () => {
 
     it('throws on remote team', async () => {
       const team = defineTeam({
-        name: 'remote', agents: [agent1],
-        boardUrl: 'https://example.com', boardApiKey: 'key',
+        name: 'remote',
+        agents: [agent1],
+        boardUrl: 'https://example.com',
+        boardApiKey: 'key',
       });
       expect(() => team.dismissSuggestion('s1')).toThrow('not supported in remote mode');
     });
@@ -799,7 +913,8 @@ describe('Team local suggestions', () => {
 
 describe('Team mesh integration', () => {
   const agent1: AgentConfig = {
-    name: 'Coder1', role: 'coder',
+    name: 'Coder1',
+    role: 'coder',
     model: { provider: 'anthropic', model: 'claude-sonnet-4' },
     capabilities: ['code-gen', 'testing'],
     claimFilter: { roles: ['coder'], maxPriority: 8 },
@@ -822,8 +937,12 @@ describe('Team mesh integration', () => {
   it('registerPeer() + peers() returns registered peer', () => {
     const team = mkTeam();
     team.registerPeer({
-      id: 'peer-1', hostname: 'localhost', port: 3000,
-      version: '1.0.0', agentCount: 2, capabilities: ['code'],
+      id: 'peer-1',
+      hostname: 'localhost',
+      port: 3000,
+      version: '1.0.0',
+      agentCount: 2,
+      capabilities: ['code'],
       lastSeen: Date.now(),
     });
     expect(team.peers()).toHaveLength(1);

package/src/__tests__/goal-synthesizer.test.ts

@@ -142,13 +142,16 @@ describe('GoalSynthesizer', () => {
     it('filters out recently completed tasks', async () => {
       const gs = new GoalSynthesizer();
       const completed = GENERIC_GOALS.slice(0, 4);
-      const goals = await gs.synthesizeMultiple({
-        domain: 'general',
-        recentCompletedTasks: completed,
-      }, 3);
+      const goals = await gs.synthesizeMultiple(
+        {
+          domain: 'general',
+          recentCompletedTasks: completed,
+        },
+        3
+      );
       // None of the returned goals should match completed tasks
       for (const g of goals) {
-        expect(completed.map(c => c.toLowerCase())).not.toContain(g.description.toLowerCase());
+        expect(completed.map((c) => c.toLowerCase())).not.toContain(g.description.toLowerCase());
       }
     });
 
@@ -208,7 +211,7 @@ describe('GoalSynthesizer', () => {
       // Request enough goals to ensure the knowledge-derived one is included
       const goals = await gs.synthesizeMultiple({ domain: 'security' }, 15);
 
-      const knowledgeGapGoals = goals.filter(g => g.category === 'knowledge-gap');
+      const knowledgeGapGoals = goals.filter((g) => g.category === 'knowledge-gap');
       // At least one goal should be derived from the gotcha
       expect(knowledgeGapGoals.length).toBeGreaterThanOrEqual(1);
       const derived = knowledgeGapGoals[0];

package/src/__tests__/presence.test.ts

@@ -70,7 +70,7 @@ describe('Local Presence Tracking (FW-0.3)', () => {
       team.localHeartbeat('Bob', 'Task B');
       const agents = team.localPresence();
       expect(agents).toHaveLength(2);
-      const names = agents.map(a => a.name).sort();
+      const names = agents.map((a) => a.name).sort();
       expect(names).toEqual(['Alice', 'Bob']);
     });
   });

package/src/__tests__/protocol-agent.test.ts

@@ -80,7 +80,9 @@ describe('ProtocolAgent', () => {
   });
 
   it('execute phase calls LLM with full model', async () => {
-    fetchSpy.mockResolvedValue(mockFetchResponse('Fixed the authentication bug by updating JWT validation'));
+    fetchSpy.mockResolvedValue(
+      mockFetchResponse('Fixed the authentication bug by updating JWT validation')
+    );
 
     const agent = new ProtocolAgent(testAgent);
     const plan = { plan: 'Use TDD', context: { task: 'Fix auth bug' } };
@@ -101,8 +103,8 @@ describe('ProtocolAgent', () => {
     fetchSpy.mockResolvedValue(
       mockFetchResponse(
         '[wisdom] JWT tokens should be validated on every request\n' +
-        '[pattern] Use middleware for auth validation\n' +
-        '[gotcha] Never store refresh tokens in localStorage'
+          '[pattern] Use middleware for auth validation\n' +
+          '[gotcha] Never store refresh tokens in localStorage'
       )
     );
 
@@ -168,7 +170,10 @@ describe('runProtocolCycle', () => {
       // Phase 2 (execute): full model
       if (callCount === 2) return mockFetchResponse('SUMMARY: Fixed JWT validation\nDone.');
       // Phase 3 (compress): extract knowledge
-      if (callCount === 3) return mockFetchResponse('[wisdom] Always validate token expiry\n[pattern] Use middleware for auth');
+      if (callCount === 3)
+        return mockFetchResponse(
+          '[wisdom] Always validate token expiry\n[pattern] Use middleware for auth'
+        );
       // Phase 4 (reintake): validate
       if (callCount === 4) return mockFetchResponse('[wisdom] Always validate token expiry');
       // Phase 5 (grow): patterns
@@ -196,9 +201,7 @@ describe('runProtocolCycle', () => {
   });
 
   it('returns summary from execute phase even when compress finds nothing', async () => {
-    fetchSpy.mockImplementation(async () =>
-      mockFetchResponse('Completed the task successfully')
-    );
+    fetchSpy.mockImplementation(async () => mockFetchResponse('Completed the task successfully'));
 
     const result = await runProtocolCycle(
       testAgent,
@@ -218,9 +221,7 @@ describe('runProtocolCycle', () => {
       model: { provider: 'openai', model: 'gpt-4o', apiKey: 'test-key' },
     };
 
-    fetchSpy.mockImplementation(async () =>
-      mockOpenAIResponse('Task done')
-    );
+    fetchSpy.mockImplementation(async () => mockOpenAIResponse('Task done'));
 
     const result = await runProtocolCycle(
       openaiAgent,
@@ -248,7 +249,7 @@ describe('runProtocolCycle', () => {
     // Should still return a result (BaseAgent catches phase errors)
     expect(result.phaseResults.length).toBeGreaterThan(0);
     // The reflect phase should fail, which cascades
-    const reflectPhase = result.phaseResults.find(p => p.phase === ProtocolPhase.REFLECT);
+    const reflectPhase = result.phaseResults.find((p) => p.phase === ProtocolPhase.REFLECT);
     expect(reflectPhase?.status).toBe('failure');
   });
 });

package/src/__tests__/revenue-splitter.test.ts

@@ -39,10 +39,13 @@ describe('RevenueSplitter', () => {
   });
 
   it('throws on basis points not summing to 10000', () => {
-    expect(() => new RevenueSplitter([
-      { id: 'a', basisPoints: 5000 },
-      { id: 'b', basisPoints: 4000 },
-    ])).toThrow('sum to 10000');
+    expect(
+      () =>
+        new RevenueSplitter([
+          { id: 'a', basisPoints: 5000 },
+          { id: 'b', basisPoints: 4000 },
+        ])
+    ).toThrow('sum to 10000');
   });
 
   it('throws on empty recipients', () => {
@@ -50,23 +53,27 @@ describe('RevenueSplitter', () => {
   });
 
   it('throws on negative basis points', () => {
-    expect(() => new RevenueSplitter([
-      { id: 'a', basisPoints: -1000 },
-      { id: 'b', basisPoints: 11000 },
-    ])).toThrow('Negative');
+    expect(
+      () =>
+        new RevenueSplitter([
+          { id: 'a', basisPoints: -1000 },
+          { id: 'b', basisPoints: 11000 },
+        ])
+    ).toThrow('Negative');
   });
 
   it('throws on duplicate IDs', () => {
-    expect(() => new RevenueSplitter([
-      { id: 'a', basisPoints: 5000 },
-      { id: 'a', basisPoints: 5000 },
-    ])).toThrow('Duplicate');
+    expect(
+      () =>
+        new RevenueSplitter([
+          { id: 'a', basisPoints: 5000 },
+          { id: 'a', basisPoints: 5000 },
+        ])
+    ).toThrow('Duplicate');
   });
 
   it('throws on negative amount', () => {
-    const splitter = new RevenueSplitter([
-      { id: 'a', basisPoints: 10000 },
-    ]);
+    const splitter = new RevenueSplitter([{ id: 'a', basisPoints: 10000 }]);
     expect(() => splitter.split(-1n)).toThrow('negative');
   });