@holoscript/framework 6.0.3 → 6.0.4

package/src/__tests__/scenario-driven-todo.test.ts

@@ -10,7 +10,6 @@ function mockKnowledgeStore(entries: Partial<StoredEntry>[] = []): KnowledgeStor
 }
 
 describe('Scenario-Driven Todo Generation', () => {
-  
   it('Scenario 1: High Network Latency/Timeout generates DevOps/Performance todos', async () => {
     // Injecting a gotcha about network lag into the knowledge store
     const store = mockKnowledgeStore([
@@ -37,30 +36,35 @@ describe('Scenario-Driven Todo Generation', () => {
         reuseCount: 0,
         createdAt: new Date().toISOString(),
         authorAgent: 'monitor-agent',
-      }
+      },
     ]);
-    
+
     const synthesizer = new GoalSynthesizer({ knowledge: store });
-    
+
     const performanceTodos = await synthesizer.synthesizeMultiple({ domain: 'performance' }, 50);
     const devopsTodos = await synthesizer.synthesizeMultiple({ domain: 'devops' }, 50);
-    
+
     // Performance agent should prioritize the dropping packets bug
-    expect(performanceTodos.some(t => t.category === 'knowledge-gap')).toBe(true);
-    expect(performanceTodos.some(t => t.description.includes('gossip sync consistently dropping'))).toBe(true);
+    expect(performanceTodos.some((t) => t.category === 'knowledge-gap')).toBe(true);
+    expect(
+      performanceTodos.some((t) => t.description.includes('gossip sync consistently dropping'))
+    ).toBe(true);
 
     // DevOps agent should look at telemetry reporting issues
-    expect(devopsTodos.some(t => t.category === 'knowledge-gap')).toBe(true);
-    expect(devopsTodos.some(t => t.description.includes('Unbounded memory growth'))).toBe(true);
+    expect(devopsTodos.some((t) => t.category === 'knowledge-gap')).toBe(true);
+    expect(devopsTodos.some((t) => t.description.includes('Unbounded memory growth'))).toBe(true);
   });
 
   it('Scenario 2: Team switches to "Testing" mode after major logic refactoring', async () => {
     const synthesizer = new GoalSynthesizer();
     // In "testing" mode with no specific recent knowledge, should yield pure heuristic testing goals
     const testingTodos = await synthesizer.synthesizeMultiple({ domain: 'testing' }, 4);
-    
+
     expect(testingTodos.length).toBe(4);
-    const allowed = new Set([...DOMAIN_GOALS['testing'], ...DOMAIN_GOALS['performance'], ...DOMAIN_GOALS['devops'],
+    const allowed = new Set([
+      ...DOMAIN_GOALS['testing'],
+      ...DOMAIN_GOALS['performance'],
+      ...DOMAIN_GOALS['devops'],
       'Analyze accumulated wisdom for contradictions',
       'Refactor internal pattern database for efficiency',
       'Explore adjacent domain knowledge',
@@ -70,22 +74,29 @@ describe('Scenario-Driven Todo Generation', () => {
       'Optimize internal decision weights',
       'Study historical logs for anomaly detection',
     ]);
-    expect(testingTodos.every(t => allowed.has(t.description) || t.description.startsWith('Investigate and resolve:'))).toBe(true);
+    expect(
+      testingTodos.every(
+        (t) => allowed.has(t.description) || t.description.startsWith('Investigate and resolve:')
+      )
+    ).toBe(true);
   });
 
   it('Scenario 3: Architecture re-evaluates service bounds based off system-mandated source', async () => {
     const synthesizer = new GoalSynthesizer();
-    
+
     // Simulate legacy synchronous call
     const architectGoal = synthesizer.synthesize('architecture', 'system-mandate');
-    
+
     expect(architectGoal).toBeDefined();
     expect(architectGoal.source).toBe('system-mandate');
     expect(['knowledge-gap', 'self-improvement']).toContain(architectGoal.category);
-    
+
     // The description should match an architecture domain or generic fallback
     const archDomains = DOMAIN_GOALS['architecture'];
-    expect(archDomains.includes(architectGoal.description) || GENERIC_GOALS.includes(architectGoal.description)).toBeTruthy();
+    expect(
+      archDomains.includes(architectGoal.description) ||
+        GENERIC_GOALS.includes(architectGoal.description)
+    ).toBeTruthy();
   });
 
   it('Scenario 4: Security agent triages code injection vulnerability knowledge', async () => {
@@ -101,33 +112,37 @@ describe('Scenario-Driven Todo Generation', () => {
         reuseCount: 0,
         createdAt: new Date().toISOString(),
         authorAgent: 'security-scanner',
-      }
+      },
     ]);
-    
+
     const synthesizer = new GoalSynthesizer({ knowledge: store });
     const secTodos = await synthesizer.synthesizeMultiple({ domain: 'security' }, 50);
 
-    expect(secTodos.some(t => t.description.includes('CRDT delta payloads bypassing type serialization'))).toBe(true);
+    expect(
+      secTodos.some((t) =>
+        t.description.includes('CRDT delta payloads bypassing type serialization')
+      )
+    ).toBe(true);
     // Security agent should rank the injection gotcha with high priority
-    const injectionTodo = secTodos.find(t => t.description.includes('CRDT delta'));
+    const injectionTodo = secTodos.find((t) => t.description.includes('CRDT delta'));
     expect(injectionTodo?.category).toBe('knowledge-gap');
   });
 
   it('Scenario 5: Goal Synthesizer todos are successfully converted and pushed to the Team board', async () => {
     // We can isolate the goal-to-task pipeline
     const synthesizer = new GoalSynthesizer();
-    
+
     // Synthesize some tasks for testing
     const newGoals = await synthesizer.synthesizeMultiple({ domain: 'performance' }, 3);
-    
+
     // Convert to board tasks structure
-    const tasksToSubmit = newGoals.map(goal => ({
+    const tasksToSubmit = newGoals.map((goal) => ({
       title: goal.description,
       description: `[Auto-Synthesized] Rationale: ${goal.rationale}\nRelevance: ${goal.relevanceScore}`,
       priority: goal.priority === 'high' ? 1 : goal.priority === 'medium' ? 2 : 3,
-      source: `synthesizer:${goal.id}`
+      source: `synthesizer:${goal.id}`,
     }));
-    
+
     // Verify valid schema
     expect(tasksToSubmit.length).toBe(3);
     expect(tasksToSubmit[0].title).toBeDefined();
@@ -142,21 +157,23 @@ describe('Scenario-Driven Todo Generation', () => {
         type: 'gotcha',
         content: 'Neural Streaming data formats changing rapidly without backward compatibility',
         domain: 'research',
-        confidence: 0.90,
+        confidence: 0.9,
         source: 'external',
         queryCount: 0,
         reuseCount: 0,
         createdAt: new Date().toISOString(),
         authorAgent: 'researcher-agent',
-      }
+      },
     ]);
-    
+
     const synthesizer = new GoalSynthesizer({ knowledge: store });
     const researchTodos = await synthesizer.synthesizeMultiple({ domain: 'research' }, 50);
 
-    expect(researchTodos.some(t => t.description.includes('Neural Streaming'))).toBe(true);
+    expect(researchTodos.some((t) => t.description.includes('Neural Streaming'))).toBe(true);
     // At least one task should fall back to general heuristic if we asked for higher count
-    const hasHeuristic = researchTodos.some(t => DOMAIN_GOALS['research'].includes(t.description));
+    const hasHeuristic = researchTodos.some((t) =>
+      DOMAIN_GOALS['research'].includes(t.description)
+    );
     expect(hasHeuristic).toBe(true);
   });
 
@@ -173,23 +190,26 @@ describe('Scenario-Driven Todo Generation', () => {
         reuseCount: 1,
         createdAt: new Date().toISOString(),
         authorAgent: 'dev-agent',
-      }
+      },
     ]);
-    
+
     const synthesizer = new GoalSynthesizer({ knowledge: store });
     const codingTodos = await synthesizer.synthesizeMultiple({ domain: 'coding' }, 50);
 
     // Should prioritize the urgent deprecation / silent failure bug
-    expect(codingTodos.some(t => t.description.includes('UnhandledPromiseRejection')) || codingTodos.some(t => t.description.includes('V1 Mesh APIs'))).toBe(true);
+    expect(
+      codingTodos.some((t) => t.description.includes('UnhandledPromiseRejection')) ||
+        codingTodos.some((t) => t.description.includes('V1 Mesh APIs'))
+    ).toBe(true);
   });
 
   it('Scenario 8: Reviewer agent generates task based on heuristic fallback', async () => {
     const synthesizer = new GoalSynthesizer();
     const reviewerTodos = await synthesizer.synthesizeMultiple({ domain: 'reviewer' }, 4);
-    
+
     expect(reviewerTodos.length).toBe(4);
     const allExpectedDomains = DOMAIN_GOALS['reviewer'];
-    const hasReviewerHeuristic = reviewerTodos.some(t => 
+    const hasReviewerHeuristic = reviewerTodos.some((t) =>
       allExpectedDomains.includes(t.description)
     );
     expect(hasReviewerHeuristic).toBe(true);

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

@@ -56,9 +56,7 @@ describe('FrameworkAbsorber', () => {
     mockFetch.mockResolvedValueOnce({
       ok: true,
       json: async () => ({
-        results: [
-          { type: 'gotcha', content: 'Test gotcha', metadata: { domain: 'framework' } },
-        ],
+        results: [{ type: 'gotcha', content: 'Test gotcha', metadata: { domain: 'framework' } }],
       }),
     });
 
@@ -77,7 +75,16 @@ describe('FrameworkAbsorber', () => {
       ok: true,
       json: async () => ({
         result: {
-          content: [{ type: 'text', text: JSON.stringify({ file_count: 42, edge_count: 100, modules: ['core', 'self-improve'] }) }],
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({
+                file_count: 42,
+                edge_count: 100,
+                modules: ['core', 'self-improve'],
+              }),
+            },
+          ],
         },
       }),
     });
@@ -110,8 +117,16 @@ describe('FrameworkAbsorber', () => {
       ok: true,
       json: async () => ({
         results: [
-          { type: 'gotcha', content: 'Missing test coverage for X', metadata: { domain: 'framework', confidence: 0.8 } },
-          { type: 'pattern', content: 'Use dependency injection', metadata: { domain: 'architecture' } },
+          {
+            type: 'gotcha',
+            content: 'Missing test coverage for X',
+            metadata: { domain: 'framework', confidence: 0.8 },
+          },
+          {
+            type: 'pattern',
+            content: 'Use dependency injection',
+            metadata: { domain: 'architecture' },
+          },
         ],
       }),
     });
@@ -286,7 +301,11 @@ describe('PromptOptimizer', () => {
   it('handles judge failures gracefully (neutral score)', async () => {
     mockedCallLLM.mockImplementation(async (_config, messages) => {
       // Judge prompt contains "Score the following"
-      const isJudge = messages.some(m => m.content.includes('Score the following') || m.content.includes('prompt quality evaluator'));
+      const isJudge = messages.some(
+        (m) =>
+          m.content.includes('Score the following') ||
+          m.content.includes('prompt quality evaluator')
+      );
       if (isJudge) {
         throw new Error('LLM quota exceeded');
       }
@@ -310,12 +329,12 @@ describe('PromptOptimizer', () => {
   it('reports correct variant scores', async () => {
     // Make variant A consistently better than variant B
     mockedCallLLM.mockImplementation(async (_config, messages) => {
-      const systemMsg = messages.find(m => m.role === 'system');
+      const systemMsg = messages.find((m) => m.role === 'system');
       const isJudge = systemMsg?.content.includes('prompt quality evaluator');
 
       if (isJudge) {
         // Check if the response being judged is from variant A or B
-        const userMsg = messages.find(m => m.role === 'user');
+        const userMsg = messages.find((m) => m.role === 'user');
         const isVariantA = userMsg?.content.includes('Great response from A');
         return {
           content: JSON.stringify({

package/src/__tests__/service-lifecycle.test.ts

@@ -148,7 +148,9 @@ describe('ServiceError', () => {
   });
 
   it('carries optional details', () => {
-    const err = new ServiceError(ServiceErrorCode.VALIDATION_ERROR, 'bad input', 400, { field: 'name' });
+    const err = new ServiceError(ServiceErrorCode.VALIDATION_ERROR, 'bad input', 400, {
+      field: 'name',
+    });
     expect(err.details).toEqual({ field: 'name' });
   });
 });
@@ -164,8 +166,12 @@ describe('ServiceManager', () => {
       constructor(name: string) {
         super({ name, version: '1.0.0', description: name });
       }
-      protected override async onInit() { order.push(`init:${this.getMetadata().name}`); }
-      protected override async onStop() { order.push(`stop:${this.getMetadata().name}`); }
+      protected override async onInit() {
+        order.push(`init:${this.getMetadata().name}`);
+      }
+      protected override async onStop() {
+        order.push(`stop:${this.getMetadata().name}`);
+      }
     }
 
     const mgr = new ServiceManager();

package/src/__tests__/skill-router.test.ts

@@ -67,7 +67,7 @@ describe('SkillRouter', () => {
     const task = makeTask({ priority: 7 });
     // Reviewer has maxPriority 5, so should be filtered out
     const result = router.route(task, agents);
-    expect(result.candidates.find(c => c.agent.name === 'Reviewer')).toBeUndefined();
+    expect(result.candidates.find((c) => c.agent.name === 'Reviewer')).toBeUndefined();
   });
 
   it('scores role match bonus', () => {
@@ -76,7 +76,7 @@ describe('SkillRouter', () => {
       role: 'reviewer',
     });
     const result = router.route(task, agents);
-    const reviewerCandidate = result.candidates.find(c => c.agent.name === 'Reviewer');
+    const reviewerCandidate = result.candidates.find((c) => c.agent.name === 'Reviewer');
     expect(reviewerCandidate?.roleMatch).toBe(true);
   });
 
@@ -114,7 +114,7 @@ describe('SkillRouter', () => {
   it('tracks matched capabilities in result', () => {
     const task = makeTask({ title: 'Fix the parser bug in typescript' });
     const result = router.route(task, agents);
-    const coderCandidate = result.candidates.find(c => c.agent.name === 'Coder');
+    const coderCandidate = result.candidates.find((c) => c.agent.name === 'Coder');
     expect(coderCandidate?.matchedCapabilities).toContain('parser');
     expect(coderCandidate?.matchedCapabilities).toContain('typescript');
   });

package/src/agents/CulturalMemory.ts

@@ -50,7 +50,7 @@ export interface StigmergicTrace {
   /** Creator */
   creatorId: string;
   /** Spatial position */
-  position: { x: number; y: number; z: number };
+  position: [number, number, number];
   /** Zone the trace belongs to */
   zoneId: string;
   /** Type of trace */
@@ -209,7 +209,7 @@ export class CulturalMemory {
     creatorId: string,
     zoneId: string,
     label: string,
-    position: { x: number; y: number; z: number },
+    position: [number, number, number],
     opts: Partial<
       Omit<
         StigmergicTrace,
@@ -249,13 +249,13 @@ export class CulturalMemory {
   /**
    * Perceive nearby traces from a position.
    */
-  perceiveTraces(zoneId: string, position: { x: number; y: number; z: number }): StigmergicTrace[] {
+  perceiveTraces(zoneId: string, position: [number, number, number]): StigmergicTrace[] {
     const traces = this.stigmergic.get(zoneId) || [];
     return traces
       .filter((t) => {
-        const dx = t.position.x - position.x;
-        const dy = t.position.y - position.y;
-        const dz = t.position.z - position.z;
+        const dx = t.position[0] - position[0];
+        const dy = t.position[1] - position[1];
+        const dz = t.position[2] - position[2];
         const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
         return dist <= t.radius && t.intensity > 0.01;
       })