@holoscript/framework 6.0.3 → 6.0.4

package/src/self-improve/index.ts

@@ -19,11 +19,7 @@ export {
   scanTodos,
 } from './absorb-scanner';
 
-export {
-  type EvolutionConfig,
-  type EvolutionResult,
-  evolve,
-} from './evolution-engine';
+export { type EvolutionConfig, type EvolutionResult, evolve } from './evolution-engine';
 
 // FW-1.0: Class-based absorb integration
 export {
@@ -34,11 +30,7 @@ export {
 } from './framework-absorber';
 
 // FW-1.0: Auto-test generation via LLM
-export {
-  TestGenerator,
-  type TestGeneratorConfig,
-  type GeneratedTest,
-} from './test-generator';
+export { TestGenerator, type TestGeneratorConfig, type GeneratedTest } from './test-generator';
 
 // FW-1.0: Prompt optimization via A/B testing
 export {

package/src/self-improve/prompt-optimizer.ts

@@ -126,7 +126,11 @@ export class PromptOptimizer {
   /**
    * Run a single variant N times and evaluate.
    */
-  private async runVariant(prompt: string, task: string, runs: number): Promise<PromptVariantResult> {
+  private async runVariant(
+    prompt: string,
+    task: string,
+    runs: number
+  ): Promise<PromptVariantResult> {
     const responses: string[] = [];
     const scores: number[] = [];
     let totalTokens = 0;
@@ -134,13 +138,17 @@ export class PromptOptimizer {
 
     for (let i = 0; i < runs; i++) {
       const start = Date.now();
-      const response = await callLLM(this.config.model, [
-        { role: 'system', content: prompt },
-        { role: 'user', content: task },
-      ], {
-        maxTokens: this.config.maxTokens,
-        temperature: this.config.temperature,
-      });
+      const response = await callLLM(
+        this.config.model,
+        [
+          { role: 'system', content: prompt },
+          { role: 'user', content: task },
+        ],
+        {
+          maxTokens: this.config.maxTokens,
+          temperature: this.config.temperature,
+        }
+      );
       const latency = Date.now() - start;
 
       responses.push(response.content);
@@ -170,17 +178,21 @@ export class PromptOptimizer {
     const criteria = this.config.criteria!;
 
     try {
-      const judgeResponse = await callLLM(this.config.model, [
-        { role: 'system', content: JUDGE_SYSTEM },
-        {
-          role: 'user',
-          content: [
-            `Task: ${task}`,
-            `Response: ${response}`,
-            `Criteria: ${criteria.map(c => `${c.name} (${c.description})`).join(', ')}`,
-          ].join('\n'),
-        },
-      ], { maxTokens: 200, temperature: 0 });
+      const judgeResponse = await callLLM(
+        this.config.model,
+        [
+          { role: 'system', content: JUDGE_SYSTEM },
+          {
+            role: 'user',
+            content: [
+              `Task: ${task}`,
+              `Response: ${response}`,
+              `Criteria: ${criteria.map((c) => `${c.name} (${c.description})`).join(', ')}`,
+            ].join('\n'),
+          },
+        ],
+        { maxTokens: 200, temperature: 0 }
+      );
 
       const parsed = JSON.parse(judgeResponse.content) as Record<string, number>;
       let weightedSum = 0;

package/src/self-improve/test-generator.ts

@@ -52,7 +52,7 @@ Use import { describe, it, expect, vi } from 'vitest';`;
 
 const JEST_SYSTEM_PROMPT = SYSTEM_PROMPT.replace(
   "import { describe, it, expect, vi } from 'vitest';",
-  "Use jest globals (describe, it, expect, jest)."
+  'Use jest globals (describe, it, expect, jest).'
 );
 
 /**
@@ -95,9 +95,7 @@ export class TestGenerator {
     const fileName = basename(absPath, '.ts');
     const dir = dirname(absPath);
 
-    const systemPrompt = this.config.testFramework === 'jest'
-      ? JEST_SYSTEM_PROMPT
-      : SYSTEM_PROMPT;
+    const systemPrompt = this.config.testFramework === 'jest' ? JEST_SYSTEM_PROMPT : SYSTEM_PROMPT;
 
     const userPrompt = [
       `Generate tests for this TypeScript file: ${basename(absPath)}`,
@@ -105,16 +103,22 @@ export class TestGenerator {
       '```typescript',
       source,
       '```',
-      this.config.additionalContext ? `\nAdditional context:\n${this.config.additionalContext}` : '',
+      this.config.additionalContext
+        ? `\nAdditional context:\n${this.config.additionalContext}`
+        : '',
     ].join('\n');
 
-    const response = await callLLM(this.config.model, [
-      { role: 'system', content: systemPrompt },
-      { role: 'user', content: userPrompt },
-    ], {
-      maxTokens: this.config.maxTokens,
-      temperature: this.config.temperature,
-    });
+    const response = await callLLM(
+      this.config.model,
+      [
+        { role: 'system', content: systemPrompt },
+        { role: 'user', content: userPrompt },
+      ],
+      {
+        maxTokens: this.config.maxTokens,
+        temperature: this.config.temperature,
+      }
+    );
 
     const testContent = cleanTestOutput(response.content);
     const testCount = countTestCases(testContent);

package/src/skill-router.ts

@@ -84,9 +84,9 @@ export class SkillRouter {
 
     for (const agent of agents) {
       // Check required capabilities
-      const agentCaps = new Set(agent.capabilities.map(c => c.toLowerCase()));
+      const agentCaps = new Set(agent.capabilities.map((c) => c.toLowerCase()));
       if (p.requiredCapabilities.length > 0) {
-        const hasAll = p.requiredCapabilities.every(rc => agentCaps.has(rc.toLowerCase()));
+        const hasAll = p.requiredCapabilities.every((rc) => agentCaps.has(rc.toLowerCase()));
         if (!hasAll) continue;
       }
 
@@ -128,16 +128,17 @@ export class SkillRouter {
     candidates.sort((a, b) => b.score - a.score);
 
     // Apply minimum threshold
-    const eligible = candidates.filter(c => c.score >= p.minScore);
+    const eligible = candidates.filter((c) => c.score >= p.minScore);
 
     if (eligible.length === 0) {
       return {
         agent: null,
         score: 0,
         candidates,
-        reason: candidates.length > 0
-          ? `${candidates.length} candidates scored below minimum threshold (${p.minScore})`
-          : 'No candidates matched task requirements',
+        reason:
+          candidates.length > 0
+            ? `${candidates.length} candidates scored below minimum threshold (${p.minScore})`
+            : 'No candidates matched task requirements',
       };
     }
 

package/src/swarm/messaging/GossipProtocol.ts

@@ -383,7 +383,7 @@ export class GossipProtocol {
         }
       }
     }
-    
+
     // Wait for any async promises to complete (but don't block synchronous callers)
     if (promises.length > 0) {
       Promise.all(promises).catch(() => {});

package/src/swarm/messaging/__tests__/BroadcastChannel.prod.test.ts

@@ -78,7 +78,9 @@ describe('BroadcastChannel — broadcast', () => {
   it('delivers to subscriber', async () => {
     const received: unknown[] = [];
     const c = makeCh();
-    c.subscribe('a1', (m) => { received.push((m as any).content); });
+    c.subscribe('a1', (m) => {
+      received.push((m as any).content);
+    });
     await c.broadcast('sender', 'hello');
     expect(received).toHaveLength(1);
     expect(received[0]).toBe('hello');
@@ -86,15 +88,25 @@ describe('BroadcastChannel — broadcast', () => {
   it('delivered to all subscribers', async () => {
     const received: unknown[] = [];
     const c = makeCh();
-    c.subscribe('a1', (m) => { received.push(m); });
-    c.subscribe('a2', (m) => { received.push(m); });
+    c.subscribe('a1', (m) => {
+      received.push(m);
+    });
+    c.subscribe('a2', (m) => {
+      received.push(m);
+    });
     await c.broadcast('sender', 'hi');
     expect(received).toHaveLength(2);
   });
   it('publisher-role subscriber does not receive', async () => {
     const received: unknown[] = [];
     const c = makeCh();
-    c.subscribe('a1', (m) => { received.push('a1', m); }, { role: 'publisher' });
+    c.subscribe(
+      'a1',
+      (m) => {
+        received.push('a1', m);
+      },
+      { role: 'publisher' }
+    );
     await c.broadcast('sender', 'hi');
     expect(received).toHaveLength(0);
   });
@@ -122,8 +134,12 @@ describe('BroadcastChannel — sendDirect', () => {
   it('delivers only to target', async () => {
     const received: string[] = [];
     const c = makeCh();
-    c.subscribe('a1', () => { received.push('a1'); });
-    c.subscribe('a2', () => { received.push('a2'); });
+    c.subscribe('a1', () => {
+      received.push('a1');
+    });
+    c.subscribe('a2', () => {
+      received.push('a2');
+    });
     await c.sendDirect('sender', 'a1', 'dm');
     expect(received).toHaveLength(1);
     expect(received[0]).toBe('a1');
@@ -213,7 +229,9 @@ describe('BroadcastChannel — replayHistory', () => {
     const c = makeCh();
     await c.broadcast('s', '1');
     await c.broadcast('s', '2');
-    const subId = c.subscribe('a1', (m) => { received.push(m); });
+    const subId = c.subscribe('a1', (m) => {
+      received.push(m);
+    });
     const count = await c.replayHistory(subId);
     expect(count).toBe(2);
     expect(received).toHaveLength(2);
@@ -316,8 +334,12 @@ describe('ChannelManager — multicast', () => {
     const c1 = m.createChannel('c1');
     const c2 = m.createChannel('c2');
     const received: string[] = [];
-    m.subscribeAgent('a1', c1.id, () => { received.push('c1'); });
-    m.subscribeAgent('a2', c2.id, () => { received.push('c2'); });
+    m.subscribeAgent('a1', c1.id, () => {
+      received.push('c1');
+    });
+    m.subscribeAgent('a2', c2.id, () => {
+      received.push('c2');
+    });
     const results = await m.multicast([c1.id, c2.id], 'sender', 'msg');
     expect(results.size).toBe(2);
     expect(received).toHaveLength(2);

package/src/swarm/messaging/__tests__/GossipProtocol.prod.test.ts

@@ -127,7 +127,9 @@ describe('GossipProtocol — publish', () => {
   it('publish calls type-specific handler synchronously', () => {
     const n = mkNode();
     const received: IGossipMessage[] = [];
-    n.subscribe('data', (msg) => { received.push(msg); });
+    n.subscribe('data', (msg) => {
+      received.push(msg);
+    });
     n.publish({ v: 42 }, 'data');
     expect(received).toHaveLength(1);
     expect((received[0].content as any).v).toBe(42);
@@ -135,21 +137,27 @@ describe('GossipProtocol — publish', () => {
   it('publish calls wildcard handler', () => {
     const n = mkNode();
     const received: IGossipMessage[] = [];
-    n.subscribe('*', (msg) => { received.push(msg); });
+    n.subscribe('*', (msg) => {
+      received.push(msg);
+    });
     n.publish({ v: 1 }, 'heartbeat');
     expect(received).toHaveLength(1);
   });
   it('publishHeartbeat uses type=heartbeat', () => {
     const n = mkNode();
     const received: IGossipMessage[] = [];
-    n.subscribe('heartbeat', (msg) => { received.push(msg); });
+    n.subscribe('heartbeat', (msg) => {
+      received.push(msg);
+    });
     n.publishHeartbeat();
     expect(received).toHaveLength(1);
   });
   it('publishMembership uses type=membership', () => {
     const n = mkNode();
     const received: IGossipMessage[] = [];
-    n.subscribe('membership', (msg) => { received.push(msg); });
+    n.subscribe('membership', (msg) => {
+      received.push(msg);
+    });
     n.publishMembership('join');
     expect(received).toHaveLength(1);
   });
@@ -189,7 +197,9 @@ describe('GossipProtocol — receive', () => {
   it('receive calls handler', async () => {
     const n = mkNode();
     const received: any[] = [];
-    n.subscribe('data', (msg) => { received.push(msg); });
+    n.subscribe('data', (msg) => {
+      received.push(msg);
+    });
     await n.receive(mkMsg({ type: 'data' }), 'peer');
     expect(received).toHaveLength(1);
   });
@@ -218,7 +228,9 @@ describe('GossipProtocol — subscribe / unsubscribe', () => {
   it('unsubscribe stops future deliveries', () => {
     const n = mkNode();
     const calls: number[] = [];
-    const unsub = n.subscribe('data', () => { calls.push(1); });
+    const unsub = n.subscribe('data', () => {
+      calls.push(1);
+    });
     n.publish({ x: 1 }, 'data');
     unsub();
     n.publish({ x: 2 }, 'data');
@@ -227,7 +239,9 @@ describe('GossipProtocol — subscribe / unsubscribe', () => {
   it('wildcard receives all message types', async () => {
     const n = mkNode();
     const types: string[] = [];
-    n.subscribe('*', (msg) => { types.push(msg.type); });
+    n.subscribe('*', (msg) => {
+      types.push(msg.type);
+    });
     n.publish({}, 'data');
     n.publish({}, 'heartbeat');
     n.publish({}, 'membership');

package/src/swarm/messaging/__tests__/SwarmEventBus.prod.test.ts

@@ -82,7 +82,9 @@ describe('SwarmEventBus — emit (synchronous)', () => {
   it('delivers synchronously to matching subscriber', () => {
     let received: unknown[] = [];
     const bus = make();
-    bus.subscribe('evt.ping', (e) => { received.push(e.payload); });
+    bus.subscribe('evt.ping', (e) => {
+      received.push(e.payload);
+    });
     bus.emit('evt.ping', 'src', { val: 42 });
     expect(received).toHaveLength(1);
     expect((received[0] as any).val).toBe(42);
@@ -90,14 +92,18 @@ describe('SwarmEventBus — emit (synchronous)', () => {
   it('does not deliver to non-matching subscriber', () => {
     let received: unknown[] = [];
     const bus = make();
-    bus.subscribe('other', (e) => { received.push(e.payload); });
+    bus.subscribe('other', (e) => {
+      received.push(e.payload);
+    });
     bus.emit('evt.ping', 'src', {});
     expect(received).toHaveLength(0);
   });
   it('wildcard pattern matches', () => {
     let received: unknown[] = [];
     const bus = make();
-    bus.subscribe('swarm.*', (e) => { received.push(e.payload); });
+    bus.subscribe('swarm.*', (e) => {
+      received.push(e.payload);
+    });
     bus.emit('swarm.joined', 'src', {});
     bus.emit('swarm.left', 'src', {});
     expect(received).toHaveLength(2);
@@ -105,7 +111,9 @@ describe('SwarmEventBus — emit (synchronous)', () => {
   it('regex pattern matches', () => {
     let received: unknown[] = [];
     const bus = make();
-    bus.subscribe(/^agent\./, (e) => { received.push(e.payload); });
+    bus.subscribe(/^agent\./, (e) => {
+      received.push(e.payload);
+    });
     bus.emit('agent.spawn', 'src', {});
     bus.emit('agent.destroy', 'src', {});
     bus.emit('other.event', 'src', {});
@@ -114,7 +122,9 @@ describe('SwarmEventBus — emit (synchronous)', () => {
   it('exact match only', () => {
     let received: unknown[] = [];
     const bus = make();
-    bus.subscribe('exact', (e) => { received.push(e.payload); });
+    bus.subscribe('exact', (e) => {
+      received.push(e.payload);
+    });
     bus.emit('exact.extended', 'src', {});
     expect(received).toHaveLength(0);
   });
@@ -124,7 +134,9 @@ describe('SwarmEventBus — processQueue', () => {
   it('delivers events to subscribers', async () => {
     let received: unknown[] = [];
     const bus = make({ asyncProcessing: false });
-    bus.subscribe('greet', (e) => { received.push(e.payload); });
+    bus.subscribe('greet', (e) => {
+      received.push(e.payload);
+    });
     bus.publish('greet', 'src', 'hello');
     await bus.processQueue();
     expect(received).toHaveLength(1);
@@ -132,7 +144,9 @@ describe('SwarmEventBus — processQueue', () => {
   it('skips expired TTL events', async () => {
     let received: unknown[] = [];
     const bus = make({ asyncProcessing: false, defaultTTL: 1 });
-    bus.subscribe('late', (e) => { received.push(e.payload); });
+    bus.subscribe('late', (e) => {
+      received.push(e.payload);
+    });
     bus.publish('late', 'src', {}, { ttl: 1 });
     await new Promise((r) => setTimeout(r, 5)); // let TTL expire
     await bus.processQueue();
@@ -168,7 +182,9 @@ describe('SwarmEventBus — dead letter / replay', () => {
     const bus = make({ asyncProcessing: false });
     bus.publish('retry', 'src', 'payload');
     await bus.processQueue(); // to DLQ
-    bus.subscribe('retry', (e) => { received.push(e.payload); });
+    bus.subscribe('retry', (e) => {
+      received.push(e.payload);
+    });
     bus.replayDeadLetters();
     await bus.processQueue();
     expect(received).toContain('payload');

package/src/swarm/messaging/__tests__/SwarmEventBus.test.ts

@@ -102,11 +102,15 @@ describe('SwarmEventBus', () => {
     it('should process critical events by priority order', async () => {
       const order: string[] = [];
 
-      bus.subscribe('event', (e: any) => { order.push(e.priority); });
+      bus.subscribe('event', (e: any) => {
+        order.push(e.priority);
+      });
 
       // Use publish with asyncProcessing: false - events are queued by priority
       const asyncBus = new SwarmEventBus({ asyncProcessing: true });
-      asyncBus.subscribe('event', (e: any) => { order.push(e.priority); });
+      asyncBus.subscribe('event', (e: any) => {
+        order.push(e.priority);
+      });
 
       // Emit directly for synchronous test
       bus.emit('event', 'a', {}, { priority: 'low' });