cognitive-core 0.1.0 → 0.2.0

package/src/atlas.ts

@@ -1,21 +1,47 @@
 import type {
   Task,
   Trajectory,
+  TeamTrajectory,
+  TeamPlaybook,
   AtlasConfig,
   Playbook,
 } from './types/index.js';
+import type { KnowledgeMatch } from './types/knowledge.js';
 import { createDefaultConfig } from './types/index.js';
-import { MemorySystem, createMemorySystem } from './memory/index.js';
+import { MemorySystem, createMemorySystem, type TeamExperience } from './memory/index.js';
 import {
-  LearningPipeline,
-  createLearningPipeline,
-  type ProcessResult,
-  type BatchResult,
-} from './learning/index.js';
+  UnifiedLearningPipeline,
+  createUnifiedPipeline,
+  type ImmediateResult,
+  type UnifiedBatchResult,
+} from './learning/unified-pipeline.js';
+import {
+  TeamLearningPipeline,
+  createTeamLearningPipeline,
+  type TeamBatchResult,
+  type TeamProcessResult,
+} from './learning/team-pipeline.js';
+import {
+  TeamMetaLearner,
+  createTeamMetaLearner,
+} from './learning/team-meta-learner.js';
+import {
+  TeamRouter,
+  createTeamRouter,
+  type TeamRecommendation,
+  type TeamRecommendationInput,
+} from './search/team-router.js';
+import {
+  TeamSkillLibrary,
+  createTeamSkillLibrary,
+  type TeamOutcomeFeedback,
+} from './surfacing/team-skill-library.js';
 import {
   PlaybookUsageInference,
   createUsageInference,
 } from './learning/usage-inference.js';
+import type { MetaLearner } from './learning/meta-learner.js';
+import type { LearningEffectivenessTracker } from './learning/effectiveness.js';
 import { TaskRouter, createRouter, type RoutingDecision } from './search/router.js';
 import { DirectSolver, createSolver } from './search/solver.js';
 import {
@@ -25,15 +51,31 @@ import {
 import type { RefinementResult } from './search/refinement-types.js';
 import type { LLMProvider } from './agents/types.js';
 import { AgentManager, createAgentManager } from './runtime/manager.js';
-import type { AgentBackend, AgentSpawnConfig } from './runtime/types.js';
+import type { AgentBackend, AgentSpawnConfig, AgentDelegate } from './runtime/types.js';
 import {
   SkillLibrary,
   createSkillLibrary,
 } from './surfacing/skill-library.js';
+import { SqliteStorageAdapter } from './surfacing/sqlite-storage-adapter.js';
+import { join } from 'node:path';
+import { SqlitePersistence, createSqlitePersistence } from './persistence/index.js';
 import {
   PlaybookMCPServer,
   createPlaybookMCPServer,
 } from './mcp/playbook-server.js';
+import {
+  AgenticTaskRunner,
+  createAgenticTaskRunner,
+} from './workspace/runner.js';
+import { usageInferenceTemplate } from './workspace/templates/usage-inference.js';
+import { metaReflectionTemplate } from './workspace/templates/meta-reflection.js';
+import { WorkspaceManager } from 'agent-workspace';
+
+/**
+ * Result from processing a team trajectory.
+ * Re-exports the pipeline's TeamProcessResult type.
+ */
+export type { TeamProcessResult } from './learning/team-pipeline.js';
 
 /**
  * Atlas statistics
@@ -44,9 +86,16 @@ export interface AtlasStats {
     playbookCount: number;
     metaObservationCount: number;
   };
+  teamMemory?: {
+    teamExperienceCount: number;
+    teamPlaybookCount: number;
+    rolePlaybookCount: number;
+    teamMetaObservationCount: number;
+  };
   learning: {
     trajectoriesProcessed: number;
     pendingTrajectories: number;
+    teamTrajectoriesProcessed: number;
   };
   execution?: {
     agentManagerEnabled: boolean;
@@ -91,6 +140,8 @@ export interface SolveResult {
   injectedPlaybooks?: Playbook[];
   /** Playbook usage inference results */
   playbookUsage?: PlaybookUsage[];
+  /** Knowledge notes that were surfaced for this task */
+  surfacedKnowledge?: KnowledgeMatch[];
 }
 
 /**
@@ -104,7 +155,7 @@ export interface SolveResult {
  */
 export class Atlas {
   private memory: MemorySystem;
-  private learning: LearningPipeline;
+  private unifiedPipeline: UnifiedLearningPipeline;
   private router: TaskRouter;
   private solver: DirectSolver | null = null;
   private agentManager: AgentManager | null = null;
@@ -112,34 +163,112 @@ export class Atlas {
   private config: AtlasConfig;
   private provider: LLMProvider | null = null;
   private trajectoriesProcessed = 0;
+  private teamTrajectoriesProcessed = 0;
 
   // Playbook-based components
   private skillLibrary: SkillLibrary | null = null;
+  private skillTreeStorage: SqliteStorageAdapter | null = null;
   private usageInference: PlaybookUsageInference | null = null;
   private mcpServer: PlaybookMCPServer | null = null;
 
+  // Agentic workspace components
+  private taskRunner: AgenticTaskRunner | null = null;
+  private workspaceManager: WorkspaceManager | null = null;
+
+  // Team-aware learning, recommendation, and surfacing
+  private teamLearning: TeamLearningPipeline | null = null;
+  private teamRouter: TeamRouter | null = null;
+  private teamMetaLearner: TeamMetaLearner | null = null;
+  private teamSkillLibrary: TeamSkillLibrary | null = null;
+
+  // Unified SQLite persistence
+  private persistence: SqlitePersistence;
+
   constructor(config?: Partial<AtlasConfig>) {
     this.config = createDefaultConfig(config);
 
-    // Initialize memory system
+    // Create unified SQLite persistence
+    this.persistence = createSqlitePersistence({
+      baseDir: this.config.storage.baseDir,
+      dbName: this.config.storage.dbName,
+    });
+
+    // Initialize memory system (with optional knowledge bank)
     this.memory = createMemorySystem(
+      this.persistence,
       this.config.storage.baseDir,
-      this.config.memory
+      this.config.memory,
+      this.config.knowledgeBank.enabled
+        ? { ...this.config.knowledgeBank, coherenceChecking: this.config.features.coherenceChecking }
+        : undefined
     );
 
-    // Initialize learning pipeline
-    this.learning = createLearningPipeline(this.memory, this.config.learning);
+    // Initialize unified learning pipeline (replaces LearningPipeline + InstantLoop + LoopCoordinator)
+    this.unifiedPipeline = createUnifiedPipeline(this.memory, {
+      instant: {
+        enableReflexion: this.config.features.reflexion,
+        enableCausalExtraction: this.config.features.causalExtraction,
+      },
+      batch: {
+        learning: this.config.learning,
+        energy: {
+          countThreshold: this.config.learning.minTrajectories ?? 10,
+        },
+      },
+      features: {
+        temporalCompression: this.config.features.temporalCompression,
+        reasoningBank: this.config.features.reasoningBank,
+        reflexion: this.config.features.reflexion,
+        causalExtraction: this.config.features.causalExtraction,
+      },
+    }, this.persistence);
+
+    // Initialize router (with persistence for MoEGate)
+    this.router = createRouter(this.memory, this.config.router, undefined, this.persistence);
 
-    // Initialize router
-    this.router = createRouter(this.memory, this.config.router);
+    // Initialize team learning pipeline and router if enabled
+    if (this.config.teamLearning.enabled) {
+      this.teamLearning = createTeamLearningPipeline(
+        this.memory.teamExperiences,
+        this.config.teamLearning
+      );
+
+      // Initialize team meta-learner and team router
+      this.teamMetaLearner = createTeamMetaLearner(
+        this.memory.teamExperiences
+      );
+      this.teamRouter = createTeamRouter(
+        this.memory.teamExperiences,
+        undefined,
+        this.teamMetaLearner
+      );
+      this.teamSkillLibrary = createTeamSkillLibrary(
+        this.memory.teamExperiences
+      );
+    }
   }
 
   /**
    * Initialize Atlas (load persisted data)
    */
   async init(): Promise<void> {
+    await this.persistence.init();
+
+    // Load persisted state for components created before persistence.init()
+    this.router.loadPersistedState();
+    this.unifiedPipeline.loadPersistedState();
+
     await this.memory.init();
 
+    // Initialize unified pipeline async components (meta-learner, effectiveness tracker, energy seed)
+    await this.unifiedPipeline.init();
+
+    // Connect meta-learner to router
+    const metaLearner = this.unifiedPipeline.getMetaLearner();
+    if (metaLearner) {
+      this.router.setMetaLearner(metaLearner);
+    }
+
     // Initialize playbook-based components if playbooks are available
     if (this.memory.playbooks) {
       this.skillLibrary = createSkillLibrary(
@@ -148,6 +277,14 @@ export class Atlas {
       );
       this.usageInference = createUsageInference();
 
+      // Wire skill-tree publisher if enabled (default: true)
+      if (this.config.skillTree.enabled) {
+        const dbPath = join(this.config.storage.baseDir, this.config.skillTree.dbPath);
+        this.skillTreeStorage = new SqliteStorageAdapter(dbPath);
+        await this.skillTreeStorage.initialize();
+        this.skillLibrary.setPublisher(this.skillTreeStorage);
+      }
+
       // Refresh skill tiers on init
       await this.skillLibrary.refreshTiers();
     }
@@ -166,15 +303,41 @@ export class Atlas {
    * Set up the AgentManager with backends for real action execution
    * This is the recommended way to configure Atlas for execution
    */
-  setAgentManager(backends: AgentBackend[]): void {
+  setAgentManager(
+    backends: AgentBackend[],
+    options?: { delegate?: AgentDelegate }
+  ): void {
     // Create AgentManager with memory system
-    this.agentManager = createAgentManager(this.memory);
+    this.agentManager = createAgentManager(this.memory, {
+      delegate: options?.delegate,
+    });
 
     // Register all backends
     for (const backend of backends) {
       this.agentManager.registerBackend(backend);
     }
 
+    // Create workspace infrastructure (using agent-workspace package)
+    this.workspaceManager = new WorkspaceManager({
+      baseDir: this.config.agenticTasks.workspaceBaseDir,
+      prefix: 'atlas-workspaces',
+    });
+    this.taskRunner = createAgenticTaskRunner(
+      this.workspaceManager,
+      this.agentManager,
+      this.memory,
+      this.unifiedPipeline,
+      this.config.agenticTasks
+    );
+
+    // Connect task runner to unified pipeline for workspace-based analysis
+    this.unifiedPipeline.setTaskRunner(this.taskRunner);
+
+    // Connect task runner to team learning pipeline
+    if (this.teamLearning) {
+      this.teamLearning.setTaskRunner(this.taskRunner);
+    }
+
     // Create refinement loop with config
     this.refinementLoop = createRefinementLoop(
       this.agentManager,
@@ -189,6 +352,9 @@ export class Atlas {
         confidenceThreshold: this.config.refinement.confidenceThreshold,
       }
     );
+
+    // Connect task runner to refinement loop for workspace-based evaluation and analysis
+    this.refinementLoop.setTaskRunner(this.taskRunner);
   }
 
   /**
@@ -198,6 +364,24 @@ export class Atlas {
     return this.agentManager;
   }
 
+  /**
+   * Set a delegate for caller-provided agent execution.
+   * Requires AgentManager to be initialized first (via setAgentManager).
+   */
+  setDelegate(delegate: AgentDelegate): void {
+    if (!this.agentManager) {
+      throw new Error('AgentManager not initialized. Call setAgentManager() first.');
+    }
+    this.agentManager.setDelegate(delegate);
+  }
+
+  /**
+   * Get the current delegate, if any.
+   */
+  getDelegate(): AgentDelegate | undefined {
+    return this.agentManager?.getDelegate();
+  }
+
   /**
    * Get the RefinementLoop for registering domain verifiers
    */
@@ -205,6 +389,13 @@ export class Atlas {
     return this.refinementLoop;
   }
 
+  /**
+   * Get the AgenticTaskRunner for running analysis tasks
+   */
+  getTaskRunner(): AgenticTaskRunner | null {
+    return this.taskRunner;
+  }
+
   /**
    * Check if agent execution is available
    */
@@ -239,11 +430,30 @@ export class Atlas {
       }
     }
 
+    // Surface knowledge from knowledge bank (independent from skill surfacing)
+    let knowledgeContext = '';
+    let surfacedKnowledge: KnowledgeMatch[] | undefined;
+    if (this.memory.knowledgeBank) {
+      surfacedKnowledge = await this.memory.knowledgeBank.getRelevantKnowledge(
+        { description: task.description, domain: task.domain },
+      );
+      if (surfacedKnowledge.length > 0) {
+        knowledgeContext = this.memory.knowledgeBank.formatKnowledgeForPrompt(
+          surfacedKnowledge,
+        );
+      }
+    }
+
+    // Combine skill context + knowledge context
+    const combinedContext = [skillContext, knowledgeContext]
+      .filter(Boolean)
+      .join('\n\n');
+
     let result: SolveResult;
 
     // Prefer AgentManager if available
     if (this.agentManager) {
-      result = await this.solveWithAgent(task, routing, skillContext);
+      result = await this.solveWithAgent(task, routing, combinedContext || undefined);
     } else if (this.solver && this.provider) {
       // Fall back to DirectSolver (deprecated)
       const solverResult = await this.solver.solve(task, routing);
@@ -261,12 +471,13 @@ export class Atlas {
 
     // Add injected playbooks to result
     result.injectedPlaybooks = injectedPlaybooks;
+    result.surfacedKnowledge = surfacedKnowledge;
 
     // Infer playbook usage from trajectory
-    if (this.usageInference && this.skillLibrary && injectedPlaybooks.length > 0) {
-      const usageResults = await this.usageInference.inferUsage(
+    if (this.skillLibrary && injectedPlaybooks.length > 0) {
+      const usageResults = await this.inferPlaybookUsage(
         result.trajectory,
-        injectedPlaybooks
+        injectedPlaybooks,
       );
 
       // Convert to PlaybookUsage format and record outcomes
@@ -292,15 +503,35 @@ export class Atlas {
       }
     }
 
-    // Process the trajectory for learning
-    await this.learning.processTrajectory(result.trajectory);
-    this.trajectoriesProcessed++;
+    // Generate meta-reflection (records observation + periodically generates strategies)
+    const metaLearner = this.unifiedPipeline.getMetaLearner();
+    if (metaLearner) {
+      await this.reflectOnExecution(result.trajectory, routing);
+    }
 
-    // Run batch learning if ready
-    if (this.learning.shouldRunBatch()) {
-      await this.runBatchLearning();
+    // Annotate trajectory for effectiveness tracking
+    const effectivenessTracker = this.unifiedPipeline.getEffectivenessTracker();
+    if (effectivenessTracker) {
+      const appliedPlaybookIds = (result.playbookUsage ?? [])
+        .filter(u => u.wasUsed)
+        .map(u => u.playbookId);
+
+      const surfacedExperienceIds = routing.memoryContext.experiences.map(
+        e => e.experience.id
+      );
+
+      await effectivenessTracker.annotate(
+        result.trajectory,
+        routing.memoryContext.playbooks,
+        surfacedExperienceIds,
+        appliedPlaybookIds,
+      );
     }
 
+    // Process the trajectory through unified pipeline (immediate + batch if energy triggers)
+    await this.unifiedPipeline.processTrajectory(result.trajectory);
+    this.trajectoriesProcessed++;
+
     return result;
   }
 
@@ -377,19 +608,185 @@ export class Atlas {
   }
 
   /**
-   * Process an external trajectory (from another agent)
+   * Process an external trajectory (from another agent).
+   * Runs the instant loop first (hot path), then feeds into the batch pipeline.
    */
-  async processTrajectory(trajectory: Trajectory): Promise<ProcessResult> {
-    const result = await this.learning.processTrajectory(trajectory);
+  async processTrajectory(trajectory: Trajectory): Promise<ImmediateResult> {
+    // Unified pipeline handles immediate + batch (if energy triggers)
+    const result = await this.unifiedPipeline.processTrajectory(trajectory);
     this.trajectoriesProcessed++;
     return result;
   }
 
+  /**
+   * Process a team trajectory through the full team learning pipeline.
+   * Ingests, analyzes (heuristic or agentic), stores, and accumulates
+   * for batch team playbook extraction.
+   */
+  async processTeamTrajectory(
+    trajectory: TeamTrajectory
+  ): Promise<TeamProcessResult> {
+    if (!this.config.teamLearning.enabled || !this.teamLearning) {
+      return { teamTrajectoryId: trajectory.id, stored: false, analyzed: false };
+    }
+
+    const result = await this.teamLearning.processTeamTrajectory(trajectory);
+    this.teamTrajectoriesProcessed++;
+
+    // Generate team meta-reflection for the meta-learner
+    if (this.teamMetaLearner) {
+      try {
+        await this.teamMetaLearner.generateReflection(trajectory);
+      } catch (error) {
+        console.error(
+          '[Atlas] Team meta-reflection failed:',
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+    }
+
+    // Run batch team learning if ready
+    if (this.teamLearning.shouldRunBatch()) {
+      await this.runTeamBatchLearning();
+    }
+
+    return result;
+  }
+
+  /**
+   * Run batch team playbook extraction explicitly.
+   */
+  async runTeamBatchLearning(): Promise<TeamBatchResult | null> {
+    if (!this.teamLearning) return null;
+    return this.teamLearning.runBatchLearning();
+  }
+
+  /**
+   * Get the team learning pipeline for direct access.
+   */
+  getTeamLearning(): TeamLearningPipeline | null {
+    return this.teamLearning;
+  }
+
+  /**
+   * Recommend a team composition for a given task.
+   * Uses team playbooks and meta-strategies to produce a recommendation
+   * with optional OpenTeams YAML export.
+   */
+  async recommendTeam(input: TeamRecommendationInput): Promise<TeamRecommendation> {
+    if (!this.teamRouter) {
+      throw new Error(
+        'Team learning is not enabled. Set teamLearning.enabled = true in config.'
+      );
+    }
+    return this.teamRouter.recommend(input);
+  }
+
+  /**
+   * Get the team router for direct access.
+   */
+  getTeamRouter(): TeamRouter | null {
+    return this.teamRouter;
+  }
+
+  /**
+   * Get the team meta-learner for direct access.
+   */
+  getTeamMetaLearner(): TeamMetaLearner | null {
+    return this.teamMetaLearner;
+  }
+
+  /**
+   * Get the team skill library for direct access.
+   */
+  getTeamSkillLibrary(): TeamSkillLibrary | null {
+    return this.teamSkillLibrary;
+  }
+
+  /**
+   * Record team outcome feedback to update playbook evolution.
+   * Updates success/failure counts, recalculates confidence, and
+   * accumulates average metrics for the team playbook.
+   */
+  async recordTeamOutcome(feedback: TeamOutcomeFeedback): Promise<void> {
+    if (!this.teamSkillLibrary) {
+      throw new Error(
+        'Team learning is not enabled. Set teamLearning.enabled = true in config.'
+      );
+    }
+    await this.teamSkillLibrary.recordTeamOutcome(feedback);
+  }
+
+  /**
+   * Format role guidance for injection into an agent's system prompt.
+   * Returns markdown-formatted role playbook content for the given role.
+   */
+  async formatRoleGuidance(
+    role: string,
+    context?: { topology?: string; domain?: string; taskType?: string }
+  ): Promise<string> {
+    if (!this.teamSkillLibrary) return '';
+
+    const ranked = await this.teamSkillLibrary.findRolePlaybooks(role, {
+      topology: context?.topology,
+      domain: context?.domain,
+      taskType: context?.taskType,
+    });
+
+    return this.teamSkillLibrary.formatRoleGuidance(
+      role,
+      ranked.map((r) => r.playbook)
+    );
+  }
+
+  /**
+   * Query team memory for coordination patterns.
+   */
+  async queryTeamMemory(
+    query: string,
+    options?: {
+      domain?: string;
+      topology?: string;
+      includeExperiences?: boolean;
+      includePlaybooks?: boolean;
+    }
+  ) {
+    const results: {
+      experiences: Array<{ experience: TeamExperience; score: number }>;
+      playbooks: Array<{ playbook: TeamPlaybook; score: number }>;
+    } = {
+      experiences: [],
+      playbooks: [],
+    };
+
+    const shouldIncludeAll = !options || (
+      options.includeExperiences === undefined &&
+      options.includePlaybooks === undefined
+    );
+
+    if (shouldIncludeAll || options?.includeExperiences) {
+      results.experiences = await this.memory.teamExperiences.findSimilarTeamExperiences(
+        query,
+        { domain: options?.domain, topology: options?.topology }
+      );
+    }
+
+    if (shouldIncludeAll || options?.includePlaybooks) {
+      results.playbooks = await this.memory.teamExperiences.findMatchingTeamPlaybooks({
+        taskType: query,
+        domain: options?.domain,
+        topology: options?.topology,
+      });
+    }
+
+    return results;
+  }
+
   /**
    * Run batch learning explicitly
    */
-  async runBatchLearning(): Promise<BatchResult> {
-    return this.learning.runBatchLearning();
+  async runBatchLearning(): Promise<UnifiedBatchResult> {
+    return this.unifiedPipeline.runBatch();
   }
 
   /**
@@ -415,10 +812,22 @@ export class Atlas {
       memory: memoryStats,
       learning: {
         trajectoriesProcessed: this.trajectoriesProcessed,
-        pendingTrajectories: this.learning.getAccumulatedCount(),
+        pendingTrajectories: this.unifiedPipeline.getAccumulatedCount(),
+        teamTrajectoriesProcessed: this.teamTrajectoriesProcessed,
       },
     };
 
+    // Add team memory stats if team learning is enabled
+    if (this.config.teamLearning.enabled) {
+      const teamStats = await this.memory.teamExperiences.getStats();
+      stats.teamMemory = {
+        teamExperienceCount: teamStats.teamExperienceCount,
+        teamPlaybookCount: teamStats.teamPlaybookCount,
+        rolePlaybookCount: teamStats.rolePlaybookCount,
+        teamMetaObservationCount: teamStats.metaObservationCount,
+      };
+    }
+
     // Add execution stats if AgentManager is available
     if (this.agentManager) {
       stats.execution = {
@@ -448,11 +857,18 @@ export class Atlas {
     return this.memory;
   }
 
+  /**
+   * Get the knowledge bank for direct access (null if not enabled)
+   */
+  getKnowledgeBank(): import('./memory/knowledge-bank.js').KnowledgeBank | null {
+    return this.memory.knowledgeBank;
+  }
+
   /**
    * Get the learning pipeline for direct access
    */
-  getLearning(): LearningPipeline {
-    return this.learning;
+  getLearning(): UnifiedLearningPipeline {
+    return this.unifiedPipeline;
   }
 
   /**
@@ -462,6 +878,13 @@ export class Atlas {
     return this.skillLibrary;
   }
 
+  /**
+   * Get the skill-tree storage adapter (null if not enabled)
+   */
+  getSkillTreeStorage(): SqliteStorageAdapter | null {
+    return this.skillTreeStorage;
+  }
+
   /**
    * Get the MCP server for direct access
    */
@@ -502,7 +925,7 @@ export class Atlas {
    */
   updateConfig(config: Partial<AtlasConfig>): void {
     if (config.learning) {
-      this.learning.updateConfig(config.learning);
+      this.unifiedPipeline.updateConfig(config.learning);
     }
     if (config.router) {
       this.router.updateConfig(config.router);
@@ -511,18 +934,136 @@ export class Atlas {
   }
 
   /**
-   * Close Atlas (flush data to disk)
+   * Infer playbook usage via workspace template when taskRunner available,
+   * otherwise fall back to heuristic.
+   */
+  private async inferPlaybookUsage(
+    trajectory: Trajectory,
+    injectedPlaybooks: Playbook[],
+  ): Promise<import('./learning/usage-inference.js').PlaybookUsageResult[]> {
+    if (this.taskRunner && injectedPlaybooks.length > 0) {
+      try {
+        const result = await this.taskRunner.run(usageInferenceTemplate, {
+          trajectory,
+          injectedPlaybooks,
+        });
+        return result.output;
+      } catch (error) {
+        console.error(
+          'Workspace-based usage inference failed, falling back to heuristic:',
+          error instanceof Error ? error.message : error
+        );
+      }
+    }
+
+    // Heuristic fallback
+    if (this.usageInference) {
+      return this.usageInference.inferUsage(trajectory, injectedPlaybooks);
+    }
+    return [];
+  }
+
+  /**
+   * Reflect on execution via workspace template when taskRunner available,
+   * otherwise fall back to MetaLearner's built-in heuristic reflection.
    */
+  private async reflectOnExecution(
+    trajectory: Trajectory,
+    routing: RoutingDecision,
+  ): Promise<void> {
+    const metaLearnerRef = this.unifiedPipeline.getMetaLearner();
+    if (!metaLearnerRef) return;
+
+    const routingInfo = {
+      strategy: routing.strategy,
+      confidence: routing.confidence,
+      estimatedBudget: routing.estimatedBudget,
+      reasoning: routing.reasoning,
+    };
+    const playbookMatches = routing.memoryContext.playbooks;
+
+    if (this.taskRunner) {
+      try {
+        const result = await this.taskRunner.run(metaReflectionTemplate, {
+          trajectory,
+          routingDecision: routingInfo,
+          playbooksUsed: playbookMatches,
+        });
+
+        // Bridge template output into MetaLearner storage
+        const playbookIds = playbookMatches.map(p => p.playbook.id);
+        const actualEffort = trajectory.llmCalls ?? trajectory.steps.length;
+        await metaLearnerRef.recordFromReflection(
+          result.output,
+          trajectory.id,
+          routingInfo,
+          playbookIds,
+          actualEffort,
+        );
+        return;
+      } catch (error) {
+        console.error(
+          'Workspace-based meta-reflection failed, falling back to heuristic:',
+          error instanceof Error ? error.message : error
+        );
+      }
+    }
+
+    // Heuristic fallback
+    await metaLearnerRef.generateReflection(
+      trajectory,
+      routingInfo,
+      playbookMatches,
+    );
+  }
+
+  /**
+   * Get the meta learner for direct access
+   */
+  getMetaLearner(): MetaLearner | null {
+    return this.unifiedPipeline.getMetaLearner();
+  }
+
+  /**
+   * Get the effectiveness tracker for direct access
+   */
+  getEffectivenessTracker(): LearningEffectivenessTracker | null {
+    return this.unifiedPipeline.getEffectivenessTracker();
+  }
+
   async close(): Promise<void> {
     // Stop MCP server if running
     await this.stopMCPServer();
 
-    // Flush learning pipeline
-    if (this.learning.getAccumulatedCount() > 0) {
-      await this.learning.runBatchLearning();
+    // Flush unified pipeline
+    if (this.unifiedPipeline.getAccumulatedCount() > 0) {
+      await this.unifiedPipeline.runBatch();
+    }
+
+    // Flush team learning pipeline
+    if (this.teamLearning && this.teamLearning.getAccumulatedCount() > 0) {
+      await this.teamLearning.runBatchLearning();
+    }
+
+    // Flush MoE gate state before closing persistence
+    this.router.persistGateState();
+
+    // Close effectiveness tracker
+    const tracker = this.unifiedPipeline.getEffectivenessTracker();
+    if (tracker) {
+      await tracker.close();
     }
+
+    // Close skill-tree storage
+    if (this.skillTreeStorage) {
+      this.skillTreeStorage.close();
+    }
+
     // Close memory system
     await this.memory.close();
+
+    // Close SQLite persistence
+    this.persistence.close();
   }
 }
 
@@ -552,9 +1093,10 @@ export function createAtlasWithProvider(
  */
 export function createAtlasWithAgents(
   backends: AgentBackend[],
-  config?: Partial<AtlasConfig>
+  config?: Partial<AtlasConfig>,
+  options?: { delegate?: AgentDelegate }
 ): Atlas {
   const atlas = new Atlas(config);
-  atlas.setAgentManager(backends);
+  atlas.setAgentManager(backends, options);
   return atlas;
 }