cognitive-core 0.1.0 → 0.1.2

package/tests/memory/team-experience.test.ts

@@ -0,0 +1,411 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import {
+  TeamExperienceMemory,
+  createTeamExperienceMemory,
+} from '../../src/memory/team-experience.js';
+import { buildTeamTrajectory } from '../../src/types/team-trajectory.js';
+import type { TeamTrajectory, TeamTrajectoryInput } from '../../src/types/team-trajectory.js';
+import { createTask, createStep, successOutcome, createTrajectory } from '../../src/types/index.js';
+import { createTeamPlaybook } from '../../src/types/team-playbook.js';
+import { createRolePlaybook } from '../../src/types/team-playbook.js';
+import { createTeamMetaObservation } from '../../src/types/team-meta.js';
+import { createTeamMetaStrategy } from '../../src/types/team-meta.js';
+
+function createTmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'team-exp-test-'));
+}
+
+function makeSampleTrajectory(overrides?: Partial<TeamTrajectoryInput>): TeamTrajectory {
+  return buildTeamTrajectory({
+    objective: 'Implement user authentication',
+    domain: 'web',
+    complexity: 'moderate',
+    teamName: 'test-team',
+    templateName: 'wave',
+    topologyType: 'wave',
+    enforcement: 'permissive',
+    memberTrajectories: [
+      {
+        agentId: 'planner-1',
+        role: 'planner',
+        trajectory: createTrajectory({
+          task: createTask({ domain: 'web', description: 'plan auth' }),
+          steps: [createStep({ action: 'plan', observation: 'done' })],
+          outcome: successOutcome('planned'),
+          agentId: 'planner-1',
+          totalTokens: 10000,
+        }),
+      },
+      {
+        agentId: 'executor-1',
+        role: 'executor',
+        trajectory: createTrajectory({
+          task: createTask({ domain: 'web', description: 'execute auth' }),
+          steps: [createStep({ action: 'execute', observation: 'done' })],
+          outcome: successOutcome('executed'),
+          agentId: 'executor-1',
+          totalTokens: 10000,
+        }),
+      },
+    ],
+    outcome: {
+      success: true,
+      partialScore: 0.9,
+      quality: 'good',
+      totalLlmCalls: 10,
+      totalTokens: 20000,
+      totalWallTimeSeconds: 60,
+    },
+    ...overrides,
+  });
+}
+
+describe('TeamExperienceMemory', () => {
+  let tmpDir: string;
+  let memory: TeamExperienceMemory;
+
+  beforeEach(async () => {
+    tmpDir = createTmpDir();
+    memory = createTeamExperienceMemory(tmpDir);
+    await memory.init();
+  });
+
+  afterEach(async () => {
+    await memory.close();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  // === TEAM EXPERIENCES ===
+
+  describe('team experiences', () => {
+    it('should store and retrieve a team experience', async () => {
+      const trajectory = makeSampleTrajectory();
+      const experience = await memory.storeTeamExperience({ teamTrajectory: trajectory });
+
+      expect(experience.id).toBe(trajectory.id);
+      expect(experience.teamTrajectory.objective).toBe('Implement user authentication');
+      expect(experience.usageCount).toBe(0);
+
+      const retrieved = await memory.getTeamExperience(trajectory.id);
+      expect(retrieved).toBeDefined();
+      expect(retrieved!.teamTrajectory.teamName).toBe('test-team');
+    });
+
+    it('should find similar experiences by objective', async () => {
+      await memory.storeTeamExperience({
+        teamTrajectory: makeSampleTrajectory({ objective: 'Implement OAuth2 authentication' }),
+      });
+      await memory.storeTeamExperience({
+        teamTrajectory: makeSampleTrajectory({ objective: 'Build CI/CD pipeline' }),
+      });
+      await memory.storeTeamExperience({
+        teamTrajectory: makeSampleTrajectory({ objective: 'Add user login with authentication' }),
+      });
+
+      const results = await memory.findSimilarTeamExperiences('authentication login');
+      expect(results.length).toBeGreaterThan(0);
+      // Authentication-related should score higher
+      const objectives = results.map((r) => r.experience.teamTrajectory.objective);
+      expect(objectives[0]).toContain('authentication');
+    });
+
+    it('should filter by domain', async () => {
+      await memory.storeTeamExperience({
+        teamTrajectory: makeSampleTrajectory({ domain: 'web' }),
+      });
+      await memory.storeTeamExperience({
+        teamTrajectory: makeSampleTrajectory({ domain: 'infra' }),
+      });
+
+      const webResults = await memory.findSimilarTeamExperiences('test', { domain: 'web' });
+      expect(webResults.length).toBe(1);
+      expect(webResults[0].experience.teamTrajectory.domain).toBe('web');
+    });
+
+    it('should filter by success', async () => {
+      await memory.storeTeamExperience({
+        teamTrajectory: makeSampleTrajectory(),
+      });
+      await memory.storeTeamExperience({
+        teamTrajectory: makeSampleTrajectory({
+          outcome: {
+            success: false,
+            partialScore: 0.2,
+            quality: 'poor',
+            totalLlmCalls: 5,
+            totalTokens: 10000,
+            totalWallTimeSeconds: 30,
+          },
+        }),
+      });
+
+      const successOnly = await memory.findSimilarTeamExperiences('test', { successOnly: true });
+      expect(successOnly.length).toBe(1);
+      expect(successOnly[0].experience.teamTrajectory.outcome.success).toBe(true);
+    });
+
+    it('should track usage count', async () => {
+      const trajectory = makeSampleTrajectory();
+      await memory.storeTeamExperience({ teamTrajectory: trajectory });
+
+      await memory.recordTeamExperienceUsage(trajectory.id);
+      await memory.recordTeamExperienceUsage(trajectory.id);
+
+      const exp = await memory.getTeamExperience(trajectory.id);
+      expect(exp!.usageCount).toBe(2);
+      expect(exp!.lastAccessedAt).toBeDefined();
+    });
+
+    it('should count experiences', async () => {
+      expect(await memory.countTeamExperiences()).toBe(0);
+
+      await memory.storeTeamExperience({ teamTrajectory: makeSampleTrajectory() });
+      await memory.storeTeamExperience({ teamTrajectory: makeSampleTrajectory() });
+
+      expect(await memory.countTeamExperiences()).toBe(2);
+    });
+  });
+
+  // === TEAM PLAYBOOKS ===
+
+  describe('team playbooks', () => {
+    it('should store and retrieve team playbooks', async () => {
+      const playbook = createTeamPlaybook({
+        name: 'wave-feature',
+        applicability: {
+          taskTypes: ['full-stack feature'],
+          teamSizeRange: { min: 3, max: 6 },
+          complexityLevels: ['moderate', 'complex'],
+          domains: ['web'],
+          antiPatterns: [],
+        },
+        composition: {
+          topology: 'wave',
+          roles: [],
+          spawnRules: {},
+          enforcement: 'permissive',
+        },
+        coordination: {
+          executionModel: 'wave-parallel',
+          channels: [],
+          interactionPatterns: [],
+          delegationStrategy: 'vertical-slice',
+        },
+      });
+
+      await memory.storeTeamPlaybook(playbook);
+
+      const all = await memory.getTeamPlaybooks();
+      expect(all).toHaveLength(1);
+      expect(all[0].name).toBe('wave-feature');
+    });
+
+    it('should find matching playbooks by domain', async () => {
+      const webPlaybook = createTeamPlaybook({
+        name: 'web-playbook',
+        applicability: {
+          taskTypes: ['feature'],
+          teamSizeRange: { min: 2, max: 4 },
+          complexityLevels: ['moderate'],
+          domains: ['web'],
+          antiPatterns: [],
+        },
+        composition: {
+          topology: 'wave',
+          roles: [],
+          spawnRules: {},
+          enforcement: 'permissive',
+        },
+        coordination: {
+          executionModel: 'wave-parallel',
+          channels: [],
+          interactionPatterns: [],
+          delegationStrategy: '',
+        },
+      });
+
+      const infraPlaybook = createTeamPlaybook({
+        name: 'infra-playbook',
+        applicability: {
+          taskTypes: ['deployment'],
+          teamSizeRange: { min: 2, max: 4 },
+          complexityLevels: ['complex'],
+          domains: ['infra'],
+          antiPatterns: [],
+        },
+        composition: {
+          topology: 'hierarchical',
+          roles: [],
+          spawnRules: {},
+          enforcement: 'strict',
+        },
+        coordination: {
+          executionModel: 'sequential',
+          channels: [],
+          interactionPatterns: [],
+          delegationStrategy: '',
+        },
+      });
+
+      await memory.storeTeamPlaybook(webPlaybook);
+      await memory.storeTeamPlaybook(infraPlaybook);
+
+      const matches = await memory.findMatchingTeamPlaybooks({ domain: 'web' });
+      expect(matches).toHaveLength(1);
+      expect(matches[0].playbook.name).toBe('web-playbook');
+    });
+  });
+
+  // === ROLE PLAYBOOKS ===
+
+  describe('role playbooks', () => {
+    it('should store and find role playbooks by role', async () => {
+      const executorPlaybook = createRolePlaybook({
+        name: 'wave-executor',
+        role: 'executor',
+        teamContext: {
+          topologies: ['wave'],
+          teamSizeRange: { min: 3, max: 6 },
+          taskTypes: ['feature'],
+          domains: ['web'],
+        },
+        guidance: {
+          responsibilities: ['Implement slice'],
+          interactionGuidance: [],
+          decisionFrameworks: [],
+          antiPatterns: [],
+        },
+      });
+
+      const plannerPlaybook = createRolePlaybook({
+        name: 'wave-planner',
+        role: 'planner',
+        teamContext: {
+          topologies: ['wave'],
+          teamSizeRange: { min: 3, max: 6 },
+          taskTypes: ['feature'],
+          domains: ['web'],
+        },
+        guidance: {
+          responsibilities: ['Decompose task'],
+          interactionGuidance: [],
+          decisionFrameworks: [],
+          antiPatterns: [],
+        },
+      });
+
+      await memory.storeRolePlaybook(executorPlaybook);
+      await memory.storeRolePlaybook(plannerPlaybook);
+
+      const executorMatches = await memory.findMatchingRolePlaybooks({ role: 'executor' });
+      expect(executorMatches).toHaveLength(1);
+      expect(executorMatches[0].playbook.name).toBe('wave-executor');
+
+      const plannerMatches = await memory.findMatchingRolePlaybooks({ role: 'planner' });
+      expect(plannerMatches).toHaveLength(1);
+      expect(plannerMatches[0].playbook.name).toBe('wave-planner');
+    });
+  });
+
+  // === META-OBSERVATIONS ===
+
+  describe('meta-observations', () => {
+    it('should record and retrieve meta-observations', async () => {
+      const obs = createTeamMetaObservation({
+        teamTrajectoryId: 'tt-001',
+        formation: {
+          formationMethod: 'playbook',
+          confidence: 0.8,
+          reasoning: 'Matched wave pattern',
+        },
+        compositionEffectiveness: {
+          roleUtilization: { planner: 0.9 },
+          missingRoles: [],
+          redundantRoles: [],
+          teamSizeAssessment: 'right-sized',
+          topologyAssessment: 'effective',
+        },
+        coordinationEffectiveness: {
+          enforcementAssessment: 'appropriate',
+          channelEffectiveness: 'helpful',
+          bottlenecks: [],
+          coordinationOverhead: 0.2,
+        },
+        outcome: {
+          success: true,
+          quality: 'good',
+          speedupEstimate: 1.5,
+          costEfficiency: 0.8,
+        },
+        lessons: {
+          whatWorked: ['Wave topology'],
+          whatFailed: [],
+          formationSuggestions: [],
+          coordinationSuggestions: [],
+        },
+      });
+
+      await memory.recordMetaObservation(obs);
+
+      const all = await memory.getMetaObservations();
+      expect(all).toHaveLength(1);
+      expect(all[0].teamTrajectoryId).toBe('tt-001');
+    });
+  });
+
+  // === META-STRATEGIES ===
+
+  describe('meta-strategies', () => {
+    it('should store and find matching meta-strategies', async () => {
+      const strategy = createTeamMetaStrategy({
+        name: 'prefer-wave-for-web',
+        condition: {
+          taskCharacteristics: ['multi-component'],
+          resourceConstraints: [],
+          domains: ['web'],
+        },
+        adjustment: {
+          topologyBias: { wave: 0.8 },
+          teamSizeAdjustment: 'maintain',
+          roleAdjustments: [],
+          coordinationHints: [],
+        },
+      });
+
+      await memory.storeMetaStrategy(strategy);
+
+      const matches = await memory.getMatchingMetaStrategies({ domains: ['web'] });
+      expect(matches).toHaveLength(1);
+      expect(matches[0].name).toBe('prefer-wave-for-web');
+
+      const noMatches = await memory.getMatchingMetaStrategies({ domains: ['infra'] });
+      expect(noMatches).toHaveLength(0);
+    });
+  });
+
+  // === AGGREGATE STATS ===
+
+  describe('stats', () => {
+    it('should return correct stats', async () => {
+      await memory.storeTeamExperience({ teamTrajectory: makeSampleTrajectory() });
+
+      const playbook = createTeamPlaybook({
+        name: 'test',
+        applicability: { taskTypes: [], teamSizeRange: { min: 1, max: 1 }, complexityLevels: [], domains: [], antiPatterns: [] },
+        composition: { topology: 'flat', roles: [], spawnRules: {}, enforcement: 'permissive' },
+        coordination: { executionModel: 'sequential', channels: [], interactionPatterns: [], delegationStrategy: '' },
+      });
+      await memory.storeTeamPlaybook(playbook);
+
+      const stats = await memory.getStats();
+      expect(stats.teamExperienceCount).toBe(1);
+      expect(stats.teamPlaybookCount).toBe(1);
+      expect(stats.rolePlaybookCount).toBe(0);
+      expect(stats.metaObservationCount).toBe(0);
+      expect(stats.metaStrategyCount).toBe(0);
+    });
+  });
+});

package/tests/runtime/agent-manager.test.ts

@@ -72,7 +72,7 @@ describe('AgentManager', () => {
 
       await expect(
         manager.spawn({ agentType: 'unsupported', task })
-      ).rejects.toThrow('No backend found for agent type: unsupported');
+      ).rejects.toThrow(/No compute source supports agent type 'unsupported'/);
     });
 
     it('should inject knowledge into system prompt', async () => {

package/tests/runtime/compute-provider.test.ts

@@ -0,0 +1,288 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import {
+  DefaultComputeProvider,
+  createComputeProvider,
+  type ComputeSource,
+} from '../../src/runtime/compute-provider.js';
+import type { AgentBackend, AgentSpawnConfig, AgentSession } from '../../src/runtime/types.js';
+
+/**
+ * Create a minimal test backend with configurable name and supported types.
+ */
+function createTestBackend(
+  name: string,
+  supportedTypes: string[],
+  options?: { available?: boolean }
+): AgentBackend {
+  return {
+    name,
+    supportedTypes,
+    async isAvailable() {
+      return options?.available ?? true;
+    },
+    async spawn(_config: AgentSpawnConfig): Promise<AgentSession> {
+      return {
+        id: crypto.randomUUID(),
+        agentType: _config.agentType,
+        task: _config.task,
+        state: 'completed',
+        messages: [],
+        toolCalls: [],
+        startTime: new Date(),
+        endTime: new Date(),
+        result: `result from ${name}`,
+        metadata: {},
+      };
+    },
+    async getSession() {
+      return undefined;
+    },
+  };
+}
+
+describe('DefaultComputeProvider', () => {
+  let provider: DefaultComputeProvider;
+  let localBackend: AgentBackend;
+  let remoteBackend: AgentBackend;
+
+  beforeEach(() => {
+    provider = createComputeProvider();
+    localBackend = createTestBackend('local-acp', ['claude-code', 'test']);
+    remoteBackend = createTestBackend('remote-api', ['claude-code', 'gpt']);
+  });
+
+  describe('register and listSources', () => {
+    it('should register and list compute sources', () => {
+      provider.register({
+        name: 'local-acp',
+        backend: localBackend,
+        costTier: 'low',
+        location: 'local',
+        priority: 10,
+      });
+
+      const sources = provider.listSources();
+      expect(sources).toHaveLength(1);
+      expect(sources[0].name).toBe('local-acp');
+    });
+
+    it('should sort sources by priority', () => {
+      provider.register({
+        name: 'remote-api',
+        backend: remoteBackend,
+        costTier: 'medium',
+        location: 'remote',
+        priority: 20,
+      });
+      provider.register({
+        name: 'local-acp',
+        backend: localBackend,
+        costTier: 'low',
+        location: 'local',
+        priority: 5,
+      });
+
+      const sources = provider.listSources();
+      expect(sources[0].name).toBe('local-acp');
+      expect(sources[1].name).toBe('remote-api');
+    });
+
+    it('should re-register source with same name', () => {
+      provider.register({
+        name: 'local-acp',
+        backend: localBackend,
+        costTier: 'low',
+        location: 'local',
+        priority: 10,
+      });
+      provider.register({
+        name: 'local-acp',
+        backend: localBackend,
+        costTier: 'high',
+        location: 'local',
+        priority: 5,
+      });
+
+      const sources = provider.listSources();
+      expect(sources).toHaveLength(1);
+      expect(sources[0].costTier).toBe('high');
+    });
+  });
+
+  describe('unregister', () => {
+    it('should remove a compute source', () => {
+      provider.register({
+        name: 'local-acp',
+        backend: localBackend,
+        costTier: 'low',
+        location: 'local',
+        priority: 10,
+      });
+
+      provider.unregister('local-acp');
+      expect(provider.listSources()).toHaveLength(0);
+    });
+
+    it('should be a no-op for nonexistent source', () => {
+      provider.unregister('nonexistent');
+      expect(provider.listSources()).toHaveLength(0);
+    });
+  });
+
+  describe('supports', () => {
+    it('should return true for supported agent types', () => {
+      provider.register({
+        name: 'local-acp',
+        backend: localBackend,
+        costTier: 'low',
+        location: 'local',
+        priority: 10,
+      });
+
+      expect(provider.supports('claude-code')).toBe(true);
+      expect(provider.supports('test')).toBe(true);
+      expect(provider.supports('unknown')).toBe(false);
+    });
+  });
+
+  describe('resolve', () => {
+    const registerBoth = () => {
+      provider.register({
+        name: 'local-acp',
+        backend: localBackend,
+        costTier: 'low',
+        location: 'local',
+        priority: 10,
+      });
+      provider.register({
+        name: 'remote-api',
+        backend: remoteBackend,
+        costTier: 'medium',
+        location: 'remote',
+        priority: 20,
+      });
+    };
+
+    it('should resolve to highest-priority available backend', async () => {
+      registerBoth();
+      const target = await provider.resolve('claude-code');
+      expect(target.source).toBe('local-acp');
+      expect(target.backend).toBe(localBackend);
+    });
+
+    it('should throw for unsupported agent type', async () => {
+      registerBoth();
+      await expect(provider.resolve('nonexistent')).rejects.toThrow(
+        /No compute source supports agent type/
+      );
+    });
+
+    it('should prefer local when mode=local', async () => {
+      registerBoth();
+      const target = await provider.resolve('claude-code', { mode: 'local' });
+      expect(target.source).toBe('local-acp');
+    });
+
+    it('should prefer remote when mode=remote', async () => {
+      registerBoth();
+      const target = await provider.resolve('claude-code', { mode: 'remote' });
+      expect(target.source).toBe('remote-api');
+    });
+
+    it('should accept any location when mode=any', async () => {
+      registerBoth();
+      const target = await provider.resolve('claude-code', { mode: 'any' });
+      expect(target.source).toBe('local-acp');
+    });
+
+    it('should filter by cost budget', async () => {
+      registerBoth();
+      // Budget of 1 cent should exclude 'medium' (5 cents)
+      const target = await provider.resolve('claude-code', { maxCostCents: 1 });
+      expect(target.source).toBe('local-acp');
+    });
+
+    it('should fall back when budget too restrictive', async () => {
+      registerBoth();
+      // Budget of 0 excludes everything (low = 1) — falls back
+      const target = await provider.resolve('claude-code', { maxCostCents: 0 });
+      expect(target.backend).toBeDefined();
+    });
+
+    it('should fall back when location preference has no match for agent type', async () => {
+      registerBoth();
+      // 'test' only supported by local; requesting remote falls back
+      const target = await provider.resolve('test', { mode: 'remote' });
+      expect(target.source).toBe('local-acp');
+    });
+
+    it('should resolve agent types unique to one backend', async () => {
+      registerBoth();
+      const target = await provider.resolve('gpt');
+      expect(target.source).toBe('remote-api');
+    });
+
+    it('should skip unavailable backends and use next in priority', async () => {
+      const unavailableBackend = createTestBackend('unavailable', ['special'], {
+        available: false,
+      });
+      const availableBackend = createTestBackend('available', ['special']);
+
+      provider.register({
+        name: 'unavailable',
+        backend: unavailableBackend,
+        costTier: 'free',
+        location: 'local',
+        priority: 1,  // Higher priority but unavailable
+      });
+      provider.register({
+        name: 'available',
+        backend: availableBackend,
+        costTier: 'low',
+        location: 'local',
+        priority: 10,
+      });
+
+      const target = await provider.resolve('special');
+      expect(target.source).toBe('available');
+    });
+
+    it('should fall back to first candidate when all are unavailable', async () => {
+      const backend1 = createTestBackend('b1', ['agent'], { available: false });
+      const backend2 = createTestBackend('b2', ['agent'], { available: false });
+
+      provider.register({
+        name: 'b1',
+        backend: backend1,
+        costTier: 'low',
+        location: 'local',
+        priority: 1,
+      });
+      provider.register({
+        name: 'b2',
+        backend: backend2,
+        costTier: 'low',
+        location: 'local',
+        priority: 2,
+      });
+
+      const target = await provider.resolve('agent');
+      expect(target.source).toBe('b1');
+    });
+
+    it('should resolve by backend name as fallback', async () => {
+      provider.register({
+        name: 'my-backend',
+        backend: localBackend,
+        costTier: 'low',
+        location: 'local',
+        priority: 10,
+      });
+
+      // 'my-backend' is not in localBackend's supportedTypes
+      // but matches the source name → backend name fallback
+      const target = await provider.resolve('my-backend');
+      expect(target.backend).toBe(localBackend);
+    });
+  });
+});