cognitive-core 0.1.2 → 0.2.0

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 });
   });
 

package/tests/session-bank/fixtures/sessionlog-root-metadata.json

@@ -0,0 +1,16 @@
+{
+  "cliVersion": "opentasks-sessionlog",
+  "checkpointID": "c4d5e6f7a8b9",
+  "strategy": "manual-commit",
+  "branch": "main",
+  "checkpointsCount": 3,
+  "filesTouched": ["src/api.ts", "tests/api.test.ts"],
+  "sessions": [
+    {
+      "metadata": "1/metadata.json",
+      "transcript": "1/full.jsonl",
+      "context": "1/context.md",
+      "prompt": "1/prompt.txt"
+    }
+  ]
+}

package/tests/session-bank/fixtures/sessionlog-session/full.jsonl

@@ -0,0 +1,6 @@
+{"type":"user","uuid":"msg-sl-001","message":{"content":"Add input validation to the API endpoint using Zod"}}
+{"type":"assistant","uuid":"msg-sl-002","message":{"content":[{"type":"text","text":"I'll examine the API endpoint first."},{"type":"tool_use","id":"tool-sl-001","name":"Read","input":{"file_path":"/src/api.ts"}}]}}
+{"type":"user","uuid":"msg-sl-003","message":{"content":[{"type":"tool_result","tool_use_id":"tool-sl-001","content":"export function handler(req, res) {\n  const body = req.body;\n  // TODO: validate\n  res.json({ ok: true });\n}"}]}}
+{"type":"assistant","uuid":"msg-sl-004","message":{"content":[{"type":"text","text":"I'll add Zod validation."},{"type":"tool_use","id":"tool-sl-002","name":"Edit","input":{"file_path":"/src/api.ts","old_string":"const body = req.body;","new_string":"const body = schema.parse(req.body);"}}]}}
+{"type":"user","uuid":"msg-sl-005","message":{"content":[{"type":"tool_result","tool_use_id":"tool-sl-002","content":"File edited successfully"}]}}
+{"type":"assistant","uuid":"msg-sl-006","message":{"content":[{"type":"text","text":"Validation added. The endpoint now validates input using the Zod schema before processing."}]}}

package/tests/session-bank/fixtures/sessionlog-session/metadata.json

@@ -0,0 +1,55 @@
+{
+  "cliVersion": "opentasks-sessionlog",
+  "checkpointID": "c4d5e6f7a8b9",
+  "sessionID": "2026-02-15-aabbccdd-1122-3344-5566-778899aabbcc",
+  "strategy": "manual-commit",
+  "createdAt": "2026-02-15T09:00:00Z",
+  "branch": "main",
+  "filesTouched": ["src/api.ts", "tests/api.test.ts"],
+  "agent": "Claude Code",
+  "turnID": "turn-001",
+  "isTask": false,
+  "checkpointTranscriptStart": 0,
+  "tokenUsage": {
+    "inputTokens": 20000,
+    "cacheCreationTokens": 3000,
+    "cacheReadTokens": 6000,
+    "outputTokens": 4000,
+    "apiCallCount": 10,
+    "subagentTokens": {
+      "inputTokens": 2000,
+      "cacheCreationTokens": 0,
+      "cacheReadTokens": 0,
+      "outputTokens": 800,
+      "apiCallCount": 3
+    }
+  },
+  "summary": {
+    "intent": "Add validation to the API endpoint",
+    "outcome": "Added input validation with Zod schema",
+    "learnings": {
+      "repo": ["API routes use Zod for validation"],
+      "code": [
+        {
+          "path": "src/api.ts",
+          "line": 15,
+          "finding": "Zod schema must be defined before route handler"
+        }
+      ],
+      "workflow": ["Run API tests with --reporter=verbose flag"]
+    },
+    "friction": ["Had to look up Zod coercion syntax"],
+    "openItems": ["Add validation for the PUT endpoint too"]
+  },
+  "initialAttribution": {
+    "calculatedAt": "2026-02-15T09:30:00Z",
+    "agentLines": 30,
+    "humanAdded": 3,
+    "humanModified": 1,
+    "humanRemoved": 0,
+    "totalCommitted": 34,
+    "agentPercentage": 0.88
+  },
+  "tasks": {},
+  "skillsUsed": []
+}

package/tests/session-bank/git-reader.test.ts

@@ -3,7 +3,7 @@ import { mkdtemp, rm, readFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { execFileSync } from 'node:child_process';
-import { EntireGitReader } from '../../src/session-bank/git-reader.js';
+import { CheckpointGitReader } from '../../src/session-bank/git-reader.js';
 
 const FIXTURES = join(import.meta.dirname, 'fixtures');
 
@@ -126,14 +126,14 @@ async function createFixtureRepo(): Promise<string> {
   const orphanCommit = commitTree(tmpDir, rootTree, 'checkpoint data');
   git(tmpDir, [
     'update-ref',
-    'refs/heads/entire/checkpoints/v1',
+    'refs/heads/sessionlog/checkpoints/v1',
     orphanCommit,
   ]);
 
   return tmpDir;
 }
 
-describe('EntireGitReader', () => {
+describe('CheckpointGitReader', () => {
   let tmpDir: string;
 
   beforeEach(async () => {
@@ -145,12 +145,12 @@ describe('EntireGitReader', () => {
   });
 
   it('should detect that the orphan branch exists', async () => {
-    const reader = new EntireGitReader({ repoPath: tmpDir });
+    const reader = new CheckpointGitReader({ repoPath: tmpDir });
     expect(await reader.branchExists()).toBe(true);
   });
 
   it('should return false for non-existent branch', async () => {
-    const reader = new EntireGitReader({
+    const reader = new CheckpointGitReader({
       repoPath: tmpDir,
       branch: 'nonexistent/branch',
     });
@@ -158,7 +158,7 @@ describe('EntireGitReader', () => {
   });
 
   it('should list checkpoint paths', async () => {
-    const reader = new EntireGitReader({ repoPath: tmpDir });
+    const reader = new CheckpointGitReader({ repoPath: tmpDir });
     const checkpoints = await reader.listCheckpoints();
 
     expect(checkpoints).toHaveLength(1);
@@ -166,7 +166,7 @@ describe('EntireGitReader', () => {
   });
 
   it('should list session indices', async () => {
-    const reader = new EntireGitReader({ repoPath: tmpDir });
+    const reader = new CheckpointGitReader({ repoPath: tmpDir });
     const sessions = await reader.listSessions('a3/b2c4d5e6f7');
 
     expect(sessions).toHaveLength(1);
@@ -174,7 +174,7 @@ describe('EntireGitReader', () => {
   });
 
   it('should read a file from the orphan branch', async () => {
-    const reader = new EntireGitReader({ repoPath: tmpDir });
+    const reader = new CheckpointGitReader({ repoPath: tmpDir });
     const content = await reader.readFile(
       'a3/b2c4d5e6f7/0/metadata.json',
     );
@@ -185,7 +185,7 @@ describe('EntireGitReader', () => {
   });
 
   it('should batch-read multiple files', async () => {
-    const reader = new EntireGitReader({ repoPath: tmpDir });
+    const reader = new CheckpointGitReader({ repoPath: tmpDir });
     const files = await reader.readFiles([
       'a3/b2c4d5e6f7/0/metadata.json',
       'a3/b2c4d5e6f7/0/full.jsonl',
@@ -199,13 +199,13 @@ describe('EntireGitReader', () => {
   });
 
   it('should return null for missing files', async () => {
-    const reader = new EntireGitReader({ repoPath: tmpDir });
+    const reader = new CheckpointGitReader({ repoPath: tmpDir });
     const content = await reader.readFileOrNull('does/not/exist');
     expect(content).toBeNull();
   });
 
   it('should get the orphan branch HEAD SHA', async () => {
-    const reader = new EntireGitReader({ repoPath: tmpDir });
+    const reader = new CheckpointGitReader({ repoPath: tmpDir });
     const sha = await reader.getBranchHead();
 
     expect(sha).toBeDefined();
@@ -213,7 +213,7 @@ describe('EntireGitReader', () => {
   });
 
   it('should return null for HEAD of non-existent branch', async () => {
-    const reader = new EntireGitReader({
+    const reader = new CheckpointGitReader({
       repoPath: tmpDir,
       branch: 'nope',
     });
@@ -222,7 +222,7 @@ describe('EntireGitReader', () => {
   });
 
   it('should return empty checkpoints for non-existent branch', async () => {
-    const reader = new EntireGitReader({
+    const reader = new CheckpointGitReader({
       repoPath: tmpDir,
       branch: 'nope',
     });