cognitive-core 0.1.0 → 0.2.0

package/tests/runtime/macro-agent-backend.test.ts

@@ -0,0 +1,266 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import {
+  MacroAgentBackendAdapter,
+  adaptMacroBackend,
+  createMacroAgentSource,
+  type MacroAgentBackendLike,
+  type MacroSessionLike,
+} from '../../src/runtime/backends/macro-agent.js';
+import type { AgentBackend, AgentSession } from '../../src/runtime/types.js';
+import { createTask } from '../../src/types/task.js';
+
+// ── Mock macro-agent backend ──────────────────────────────────
+
+function createMockMacroBackend(
+  overrides?: Partial<MacroAgentBackendLike>,
+): MacroAgentBackendLike {
+  const sessions = new Map<string, MacroSessionLike>();
+  let idCounter = 0;
+
+  return {
+    name: 'macro-agent',
+    supportedTypes: ['claude-code'],
+    isAvailable: vi.fn().mockResolvedValue(true),
+    spawn: vi.fn().mockImplementation(async (config: { agentType: string; task: { description: string } }) => {
+      const session: MacroSessionLike = {
+        id: `cognitive_${++idCounter}`,
+        agentType: config.agentType,
+        task: config.task,
+        state: 'running',
+        messages: [],
+        toolCalls: [],
+        startTime: new Date(),
+        metadata: { macroAgentId: `agent_${idCounter}` },
+      };
+      sessions.set(session.id, session);
+      return session;
+    }),
+    getSession: vi.fn().mockImplementation(async (id: string) => sessions.get(id)),
+    terminate: vi.fn().mockImplementation(async (id: string) => {
+      const session = sessions.get(id);
+      if (session) {
+        session.state = 'failed';
+        session.error = 'Terminated by caller';
+        session.endTime = new Date();
+      }
+    }),
+    listSessions: vi.fn().mockImplementation(async () => Array.from(sessions.values())),
+    ...overrides,
+  };
+}
+
+// ── MacroAgentBackendAdapter ──────────────────────────────────
+
+describe('MacroAgentBackendAdapter', () => {
+  let mockBackend: MacroAgentBackendLike;
+  let adapter: MacroAgentBackendAdapter;
+
+  beforeEach(() => {
+    mockBackend = createMockMacroBackend();
+    adapter = new MacroAgentBackendAdapter(mockBackend);
+  });
+
+  describe('constructor and properties', () => {
+    it('should expose name and supportedTypes from inner backend', () => {
+      expect(adapter.name).toBe('macro-agent');
+      expect(adapter.supportedTypes).toEqual(['claude-code']);
+    });
+
+    it('should copy supportedTypes (not share reference)', () => {
+      expect(adapter.supportedTypes).not.toBe(mockBackend.supportedTypes);
+    });
+  });
+
+  describe('isAvailable', () => {
+    it('should delegate to inner backend', async () => {
+      expect(await adapter.isAvailable()).toBe(true);
+      expect(mockBackend.isAvailable).toHaveBeenCalled();
+    });
+
+    it('should propagate false', async () => {
+      const backend = createMockMacroBackend({
+        isAvailable: vi.fn().mockResolvedValue(false),
+      });
+      const a = new MacroAgentBackendAdapter(backend);
+      expect(await a.isAvailable()).toBe(false);
+    });
+  });
+
+  describe('spawn', () => {
+    it('should return an AgentSession with full Task', async () => {
+      const task = createTask({
+        domain: 'analysis',
+        description: 'Analyze trajectory patterns',
+      });
+
+      const session = await adapter.spawn({ agentType: 'claude-code', task });
+
+      expect(session.id).toBeDefined();
+      expect(session.agentType).toBe('claude-code');
+      expect(session.state).toBe('running');
+      expect(session.messages).toEqual([]);
+      expect(session.toolCalls).toEqual([]);
+      // Full Task is preserved (not just CognitiveTask subset)
+      expect(session.task).toBe(task);
+      expect(session.task.id).toBe(task.id);
+      expect(session.task.domain).toBe('analysis');
+    });
+
+    it('should forward config to inner backend', async () => {
+      const task = createTask({
+        domain: 'test',
+        description: 'Test task',
+      });
+
+      await adapter.spawn({ agentType: 'claude-code', task });
+
+      expect(mockBackend.spawn).toHaveBeenCalledWith(
+        expect.objectContaining({
+          agentType: 'claude-code',
+          task: expect.objectContaining({ description: 'Test task' }),
+        }),
+      );
+    });
+
+    it('should preserve metadata from inner session', async () => {
+      const task = createTask({ domain: 'test', description: 'test' });
+      const session = await adapter.spawn({ agentType: 'claude-code', task });
+
+      expect(session.metadata.macroAgentId).toBeDefined();
+    });
+  });
+
+  describe('getSession', () => {
+    it('should return session with cached Task', async () => {
+      const task = createTask({
+        domain: 'analysis',
+        description: 'Find patterns',
+      });
+      const spawned = await adapter.spawn({ agentType: 'claude-code', task });
+
+      const retrieved = await adapter.getSession(spawned.id);
+
+      expect(retrieved).toBeDefined();
+      expect(retrieved!.id).toBe(spawned.id);
+      // Task is preserved from original spawn call
+      expect(retrieved!.task).toBe(task);
+      expect(retrieved!.task.domain).toBe('analysis');
+    });
+
+    it('should return undefined for non-existent session', async () => {
+      const result = await adapter.getSession('non-existent');
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('terminate', () => {
+    it('should delegate to inner backend', async () => {
+      const task = createTask({ domain: 'test', description: 'task' });
+      const session = await adapter.spawn({ agentType: 'claude-code', task });
+
+      await adapter.terminate(session.id);
+
+      expect(mockBackend.terminate).toHaveBeenCalledWith(session.id);
+    });
+
+    it('should reflect terminated state on subsequent getSession', async () => {
+      const task = createTask({ domain: 'test', description: 'Long task' });
+      const session = await adapter.spawn({ agentType: 'claude-code', task });
+
+      await adapter.terminate(session.id);
+
+      const updated = await adapter.getSession(session.id);
+      expect(updated?.state).toBe('failed');
+      expect(updated?.error).toBe('Terminated by caller');
+    });
+  });
+
+  describe('listSessions', () => {
+    it('should return all sessions with cached Tasks', async () => {
+      const task1 = createTask({ domain: 'test', description: 'Task 1' });
+      const task2 = createTask({ domain: 'analysis', description: 'Task 2' });
+
+      await adapter.spawn({ agentType: 'claude-code', task: task1 });
+      await adapter.spawn({ agentType: 'claude-code', task: task2 });
+
+      const sessions = await adapter.listSessions();
+
+      expect(sessions).toHaveLength(2);
+      expect(sessions[0].task.domain).toBe('test');
+      expect(sessions[1].task.domain).toBe('analysis');
+    });
+
+    it('should return empty array when no sessions', async () => {
+      const sessions = await adapter.listSessions();
+      expect(sessions).toEqual([]);
+    });
+  });
+});
+
+// ── adaptMacroBackend ─────────────────────────────────────────
+
+describe('adaptMacroBackend', () => {
+  it('should return an AgentBackend', () => {
+    const mock = createMockMacroBackend();
+    const backend = adaptMacroBackend(mock);
+
+    expect(backend.name).toBe('macro-agent');
+    expect(backend.supportedTypes).toContain('claude-code');
+    expect(typeof backend.isAvailable).toBe('function');
+    expect(typeof backend.spawn).toBe('function');
+    expect(typeof backend.getSession).toBe('function');
+    expect(typeof backend.terminate).toBe('function');
+    expect(typeof backend.listSessions).toBe('function');
+  });
+
+  it('should satisfy AgentBackend interface', async () => {
+    const mock = createMockMacroBackend();
+    const backend: AgentBackend = adaptMacroBackend(mock);
+
+    const task = createTask({ domain: 'test', description: 'verify interface' });
+    const session = await backend.spawn({ agentType: 'claude-code', task });
+
+    expect(session.id).toBeDefined();
+    expect(session.task).toBe(task);
+  });
+});
+
+// ── createMacroAgentSource ────────────────────────────────────
+
+describe('createMacroAgentSource', () => {
+  it('should create a ComputeSource with defaults', () => {
+    const mock = createMockMacroBackend();
+    const source = createMacroAgentSource(mock);
+
+    expect(source.name).toBe('macro-agent');
+    expect(source.costTier).toBe('medium');
+    expect(source.location).toBe('local');
+    expect(source.priority).toBe(50);
+    expect(source.backend).toBeDefined();
+    expect(source.backend.name).toBe('macro-agent');
+  });
+
+  it('should accept custom options', () => {
+    const mock = createMockMacroBackend();
+    const source = createMacroAgentSource(mock, {
+      costTier: 'high',
+      location: 'remote',
+      priority: 10,
+    });
+
+    expect(source.costTier).toBe('high');
+    expect(source.location).toBe('remote');
+    expect(source.priority).toBe(10);
+  });
+
+  it('should create a functional backend in the source', async () => {
+    const mock = createMockMacroBackend();
+    const source = createMacroAgentSource(mock);
+
+    expect(await source.backend.isAvailable()).toBe(true);
+
+    const task = createTask({ domain: 'test', description: 'via source' });
+    const session = await source.backend.spawn({ agentType: 'claude-code', task });
+    expect(session.task).toBe(task);
+  });
+});

package/tests/search/moe-gate.test.ts

@@ -0,0 +1,250 @@
+import { describe, it, expect } from 'vitest';
+import {
+  MoEGate,
+  extractTaskFeatures,
+  MOE_FEATURE_SIZE,
+  MOE_STRATEGIES,
+} from '../../src/search/moe-gate.js';
+
+describe('MoEGate', () => {
+  const strategies = [...MOE_STRATEGIES];
+  const featureSize = MOE_FEATURE_SIZE;
+
+  describe('gate produces valid probability distribution', () => {
+    it('should produce probabilities that sum to 1', () => {
+      const gate = new MoEGate(strategies, featureSize);
+      const features = [0.5, 0.3, 0.8, 0.6, 0.9, 1, 0, 0.2];
+
+      const probs = gate.gate(features);
+
+      let sum = 0;
+      for (const [, prob] of probs) {
+        expect(prob).toBeGreaterThanOrEqual(0);
+        expect(prob).toBeLessThanOrEqual(1);
+        sum += prob;
+      }
+      expect(sum).toBeCloseTo(1.0, 5);
+    });
+
+    it('should produce one weight per strategy', () => {
+      const gate = new MoEGate(strategies, featureSize);
+      const features = Array(featureSize).fill(0.5);
+
+      const probs = gate.gate(features);
+      expect(probs.size).toBe(strategies.length);
+
+      for (const strategy of strategies) {
+        expect(probs.has(strategy)).toBe(true);
+      }
+    });
+  });
+
+  describe('cold start produces uniform weights', () => {
+    it('should produce near-uniform weights before any updates', () => {
+      const gate = new MoEGate(strategies, featureSize);
+      const features = Array(featureSize).fill(0.5);
+
+      const probs = gate.gate(features);
+
+      const expected = 1 / strategies.length;
+      for (const [, prob] of probs) {
+        // Near-uniform (within 10% of expected)
+        expect(Math.abs(prob - expected)).toBeLessThan(0.1);
+      }
+    });
+
+    it('should not be marked as trained initially', () => {
+      const gate = new MoEGate(strategies, featureSize);
+      expect(gate.isTrained).toBe(false);
+      expect(gate.totalUpdates).toBe(0);
+    });
+  });
+
+  describe('update shifts weights toward successful strategy', () => {
+    it('should increase probability of rewarded strategy', () => {
+      const gate = new MoEGate(strategies, featureSize);
+      const features = [0.5, 0.3, 0.8, 0.6, 0.9, 1, 0, 0.2];
+
+      const before = gate.gate(features).get('direct')!;
+
+      // Repeatedly reward 'direct' strategy
+      for (let i = 0; i < 50; i++) {
+        gate.update(features, 'direct', 1.0, 0.05);
+      }
+
+      const after = gate.gate(features).get('direct')!;
+      expect(after).toBeGreaterThan(before);
+    });
+
+    it('should decrease probability of failing strategy', () => {
+      const gate = new MoEGate(strategies, featureSize);
+      const features = [0.5, 0.3, 0.8, 0.6, 0.9, 1, 0, 0.2];
+
+      // First train 'explore' to have high weight
+      for (let i = 0; i < 20; i++) {
+        gate.update(features, 'explore', 1.0, 0.05);
+      }
+      const beforeFail = gate.gate(features).get('explore')!;
+
+      // Then penalize 'explore' (reward=0)
+      for (let i = 0; i < 30; i++) {
+        gate.update(features, 'explore', 0.0, 0.05);
+      }
+      const afterFail = gate.gate(features).get('explore')!;
+
+      expect(afterFail).toBeLessThan(beforeFail);
+    });
+
+    it('should be marked as trained after updates', () => {
+      const gate = new MoEGate(strategies, featureSize);
+      gate.update(Array(featureSize).fill(0.5), 'direct', 1.0);
+      expect(gate.isTrained).toBe(true);
+      expect(gate.totalUpdates).toBe(1);
+    });
+  });
+
+  describe('repeated updates converge', () => {
+    it('should converge on the consistently rewarded strategy', () => {
+      const gate = new MoEGate(strategies, featureSize);
+      const features = [0.5, 0.3, 0.8, 0.6, 0.9, 1, 0, 0.2];
+
+      // Consistently reward 'adapt'
+      for (let i = 0; i < 100; i++) {
+        gate.update(features, 'adapt', 1.0, 0.02);
+      }
+
+      const selected = gate.selectStrategy(features);
+      expect(selected).toBe('adapt');
+    });
+  });
+
+  describe('domain-specific weights', () => {
+    it('should learn different strategies for different domains', () => {
+      const gate = new MoEGate(strategies, featureSize);
+      const features = [0.5, 0.3, 0.8, 0.6, 0.9, 1, 0, 0.2];
+
+      // TypeScript domain prefers 'direct'
+      for (let i = 0; i < 50; i++) {
+        gate.update(features, 'direct', 1.0, 0.05, 'typescript');
+      }
+
+      // Devops domain prefers 'explore'
+      for (let i = 0; i < 50; i++) {
+        gate.update(features, 'explore', 1.0, 0.05, 'devops');
+      }
+
+      const tsStrategy = gate.selectStrategy(features, 'typescript');
+      const devopsStrategy = gate.selectStrategy(features, 'devops');
+
+      expect(tsStrategy).toBe('direct');
+      expect(devopsStrategy).toBe('explore');
+    });
+  });
+
+  describe('serialization round-trips correctly', () => {
+    it('should produce identical gate output after serialization', () => {
+      const gate = new MoEGate(strategies, featureSize);
+      const features = [0.5, 0.3, 0.8, 0.6, 0.9, 1, 0, 0.2];
+
+      // Train it
+      for (let i = 0; i < 20; i++) {
+        gate.update(features, 'adapt', 1.0, 0.05);
+        gate.update(features, 'direct', 0.5, 0.05, 'typescript');
+      }
+
+      // Serialize and deserialize
+      const json = gate.toJSON();
+      const restored = MoEGate.fromJSON(json);
+
+      // Compare outputs
+      const originalProbs = gate.gate(features);
+      const restoredProbs = restored.gate(features);
+
+      for (const strategy of strategies) {
+        expect(restoredProbs.get(strategy)).toBeCloseTo(
+          originalProbs.get(strategy)!,
+          10
+        );
+      }
+
+      expect(restored.isTrained).toBe(gate.isTrained);
+      expect(restored.totalUpdates).toBe(gate.totalUpdates);
+    });
+
+    it('should preserve domain weights across serialization', () => {
+      const gate = new MoEGate(strategies, featureSize);
+      const features = [0.5, 0.3, 0.8, 0.6, 0.9, 1, 0, 0.2];
+
+      for (let i = 0; i < 30; i++) {
+        gate.update(features, 'direct', 1.0, 0.05, 'typescript');
+      }
+
+      const json = gate.toJSON();
+      const restored = MoEGate.fromJSON(json);
+
+      const originalTs = gate.gate(features, 'typescript');
+      const restoredTs = restored.gate(features, 'typescript');
+
+      for (const strategy of strategies) {
+        expect(restoredTs.get(strategy)).toBeCloseTo(
+          originalTs.get(strategy)!,
+          10
+        );
+      }
+    });
+  });
+});
+
+describe('extractTaskFeatures', () => {
+  it('should produce feature vector of correct size', () => {
+    const features = extractTaskFeatures(
+      'Fix TypeScript type error in user module',
+      { experiences: [], playbooks: [] },
+    );
+
+    expect(features).toHaveLength(MOE_FEATURE_SIZE);
+  });
+
+  it('should set bug fix indicator for bug-related tasks', () => {
+    const features = extractTaskFeatures(
+      'Fix the authentication bug in login flow',
+      { experiences: [], playbooks: [] },
+    );
+
+    expect(features[5]).toBe(1); // isBugFix
+  });
+
+  it('should set new feature indicator for implementation tasks', () => {
+    const features = extractTaskFeatures(
+      'Implement user profile page with avatar upload',
+      { experiences: [], playbooks: [] },
+    );
+
+    expect(features[6]).toBe(1); // isNewFeature
+  });
+
+  it('should reflect memory context scores', () => {
+    const features = extractTaskFeatures(
+      'Test task',
+      {
+        experiences: [{ score: 0.85 }],
+        playbooks: [{ score: 0.9, playbook: { confidence: 0.95 } }],
+      },
+    );
+
+    expect(features[2]).toBe(0.85); // best experience match
+    expect(features[3]).toBe(0.9);  // best playbook match
+    expect(features[4]).toBe(0.95); // best playbook confidence
+  });
+
+  it('should handle empty memory context', () => {
+    const features = extractTaskFeatures(
+      'Novel task',
+      { experiences: [], playbooks: [] },
+    );
+
+    expect(features[2]).toBe(0); // no experiences
+    expect(features[3]).toBe(0); // no playbooks
+    expect(features[4]).toBe(0); // no playbook confidence
+  });
+});

package/tests/search/refinement-loop.test.ts

@@ -13,6 +13,7 @@ import type { AgentSpawnConfig } from '../../src/runtime/types.js';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
+import { createSqlitePersistence } from '../../src/persistence/index.js';
 
 describe('RefinementLoop', () => {
   let tempDir: string;
@@ -20,6 +21,7 @@ describe('RefinementLoop', () => {
   let agentManager: AgentManager;
   let mockBackend: MockBackend;
   let refinementLoop: RefinementLoop;
+  let persistence: any;
 
   const createTestTask = () => createTask({
     domain: 'test',
@@ -48,7 +50,9 @@ describe('RefinementLoop', () => {
 
   beforeEach(async () => {
     tempDir = await mkdtemp(join(tmpdir(), 'refinement-loop-test-'));
-    memory = createMemorySystem(tempDir);
+    persistence = createSqlitePersistence({ baseDir: tempDir });
+    await persistence.init();
+    memory = createMemorySystem(persistence, tempDir);
     await memory.init();
 
     agentManager = createAgentManager(memory);
@@ -67,6 +71,7 @@ describe('RefinementLoop', () => {
 
   afterEach(async () => {
     await memory.close();
+    persistence.close();
     await rm(tempDir, { recursive: true, force: true });
   });
 
@@ -432,10 +437,13 @@ describe('createRefinementLoop', () => {
   let tempDir: string;
   let memory: MemorySystem;
   let agentManager: AgentManager;
+  let persistence: any;
 
   beforeEach(async () => {
     tempDir = await mkdtemp(join(tmpdir(), 'create-refinement-test-'));
-    memory = createMemorySystem(tempDir);
+    persistence = createSqlitePersistence({ baseDir: tempDir });
+    await persistence.init();
+    memory = createMemorySystem(persistence, tempDir);
     await memory.init();
     agentManager = createAgentManager(memory);
     agentManager.registerBackend(createMockBackend());
@@ -443,6 +451,7 @@ describe('createRefinementLoop', () => {
 
   afterEach(async () => {
     await memory.close();
+    persistence.close();
     await rm(tempDir, { recursive: true, force: true });
   });
 

package/tests/search/router.test.ts

@@ -7,21 +7,26 @@ import type { MetaLearner } from '../../src/learning/meta-learner.js';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
+import { createSqlitePersistence } from '../../src/persistence/index.js';
 
 describe('TaskRouter', () => {
   let tempDir: string;
   let memory: MemorySystem;
   let router: TaskRouter;
+  let persistence: any;
 
   beforeEach(async () => {
     tempDir = await mkdtemp(join(tmpdir(), 'router-test-'));
-    memory = createMemorySystem(tempDir);
+    persistence = createSqlitePersistence({ baseDir: tempDir });
+    await persistence.init();
+    memory = createMemorySystem(persistence, tempDir);
     await memory.init();
     router = createRouter(memory);
   });
 
   afterEach(async () => {
     await memory.close();
+    persistence.close();
     await rm(tempDir, { recursive: true, force: true });
   });
 
@@ -351,6 +356,76 @@ describe('TaskRouter', () => {
     });
   });
 
+  describe('MoE gate integration', () => {
+    it('should still select reasonable strategies with uninitialized gate', async () => {
+      const task = createTask({
+        domain: 'test',
+        description: 'A completely new task with no memory',
+      });
+
+      const decision = await router.route(task);
+
+      // Gate is untrained, should fall back to threshold heuristics
+      expect(decision.strategy).toBe('fallback');
+      expect(decision.appliedMetaStrategies).toBeUndefined();
+    });
+
+    it('should update gate after trajectory completion', async () => {
+      const task = createTask({
+        domain: 'typescript',
+        description: 'Fix TypeScript error in module',
+      });
+
+      const decision = await router.route(task);
+
+      // Update gate with outcome
+      router.updateGate(task, decision.memoryContext, decision.strategy, 1.0);
+
+      // Gate should now be trained
+      expect(router.getMoEGate().isTrained).toBe(true);
+      expect(router.getMoEGate().totalUpdates).toBe(1);
+    });
+
+    it('should use trained gate for routing when updates exist', async () => {
+      const features_task = createTask({
+        domain: 'typescript',
+        description: 'Fix TypeScript type error in user handler module',
+      });
+
+      // Train the gate heavily toward 'adapt' for this feature profile
+      const memoryContext = { experiences: [], playbooks: [] };
+      for (let i = 0; i < 50; i++) {
+        router.updateGate(features_task, memoryContext, 'adapt', 1.0);
+      }
+
+      const decision = await router.route(features_task);
+
+      // With a trained gate, the applied strategies should include 'moe-gate'
+      expect(decision.appliedMetaStrategies).toContain('moe-gate');
+    });
+
+    it('should persist and restore gate state', () => {
+      const task = createTask({
+        domain: 'test',
+        description: 'Persistence test task',
+      });
+      const memoryContext = { experiences: [], playbooks: [] };
+
+      // Train
+      router.updateGate(task, memoryContext, 'direct', 1.0);
+
+      // Serialize
+      const state = router.getMoEGate().toJSON();
+
+      // Load into fresh router
+      const router2 = createRouter(memory);
+      router2.loadGateState(state);
+
+      expect(router2.getMoEGate().isTrained).toBe(true);
+      expect(router2.getMoEGate().totalUpdates).toBe(1);
+    });
+  });
+
   describe('task characteristics extraction', () => {
     it('should identify bug fix tasks', async () => {
       const task = createTask({
@@ -387,15 +462,19 @@ describe('TaskRouter', () => {
 describe('createRouter', () => {
   let tempDir: string;
   let memory: MemorySystem;
+  let persistence: any;
 
   beforeEach(async () => {
     tempDir = await mkdtemp(join(tmpdir(), 'create-router-test-'));
-    memory = createMemorySystem(tempDir);
+    persistence = createSqlitePersistence({ baseDir: tempDir });
+    await persistence.init();
+    memory = createMemorySystem(persistence, tempDir);
     await memory.init();
   });
 
   afterEach(async () => {
     await memory.close();
+    persistence.close();
     await rm(tempDir, { recursive: true, force: true });
   });