cognitive-core 0.2.4 → 0.3.1

package/dist/atlas.js

@@ -1,26 +1,30 @@
-import { createDefaultConfig } from './types/index.js';
+import { logger } from './utils/logger.js';
+import { taskSignature } from './utils/task-signature.js';
+import { deriveObjectives } from './utils/objectives.js';
+import { applyValidationControls, createDefaultConfig } from './types/index.js';
 import { createMemorySystem } from './memory/index.js';
-import { loadCuratedPlaybooks as loadCuratedPlaybooksFn, BUNDLED_SEED_PACK_DIR, } from './memory/curated-loader.js';
+import { loadCuratedPlaybooks as loadCuratedPlaybooksFn, BUNDLED_SEED_PACKS, } from './memory/curated-loader.js';
 import { resolvePlaybookSource, sourceStateKey, } from './memory/source-resolver.js';
 import { createUnifiedPipeline, } from './learning/unified-pipeline.js';
-import { createTeamLearningPipeline, } from './learning/team-pipeline.js';
-import { createTeamMetaLearner, } from './learning/team-meta-learner.js';
-import { createTeamRouter, } from './search/team-router.js';
-import { createTeamSkillLibrary, } from './surfacing/team-skill-library.js';
-import { createUsageInference, } from './learning/usage-inference.js';
+import { createConsolidationCoordinator, } from './learning/consolidation-coordinator.js';
+import { LLMJudgeReplay, LiveReplay, BudgetedReplayJudge, ConditionalReplayJudge, StubJudge, } from './learning/replay.js';
+import { AgentReplayExecutor } from './learning/replay-executor.js';
+import { DefaultEnvironmentProvider, CompositeEnvironmentProvider, ReplayVerifierRegistry, buildReplayDescriptor, readReplayDescriptor, REPLAY_METADATA_KEY, } from './learning/replay-types.js';
+import { GitWorkspaceSnapshotStore, WorkspaceSnapshotProvider, } from './learning/workspace-snapshot.js';
+import { createUsageInference } from './learning/usage-inference.js';
 import { createRouter } from './search/router.js';
-import { createSolver } from './search/solver.js';
-import { createRefinementLoop, } from './search/refinement-loop.js';
+import { CostTracker, createRefinementLoop } from './search/refinement-loop.js';
 import { createAgentManager } from './runtime/manager.js';
-import { createSkillLibrary, } from './surfacing/skill-library.js';
+import { createSkillLibrary } from './surfacing/skill-library.js';
 import { SqliteStorageAdapter } from './surfacing/sqlite-storage-adapter.js';
+import { SharedSkillBank, resolveSharedBankPath } from './surfacing/shared-bank.js';
 import { join } from 'node:path';
 import { createSqlitePersistence } from './persistence/index.js';
-import { createPlaybookMCPServer, } from './mcp/playbook-server.js';
-import { createAgenticTaskRunner, } from './workspace/runner.js';
+import { createPlaybookMCPServer } from './mcp/playbook-server.js';
+import { 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';
+import { createExternalKnowledgeAcquisition, } from './learning/compound-bootstrap/index.js';
 /**
  * Atlas - Adaptive Trajectory Learning and Abstraction System
  *
@@ -34,30 +38,42 @@ export class Atlas {
     memory;
     unifiedPipeline;
     router;
-    solver = null;
     agentManager = null;
     refinementLoop = null;
     config;
-    provider = null;
+    /** Provider bound for LLM-backed learning (reflective generation + judge fallback). */
+    learningProvider = null;
+    /** Registry resolving a descriptor's `verifierId` → verifier for live replay. */
+    replayVerifiers = new ReplayVerifierRegistry();
+    /** When set, solves capture a workspace snapshot for faithful Regime-B replay. */
+    snapshotStore = null;
+    /** Retention policy for snapshot GC (dead-ref grace period + object reclaim). */
+    snapshotRetention = {
+        maxAgeMs: 24 * 60 * 60 * 1000,
+        gc: false,
+    };
+    snapshotGcRegistered = false;
     trajectoriesProcessed = 0;
-    teamTrajectoriesProcessed = 0;
     // Playbook-based components
     skillLibrary = null;
     skillTreeStorage = null;
+    sharedSkillBank = null;
     usageInference = null;
     mcpServer = null;
     // Agentic workspace components
     taskRunner = null;
     workspaceManager = null;
-    // Team-aware learning, recommendation, and surfacing
-    teamLearning = null;
-    teamRouter = null;
-    teamMetaLearner = null;
-    teamSkillLibrary = null;
+    analysisAgentManager = null;
+    analysisWorkspaceManager = null;
+    // External knowledge acquisition (cold-start bootstrap + diagnostic gap-fill)
+    externalAcquisition = null;
     // Unified SQLite persistence
     persistence;
+    // Dreaming / consolidation (Phase B)
+    consolidationCoordinator = null;
+    dreamTimer = null;
     constructor(config) {
-        this.config = createDefaultConfig(config);
+        this.config = applyValidationControls(createDefaultConfig(config));
         // Create unified SQLite persistence
         this.persistence = createSqlitePersistence({
             baseDir: this.config.storage.baseDir,
@@ -65,37 +81,46 @@ export class Atlas {
         });
         // Initialize memory system (with optional knowledge bank)
         this.memory = createMemorySystem(this.persistence, this.config.storage.baseDir, this.config.memory, this.config.knowledgeBank.enabled
-            ? { ...this.config.knowledgeBank, coherenceChecking: this.config.features.coherenceChecking }
+            ? {
+                ...this.config.knowledgeBank,
+                coherenceChecking: this.config.features.coherenceChecking,
+            }
             : undefined);
+        this.memory.setValidationControls(this.config.validation);
         // 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,
+                dreamQueue: this.config.features.dreamQueue,
+                mergeProposing: this.config.features.mergeProposing,
+                reflectiveMutation: this.config.features.reflectiveMutation,
+                curation: this.config.features.curation,
+                liftTracking: this.config.features.liftTracking,
+                additiveConsolidation: this.config.features.additiveConsolidation,
+            },
+            dream: {
+                maxRowsPerDream: this.config.dream.maxRowsPerDream,
+                maxBatchesPerDream: this.config.dream.maxBatchesPerDream,
+                leaseTtlMs: this.config.dream.leaseTtlMs,
+                maxAttempts: this.config.dream.maxAttempts,
             },
+            validation: this.config.validation,
         }, this.persistence);
-        // Initialize router (with persistence for MoEGate)
-        this.router = createRouter(this.memory, this.config.router, undefined, this.persistence);
-        // 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);
-        }
+        // Consolidation coordinator: decides when a dream runs (cadence +
+        // single-flight). Drives the idle scheduler and the explicit dream() API.
+        this.consolidationCoordinator = createConsolidationCoordinator(this.persistence, (opts) => this.unifiedPipeline.dream(opts), {
+            countThreshold: this.config.dream.countThreshold,
+            maxStalenessMs: this.config.dream.maxStalenessMs,
+        });
+        // Initialize router
+        this.router = createRouter(this.memory, this.config.router, undefined);
     }
     /**
      * Initialize Atlas (load persisted data)
@@ -103,7 +128,6 @@ export class Atlas {
     async init() {
         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)
@@ -113,18 +137,39 @@ export class Atlas {
         if (metaLearner) {
             this.router.setMetaLearner(metaLearner);
         }
+        // Initialize external knowledge acquisition (cold-start bootstrap)
+        if (this.memory.knowledgeBank) {
+            this.externalAcquisition = createExternalKnowledgeAcquisition();
+        }
         // Initialize playbook-based components if playbooks are available
         if (this.memory.playbooks) {
+            // PR-D2: wire write-time curation config into PlaybookLibrary.
+            this.memory.playbooks.setCurationConfig({
+                enabled: this.config.features.curation,
+            });
             // Load curated playbooks (bundled seed pack + additional dirs)
             await this.loadCuratedPlaybooks();
-            this.skillLibrary = createSkillLibrary(this.memory.playbooks, this.config.skillLibrary);
+            this.skillLibrary = createSkillLibrary(this.memory.playbooks, {
+                ...this.config.skillLibrary,
+                // Keep Atlas' two playbook injection channels aligned when the
+                // memory retriever is switched for an experiment.
+                retrieval: this.config.memory.playbookRetrieval.mode !== 'legacy'
+                    ? this.config.memory.playbookRetrieval
+                    : this.config.skillLibrary.retrieval,
+            });
             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);
+                // Optional shared-bank mirror: extracted playbooks are also written
+                // to a shared skill-tree filesystem bank (default ~/.skill-tree) so
+                // out-of-process consumers see them without an openhive bridge.
+                if (this.config.skillTree.sharedBank.enabled) {
+                    this.sharedSkillBank = new SharedSkillBank(resolveSharedBankPath(this.config.skillTree.sharedBank.path));
+                }
+                this.skillLibrary.setPublisher(this.skillTreeStorage, this.sharedSkillBank ?? undefined);
             }
             // Refresh skill tiers on init
             await this.skillLibrary.refreshTiers();
@@ -138,18 +183,24 @@ export class Atlas {
     async loadCuratedPlaybooks() {
         const cfg = this.config.curatedPlaybooks;
         const recreate = cfg.recreateOnInit;
-        // Load bundled seed pack (shipped with cognitive-core)
+        // Load bundled seed packs (shipped with cognitive-core). Cold-start
+        // semantics: bundled packs only seed an EMPTY library so a warm store is
+        // never retro-seeded on upgrade; `recreateOnInit` bypasses the check for
+        // explicit seed-update workflows.
         if (cfg.loadBundledSeedPack) {
-            const loadOpts = recreate
-                ? { recreate: true, sourceId: 'bundled' }
-                : { sourceId: 'bundled' };
-            await loadCuratedPlaybooksFn(BUNDLED_SEED_PACK_DIR, this.memory.playbooks, loadOpts);
+            const libraryEmpty = (await this.memory.playbooks.count()) === 0;
+            if (libraryEmpty || recreate) {
+                for (const pack of BUNDLED_SEED_PACKS) {
+                    const loadOpts = recreate
+                        ? { recreate: true, sourceId: pack.sourceId }
+                        : { sourceId: pack.sourceId };
+                    await loadCuratedPlaybooksFn(pack.dir, this.memory.playbooks, loadOpts);
+                }
+            }
         }
         // Load from additional directories (backward compat)
         for (const dir of cfg.additionalDirs) {
-            const loadOpts = recreate
-                ? { recreate: true, sourceId: dir }
-                : { sourceId: dir };
+            const loadOpts = recreate ? { recreate: true, sourceId: dir } : { sourceId: dir };
             await loadCuratedPlaybooksFn(dir, this.memory.playbooks, loadOpts);
         }
         // Resolve and load from sources (local paths + git repos)
@@ -192,12 +243,187 @@ export class Atlas {
         }
     }
     /**
-     * Set the LLM provider for solving (deprecated)
-     * @deprecated Use setAgentManager() with backends for real execution
+     * Register an LLM provider for LLM-backed learning — reflective playbook
+     * mutation and ReplayJudge-gated merge proposing. Independent of the
+     * solving path, so it can be used alongside `setAgentManager` (the
+     * recommended execution path, which uses backends rather than a single
+     * LLMProvider).
+     *
+     * The provider is bound into the maintenance loop and used to build a
+     * default {@link LLMJudgeReplay} for gating candidates. The
+     * `reflectiveMutation` / `mergeProposing` feature flags still gate
+     * whether those tasks actually run — without them set, this is a no-op
+     * at maintenance time.
      */
-    setProvider(provider) {
-        this.provider = provider;
-        this.solver = createSolver(this.memory, provider);
+    setLearningProvider(provider) {
+        this.learningProvider = provider;
+        // Bind the generator; install a default LLM judge ONLY if none is set, so
+        // a previously-installed live judge (enableLiveReplayGating) survives a
+        // later setLearningProvider call regardless of order.
+        this.unifiedPipeline.setLearningLLM(provider);
+        this.unifiedPipeline.setJudgeIfUnset(new LLMJudgeReplay(provider));
+    }
+    /**
+     * Register a verifier under an id so that live replay can score a
+     * reconstructed environment with a domain-appropriate signal. The id is
+     * stamped into an experience's replay descriptor (via the `replay` solve
+     * option) and resolved here at replay time.
+     */
+    registerReplayVerifier(id, verifier) {
+        this.replayVerifiers.register(id, verifier);
+    }
+    /**
+     * Enable Regime-B workspace snapshotting: each solve captures the working
+     * tree's initial state, so live-replay gating can later rematerialize it
+     * and score a candidate against the real end-state (build/tests). Defaults
+     * to a git-backed store; pass a custom store to override.
+     *
+     * Capture is best-effort and safe: non-git working trees (or capture
+     * failures) simply leave the experience non-snapshot-replayable, and
+     * gating falls back to the cheaper judge. Pair with a `replay.snapshot`
+     * solve hint to supply the verification command for scoring.
+     */
+    enableWorkspaceSnapshots(store, options) {
+        this.snapshotStore =
+            store ??
+                new GitWorkspaceSnapshotStore({
+                    excludePathspecs: options?.excludePathspecs,
+                });
+        if (options?.maxAgeMs !== undefined)
+            this.snapshotRetention.maxAgeMs = options.maxAgeMs;
+        if (options?.gc !== undefined)
+            this.snapshotRetention.gc = options.gc;
+        this.registerSnapshotGcTask();
+    }
+    /**
+     * Register the snapshot-gc maintenance task (once). It scans live
+     * experiences for the snapshot refs still in use, then prunes each repo's
+     * anchored snapshots that are no longer referenced and past the grace
+     * period — bounding the unbounded ref growth from per-solve capture.
+     */
+    registerSnapshotGcTask() {
+        if (this.snapshotGcRegistered)
+            return;
+        this.snapshotGcRegistered = true;
+        this.unifiedPipeline.registerMaintenanceTask({
+            name: 'snapshot-gc',
+            priority: 40,
+            execute: async () => {
+                const start = Date.now();
+                const store = this.snapshotStore;
+                if (!store?.prune) {
+                    return {
+                        taskName: 'snapshot-gc',
+                        success: true,
+                        durationMs: Date.now() - start,
+                        details: { skipped: true, reason: 'no prunable snapshot store' },
+                    };
+                }
+                // Refs still referenced by a live experience — never pruned.
+                const liveByRepo = new Map();
+                for (const exp of await this.memory.experiences.getAll()) {
+                    const snap = readReplayDescriptor(exp)?.snapshot;
+                    if (!snap?.ref || !snap.repo)
+                        continue;
+                    let set = liveByRepo.get(snap.repo);
+                    if (!set) {
+                        set = new Set();
+                        liveByRepo.set(snap.repo, set);
+                    }
+                    set.add(snap.ref);
+                }
+                // Visit repos referenced by live experiences plus any the store
+                // captured into (covers repos whose experiences were all evicted).
+                const repos = new Set([...liveByRepo.keys(), ...(store.knownRepos?.() ?? [])]);
+                let refsPruned = 0;
+                for (const repo of repos) {
+                    try {
+                        refsPruned += await store.prune(repo, {
+                            keepRefs: liveByRepo.get(repo) ?? new Set(),
+                            minAgeMs: this.snapshotRetention.maxAgeMs,
+                            gc: this.snapshotRetention.gc,
+                        });
+                    }
+                    catch {
+                        // one bad repo shouldn't kill the cycle
+                    }
+                }
+                return {
+                    taskName: 'snapshot-gc',
+                    success: true,
+                    durationMs: Date.now() - start,
+                    details: { reposScanned: repos.size, refsPruned },
+                };
+            },
+        });
+    }
+    /**
+     * Set (or replace) the ReplayJudge that gates playbook mutations/merges,
+     * without touching the LLM generator. Use to plug in a custom or live
+     * judge. Most callers want {@link enableLiveReplayGating} instead.
+     */
+    setLearningJudge(judge) {
+        this.unifiedPipeline.setJudge(judge);
+    }
+    /**
+     * Upgrade mutation/merge gating to a {@link LiveReplay} judge: candidates
+     * are scored by actually re-running their task through the AgentManager
+     * with the candidate playbook pinned in context, then verifying the
+     * outcome. Accurate but expensive — intended for high-stakes acceptance.
+     *
+     * Requires `setAgentManager(...)` to have been called (it needs real
+     * compute to run rollouts). Optionally caps rollouts per rolling window
+     * via {@link BudgetedReplayJudge}, routing overflow to `fallback` (or a
+     * neutral judge) so the maintenance loop never runs away on cost.
+     *
+     * Note: this supplies the *judge*. Reflective mutation also needs an LLM
+     * *generator* — pair with `setLearningProvider(...)` for the full
+     * high-stakes reflective path; merge proposing works with the judge alone.
+     */
+    enableLiveReplayGating(options) {
+        if (!this.agentManager) {
+            throw new Error('enableLiveReplayGating() requires setAgentManager(...) first — live ' +
+                'replay re-runs tasks through the AgentManager.');
+        }
+        const agentType = options?.agentType ?? this.config.execution.defaultAgentType;
+        // Compose providers: the workspace-snapshot provider (Regime B) takes
+        // precedence over the descriptor/env-MCP provider (Phase 1) when both
+        // could apply. Falls back to the default provider alone when snapshots
+        // aren't enabled.
+        const provider = options?.environmentProvider ??
+            (this.snapshotStore
+                ? new CompositeEnvironmentProvider([
+                    new WorkspaceSnapshotProvider(this.snapshotStore, {
+                        agentType,
+                        verifyTimeoutMs: options?.timeoutMs,
+                    }),
+                    new DefaultEnvironmentProvider(this.replayVerifiers),
+                ])
+                : new DefaultEnvironmentProvider(this.replayVerifiers));
+        const executor = new AgentReplayExecutor(this.agentManager, {
+            agentType,
+            verifier: options?.verifier,
+            timeoutMs: options?.timeoutMs,
+            environmentProvider: provider,
+            reconstructTask: options?.reconstructTask,
+        });
+        // The expensive, faithful path — optionally rate-limited.
+        let live = new LiveReplay(executor);
+        if (options?.maxRolloutsPerWindow !== undefined) {
+            live = new BudgetedReplayJudge(live, {
+                maxCalls: options.maxRolloutsPerWindow,
+                windowMs: options.windowMs,
+                fallback: options.fallback,
+            });
+        }
+        // Cheap path for experiences whose env can't be faithfully rebuilt.
+        const fallback = options?.fallback ??
+            (this.learningProvider
+                ? new LLMJudgeReplay(this.learningProvider)
+                : new StubJudge(() => 0.5));
+        // Route each experience: faithfully-replayable → live, else → fallback.
+        const judge = new ConditionalReplayJudge((_pb, exp) => provider.isReplayable(exp), live, fallback);
+        this.unifiedPipeline.setJudge(judge);
     }
     /**
      * Set up the AgentManager with backends for real action execution
@@ -208,6 +434,10 @@ export class Atlas {
         this.agentManager = createAgentManager(this.memory, {
             delegate: options?.delegate,
         });
+        // PR-D2: wire helpfulness-weighted injection re-rank from features config.
+        this.agentManager.setCurationEnabled(this.config.features.curation);
+        // Exp 4: wire section-level playbook incorporation from memory config.
+        this.agentManager.setIncorporation(this.config.memory?.playbookRetrieval?.incorporation ?? 'full');
         // Register all backends
         for (const backend of backends) {
             this.agentManager.registerBackend(backend);
@@ -220,22 +450,55 @@ export class Atlas {
         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, this.memory, {
             maxIterations: this.config.refinement.maxIterations,
             minAcceptableScore: this.config.refinement.acceptableScore,
             evaluatorConfig: {
                 evaluatorAgentType: this.config.refinement.evaluatorAgentType,
+                // When false, the evaluator scores heuristically instead of spawning
+                // a live evaluation agent — the registered OutcomeVerifier still
+                // drives the refine/accept decision. (Decoupled from eligibility
+                // below, so refinement can fire with heuristic evaluation.)
+                useAgentEvaluation: this.config.refinement.useAgentEvaluation,
             },
             triggerOnStrategies: this.config.refinement.triggerOnStrategies,
             confidenceThreshold: this.config.refinement.confidenceThreshold,
         });
-        // Connect task runner to refinement loop for workspace-based evaluation and analysis
-        this.refinementLoop.setTaskRunner(this.taskRunner);
+        // Connect task runner to refinement loop for workspace-based evaluation and
+        // analysis — ONLY when agentic evaluation is enabled. When disabled (e.g. an
+        // eval harness driving refinement via an OutcomeVerifier), withholding the
+        // task runner makes BOTH the evaluator (evaluate()) and the refinement-plan
+        // analysis (getRefinementPlan) fall back to heuristic, so no internal
+        // template spawn hangs waiting for a done() it never calls. The task agent
+        // itself still runs via agentManager.spawn.
+        if (this.config.refinement.useAgentEvaluation) {
+            this.refinementLoop.setTaskRunner(this.taskRunner);
+        }
+        if (this.externalAcquisition) {
+            this.refinementLoop.setExternalAcquisition(this.externalAcquisition);
+        }
+    }
+    /**
+     * Configure a separate AgentManager for offline analysis tasks such as
+     * playbook extraction. This keeps benchmark delegates on the solve path from
+     * accidentally handling workspace-abstraction prompts.
+     */
+    setAnalysisAgentManager(backends) {
+        this.analysisAgentManager = createAgentManager(this.memory);
+        this.analysisAgentManager.setCurationEnabled(this.config.features.curation);
+        for (const backend of backends) {
+            this.analysisAgentManager.registerBackend(backend);
+        }
+        this.analysisWorkspaceManager = new WorkspaceManager({
+            baseDir: this.config.agenticTasks.workspaceBaseDir,
+            prefix: 'atlas-analysis-workspaces',
+        });
+        const analysisRunner = createAgenticTaskRunner(this.analysisWorkspaceManager, this.analysisAgentManager, this.memory, this.unifiedPipeline, this.config.agenticTasks);
+        this.unifiedPipeline.setTaskRunner(analysisRunner);
+    }
+    setLearningDiagnosticsCollector(collector) {
+        this.unifiedPipeline.setDiagnosticsCollector(collector);
     }
     /**
      * Get the AgentManager for direct access
@@ -259,12 +522,51 @@ export class Atlas {
     getDelegate() {
         return this.agentManager?.getDelegate();
     }
+    /**
+     * Disable workspace-based agentic analysis on the per-solve hot path
+     * (playbook usage inference + meta-reflection), forcing their heuristic
+     * fallbacks. Without this, each `solve()` spawns extra workspace analysis
+     * agents — which, behind a real agent delegate, means several nested agent
+     * calls per task. Eval harnesses call this so each solve is a single agent
+     * call. Learning fidelity is preserved: experience storage and immediate
+     * learning are unaffected; only the heavyweight agentic post-analysis is
+     * downgraded to its heuristic path.
+     */
+    disableAgenticAnalysis() {
+        this.disableAgenticHotPathAnalysis();
+        // Also clear the pipeline's task runner so batch/dream analysis + playbook
+        // extraction use the heuristic path (no workspace-agent spawns). Without
+        // this, a dream that runs extraction (e.g. an eval that lowers
+        // minTrajectories) would still spawn agents despite "agentic analysis"
+        // being disabled.
+        this.unifiedPipeline.setTaskRunner(null);
+    }
+    /**
+     * Disable only solve-time workspace analysis (usage inference +
+     * meta-reflection). Batch/dream extraction can still use a separately
+     * configured analysis runner.
+     */
+    disableAgenticHotPathAnalysis() {
+        this.taskRunner = null;
+    }
     /**
      * Get the RefinementLoop for registering domain verifiers
      */
     getRefinementLoop() {
         return this.refinementLoop;
     }
+    /**
+     * Register a pluggable outcome verifier so a domain (e.g. a benchmark
+     * harness) can mark self-reported successes as mis-executed and route them
+     * into refinement. Requires the AgentManager to be initialized first
+     * (via setAgentManager).
+     */
+    setOutcomeVerifier(verifier) {
+        if (!this.refinementLoop) {
+            throw new Error('RefinementLoop not initialized. Call setAgentManager() first.');
+        }
+        this.refinementLoop.setOutcomeVerifier(verifier);
+    }
     /**
      * Get the AgenticTaskRunner for running analysis tasks
      */
@@ -281,21 +583,47 @@ export class Atlas {
      * Solve a task using the best available method
      * Prefers AgentManager with refinement when available
      */
-    async solve(task) {
+    async solve(task, options) {
         // Route the task first
-        const routing = await this.router.route(task);
+        let routing = await this.router.route(task, options);
+        // Cold-start bootstrap: when router returns fallback and domain has
+        // sparse knowledge, analyze the workspace and synthesize notes so the
+        // agent has context on its first encounter with a new domain.
+        if (this.externalAcquisition &&
+            this.memory.knowledgeBank &&
+            routing.strategy === 'fallback' &&
+            this.validationCanWrite('knowledgeNote')) {
+            const domainNotes = await this.memory.knowledgeBank.search(task.domain ?? task.description.slice(0, 80), { maxResults: 5 });
+            if (this.externalAcquisition.shouldBootstrap(routing.strategy, domainNotes.length)) {
+                const workspacePath = this.workspaceManager ? this.config.storage.baseDir : undefined;
+                const { notes } = await this.externalAcquisition.bootstrap(task, workspacePath);
+                if (notes.length > 0) {
+                    await this.memory.knowledgeBank.applyExtraction({
+                        observations: notes,
+                        entityUpdates: [],
+                        contradictions: [],
+                        links: [],
+                        playbookLinks: [],
+                    });
+                    routing = await this.router.route(task, options);
+                }
+            }
+        }
+        const servedMemoryContext = this.filterMemoryForServing(routing.memoryContext);
         // Get skills for the agent if skill library is available
         let injectedPlaybooks = [];
         let skillContext = '';
-        if (this.skillLibrary) {
+        if (this.skillLibrary &&
+            this.validationCanRetrieve('playbooks') &&
+            this.validationCanServe('playbooks')) {
             const skills = await this.skillLibrary.getSkillsForAgent(task);
             injectedPlaybooks = [...skills.core, ...skills.domain, ...skills.contextual];
             skillContext = this.skillLibrary.formatForSystemPrompt(skills);
         }
         // Merge playbooks from router's memory context (deduplicating by ID)
         // This ensures we track ALL playbooks that will be injected into the agent
-        const injectedIds = new Set(injectedPlaybooks.map(p => p.id));
-        for (const { playbook } of routing.memoryContext.playbooks) {
+        const injectedIds = new Set(injectedPlaybooks.map((p) => p.id));
+        for (const { playbook } of servedMemoryContext.playbooks) {
             if (!injectedIds.has(playbook.id)) {
                 injectedPlaybooks.push(playbook);
                 injectedIds.add(playbook.id);
@@ -304,33 +632,29 @@ export class Atlas {
         // Surface knowledge from knowledge bank (independent from skill surfacing)
         let knowledgeContext = '';
         let surfacedKnowledge;
-        if (this.memory.knowledgeBank) {
-            surfacedKnowledge = await this.memory.knowledgeBank.getRelevantKnowledge({ description: task.description, domain: task.domain });
+        if (this.memory.knowledgeBank &&
+            this.validationCanRetrieve('knowledge') &&
+            this.validationCanServe('knowledge')) {
+            surfacedKnowledge = await this.memory.knowledgeBank.getRelevantKnowledge({
+                description: task.description,
+                domain: task.domain,
+            });
             if (surfacedKnowledge.length > 0) {
                 knowledgeContext = this.memory.knowledgeBank.formatKnowledgeForPrompt(surfacedKnowledge);
             }
         }
+        else if (this.memory.knowledgeBank) {
+            surfacedKnowledge = [];
+        }
         // Combine skill context + knowledge context
-        const combinedContext = [skillContext, knowledgeContext]
-            .filter(Boolean)
-            .join('\n\n');
+        const combinedContext = [skillContext, knowledgeContext].filter(Boolean).join('\n\n');
         let result;
-        // Prefer AgentManager if available
+        // AgentManager is the only execution path.
         if (this.agentManager) {
-            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);
-            result = {
-                trajectory: solverResult.trajectory,
-                usedMemory: solverResult.usedMemory,
-                strategy: solverResult.strategy,
-                usedAgentManager: false,
-            };
+            result = await this.solveWithAgent(task, routing, servedMemoryContext, combinedContext || undefined, options?.spawnConfig, options?.replay, options?.costBudgetUsd);
         }
         else {
-            throw new Error('No execution method available. Call setAgentManager() or setProvider().');
+            throw new Error('No execution method available. Call setAgentManager().');
         }
         // Add injected playbooks to result
         result.injectedPlaybooks = injectedPlaybooks;
@@ -340,6 +664,7 @@ export class Atlas {
             const usageResults = await this.inferPlaybookUsage(result.trajectory, injectedPlaybooks);
             // Convert to PlaybookUsage format and record outcomes
             result.playbookUsage = [];
+            const canWritePlaybookOutcomes = this.validationCanWrite('playbook');
             for (const usage of usageResults) {
                 result.playbookUsage.push({
                     playbookId: usage.playbookId,
@@ -348,65 +673,224 @@ export class Atlas {
                     usageConfidence: usage.usageConfidence,
                     wasSuccessful: usage.wasSuccessful,
                 });
-                // Record outcome for tier management
-                if (usage.wasUsed) {
+                // Record outcome for tier management (skill-library tier; always on wasUsed).
+                if (usage.wasUsed && canWritePlaybookOutcomes) {
                     await this.skillLibrary.recordOutcome(usage.playbookId, result.trajectory.id, usage.wasSuccessful, usage.context);
+                    // PR-D2 (legacy path): wasUsed-gated counter update.
+                    // Only active when injectionPresenceCredit is OFF (ablation arm).
+                    // When injectionPresenceCredit is ON the counters are updated below
+                    // via attribution across ALL injected playbooks, not just wasUsed ones
+                    // — so we must not also call recordSuccess/recordFailure here or we
+                    // double-count the wasUsed subset.
+                    if (this.config.features.curation && !this.config.features.injectionPresenceCredit) {
+                        if (usage.wasSuccessful) {
+                            await this.memory.playbooks.recordSuccess(usage.playbookId, result.trajectory.id);
+                        }
+                        else {
+                            await this.memory.playbooks.recordFailure(usage.playbookId, result.trajectory.id, usage.context ?? '', 'playbook-application-failure');
+                        }
+                    }
+                }
+            }
+            // F6: Injection-presence credit — attribute task outcome fractionally across
+            // ALL injected playbooks weighted by retrieval score.  This replaces the
+            // wasUsed-gated counter path for the normal (injectionPresenceCredit=true) arm.
+            // The skillLibrary.recordOutcome() tier-management call above is KEPT — it is
+            // gated on wasUsed and manages skill-tier promotion/demotion, not counters.
+            if (this.config.features.curation &&
+                this.config.features.injectionPresenceCredit &&
+                canWritePlaybookOutcomes) {
+                const taskSucceeded = result.trajectory.outcome.success;
+                const credits = attributeCredit(servedMemoryContext.playbooks);
+                for (const { id, weight } of credits) {
+                    await this.memory.playbooks.recordApplicationOutcome(id, taskSucceeded, weight);
                 }
             }
         }
-        // Generate meta-reflection (records observation + periodically generates strategies)
-        const metaLearner = this.unifiedPipeline.getMetaLearner();
-        if (metaLearner) {
-            await this.reflectOnExecution(result.trajectory, routing);
-        }
-        // 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);
+        // Phase 2 — meta-reflection + effectiveness annotation. These are deferred
+        // to the dream via a routing snapshot persisted on the queue row.
+        // (Usage inference above stays inline — it is SkillLibrary-coupled and
+        // produces the synchronous solve result.)
+        const appliedPlaybookIds = (result.playbookUsage ?? [])
+            .filter((u) => u.wasUsed)
+            .map((u) => u.playbookId);
+        const surfacedExperienceIds = servedMemoryContext.experiences.map((e) => e.experience.id);
+        const surfacedKnowledgeNoteIds = [
+            ...(servedMemoryContext.knowledge ?? []).map((m) => m.note.frontmatter.id),
+            ...(surfacedKnowledge ?? []).map((m) => m.note.frontmatter.id),
+        ];
+        const snapshot = {
+            routingInfo: {
+                strategy: routing.strategy,
+                confidence: routing.confidence,
+                estimatedBudget: routing.estimatedBudget,
+                reasoning: routing.reasoning,
+                appliedStrategyIds: routing.appliedStrategyIds,
+            },
+            playbookMatchRefs: servedMemoryContext.playbooks.map((p) => ({
+                id: p.playbook.id,
+                score: p.score,
+                matchType: p.matchType,
+            })),
+            surfacedExperienceIds,
+            appliedPlaybookIds,
+            surfacedKnowledgeNoteIds,
+        };
+        const immediateResult = await this.unifiedPipeline.processTrajectory(result.trajectory, JSON.stringify(snapshot));
         this.trajectoriesProcessed++;
+        // FIX 2 (ADDITIVE LEARNING, default OFF): unify frontier accounting with
+        // INJECTION. The instant loop only writes frontier rows for playbooks
+        // caught by the legacy 0.3 lexical findMatching, and injection-presence
+        // credit updates counters (recordApplicationOutcome) without touching the
+        // frontier — so an injected+reused playbook accrues no frontier row and
+        // stays invisible to the mutation-gate minibatch sampler. Here we record a
+        // frontier/live outcome for the playbooks that were actually SERVED (hybrid
+        // retrieval @ minScore), so reused playbooks accumulate frontier rows
+        // aligned with what was injected. Dedup: upsertFrontierRow is keyed by
+        // (task_signature, experience_id, playbook_id) with MAX(score), so
+        // re-writing a row the instant loop already wrote for THIS solve is
+        // idempotent — no double count. Distinct solves have distinct experience
+        // ids, which is exactly how a reused playbook reaches ≥2 minibatch rows.
+        if (this.config.features.additiveConsolidation && this.validationCanWrite('frontier')) {
+            const experienceId = immediateResult.instantLoop.experienceId;
+            if (experienceId) {
+                const sig = taskSignature(result.trajectory.task);
+                const score = result.trajectory.outcome.success
+                    ? Math.max(result.trajectory.outcome.partialScore, 1.0)
+                    : result.trajectory.outcome.partialScore;
+                const objectives = deriveObjectives(result.trajectory);
+                for (const { playbook } of servedMemoryContext.playbooks) {
+                    try {
+                        await this.memory.playbooks.recordLiveOutcome(playbook.id, sig, experienceId, score, objectives);
+                    }
+                    catch {
+                        // Non-fatal — frontier bookkeeping must never fail the solve.
+                    }
+                }
+            }
+        }
+        // Populate extraction yield from the instant-loop result.
+        const il = immediateResult.instantLoop;
+        const byType = {};
+        if (il.experienceId)
+            byType['experience'] = 1;
+        if (il.knowledgeNotesExtracted > 0)
+            byType['knowledge'] = il.knowledgeNotesExtracted;
+        const itemsStored = Object.values(byType).reduce((a, b) => a + b, 0);
+        result.extractionYield = { itemsStored, byType };
+        // Dreaming hooks: optionally consolidate synchronously (eval determinism),
+        // then (re)arm the idle scheduler if enabled.
+        await this.maybeConsolidateInline();
+        this.scheduleDreamCheck();
         return result;
     }
     /**
      * Solve using AgentManager with optional refinement
      */
-    async solveWithAgent(task, routing, skillContext) {
+    /**
+     * Stamp a replay descriptor onto a trajectory's metadata from the spawn
+     * config it ran under. Auto-captures the env (env-MCP / cwd / agentType);
+     * the optional hint adds verifierId / envHandle / reconstructable overrides.
+     */
+    /**
+     * If workspace snapshotting is enabled, capture the spawn cwd's initial
+     * state and fold the snapshot handle into the replay hint (preserving any
+     * caller-supplied verifyCommand/successPattern). No-op / unchanged hint
+     * when snapshotting is off or capture isn't possible.
+     */
+    async captureSnapshotHint(spawnConfig, hint) {
+        if (!this.snapshotStore)
+            return hint;
+        const dir = spawnConfig.cwd ?? process.cwd();
+        let snapshot = null;
+        try {
+            snapshot = await this.snapshotStore.capture(dir);
+        }
+        catch {
+            snapshot = null; // capture is best-effort
+        }
+        if (!snapshot)
+            return hint;
+        return {
+            ...hint,
+            snapshot: {
+                ...(hint?.snapshot ?? {}),
+                ref: snapshot.ref,
+                repo: snapshot.repo,
+            },
+        };
+    }
+    stampReplayDescriptor(trajectory, spawnConfig, hint) {
+        const descriptor = buildReplayDescriptor({
+            mcpServers: spawnConfig.mcpServers,
+            cwd: spawnConfig.cwd,
+            agentType: spawnConfig.agentType,
+        }, hint);
+        trajectory.metadata = { ...(trajectory.metadata ?? {}), [REPLAY_METADATA_KEY]: descriptor };
+    }
+    async solveWithAgent(task, routing, servedMemoryContext, skillContext, spawnConfigOverride, replayHint, costBudgetUsd) {
         if (!this.agentManager) {
             throw new Error('AgentManager not available');
         }
         // Build spawn configuration
         const spawnConfig = {
             agentType: this.config.execution.defaultAgentType,
-            task,
             timeout: this.config.execution.maxExecutionTime * 1000,
             captureToolCalls: this.config.execution.captureToolCalls,
             // Inject skill context if available
             systemPromptAdditions: skillContext || undefined,
-            // Pass router's memory context to avoid duplicate memory queries
-            injectedKnowledge: routing.memoryContext,
+            // Pass the already serving-filtered router memory context to avoid duplicate queries.
+            injectedKnowledge: servedMemoryContext,
+            // Preserve the raw retrieval result for eval diagnostics so traces can
+            // distinguish retrieved-but-masked candidates from genuinely empty retrieval.
+            diagnosticKnowledge: routing.memoryContext,
+            // Per-call overrides (e.g. mcpServers, a caller-owned customer prompt).
+            // Shallow-merged before `task` is pinned so a caller can supply
+            // task-scoped execution context without disturbing the default build.
+            ...(spawnConfigOverride ?? {}),
+            // `task` is always the routed task; an override cannot redirect it.
+            task,
         };
+        // Regime B: snapshot the working tree's INITIAL state BEFORE the agent
+        // mutates it, so a replay rematerializes the same starting world. The
+        // captured ref is merged into the descriptor hint. Best-effort & safe:
+        // non-git dirs / failures just leave the experience non-snapshot-replayable.
+        const effectiveHint = await this.captureSnapshotHint(spawnConfig, replayHint);
         // Run initial execution
         const agentResult = await this.agentManager.spawn(spawnConfig);
-        // Check if refinement should be triggered
-        const shouldRefine = this.refinementLoop &&
-            this.config.refinement.useAgentEvaluation &&
+        // Capture a replay descriptor of the environment this ran under, so the
+        // experience derived from this trajectory can later be re-run faithfully
+        // by live-replay gating. Rides the trajectory.metadata channel that
+        // storeTrajectory() already spreads into experience.metadata.
+        this.stampReplayDescriptor(agentResult.trajectory, spawnConfig, effectiveHint);
+        // Check if refinement is eligible for this route (strategy + confidence).
+        // Eligibility is decoupled from useAgentEvaluation: that flag controls only
+        // HOW the evaluator scores (agentic vs heuristic), not WHETHER we refine —
+        // an external OutcomeVerifier can drive refinement with heuristic scoring.
+        const eligibleForRefinement = this.refinementLoop &&
             this.refinementLoop.shouldTriggerRefinement(routing.strategy, routing.confidence);
         let refinementResult;
-        if (shouldRefine && !agentResult.success) {
-            // Run refinement loop on failed trajectory
-            refinementResult = await this.refinementLoop.refine(agentResult.trajectory, spawnConfig);
-            return {
-                trajectory: refinementResult.trajectory,
-                routing,
-                usedAgentManager: true,
-                refinement: refinementResult,
-            };
+        if (eligibleForRefinement) {
+            // Decouple from the success-only gate: refinement triggers on
+            // (verifier says retry) OR (hard failure). The default pass-through
+            // verifier preserves the previous success-only behavior.
+            const { refine, verdict } = await this.refinementLoop.shouldRefineOutcome({ success: agentResult.success, trajectory: agentResult.trajectory }, task);
+            if (refine) {
+                // Thread the verdict through so refine() skips its cheap early-return
+                // for a misexecuted-but-success trajectory and surfaces verdict.reason
+                // into the retry prompt.
+                const tracker = costBudgetUsd != null ? new CostTracker(costBudgetUsd) : undefined;
+                refinementResult = await this.refinementLoop.refine(agentResult.trajectory, spawnConfig, verdict, tracker);
+                // Refinement re-spawns with the same spawnConfig (env unchanged), so
+                // the same descriptor applies to the refined trajectory.
+                this.stampReplayDescriptor(refinementResult.trajectory, spawnConfig, effectiveHint);
+                return {
+                    trajectory: refinementResult.trajectory,
+                    routing,
+                    usedAgentManager: true,
+                    refinement: refinementResult,
+                };
+            }
         }
         return {
             trajectory: agentResult.trajectory,
@@ -433,129 +917,112 @@ export class Atlas {
         // Unified pipeline handles immediate + batch (if energy triggers)
         const result = await this.unifiedPipeline.processTrajectory(trajectory);
         this.trajectoriesProcessed++;
+        // Dreaming hooks (see solve()).
+        await this.maybeConsolidateInline();
+        this.scheduleDreamCheck();
         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.
+     * Run a consolidation pass ("dream"): drain the durable dream_queue and run
+     * batch + maintenance over it. This is the decoupled replacement for inline
+     * batch learning — call it explicitly, on a schedule, or at close. A no-op
+     * (empty result) when there is nothing to drain or a dream is already running.
      */
-    async processTeamTrajectory(trajectory) {
-        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() {
-        if (!this.teamLearning)
-            return null;
-        return this.teamLearning.runBatchLearning();
+    async dream(opts) {
+        return this.unifiedPipeline.dream(opts);
     }
     /**
-     * Get the team learning pipeline for direct access.
+     * Get the consolidation coordinator (cadence + single-flight) for direct
+     * access — e.g. to drive `maybeDream()` from an external scheduler.
      */
-    getTeamLearning() {
-        return this.teamLearning;
+    getConsolidationCoordinator() {
+        return this.consolidationCoordinator;
     }
     /**
-     * Recommend a team composition for a given task.
-     * Uses team playbooks and meta-strategies to produce a recommendation
-     * with optional OpenTeams YAML export.
+     * Synchronously consolidate after a solve/process call when configured —
+     * gives eval harnesses "free consolidation" determinism. No-op unless
+     * `dream.consolidateInline` is set.
      */
-    async recommendTeam(input) {
-        if (!this.teamRouter) {
-            throw new Error('Team learning is not enabled. Set teamLearning.enabled = true in config.');
+    async maybeConsolidateInline() {
+        if (!this.validationAllowsStableMutation())
+            return;
+        if (this.config.dream.consolidateInline) {
+            await this.dream({ drainAll: true });
         }
-        return this.teamRouter.recommend(input);
     }
     /**
-     * Get the team router for direct access.
+     * (Re)arm the in-process idle timer. Each solve/process resets it; on fire it
+     * asks the coordinator to dream if the cadence policy says it's due. Opt-in
+     * via `dream.scheduler.enabled`. The timer is unref'd so it never keeps the
+     * process alive on its own.
      */
-    getTeamRouter() {
-        return this.teamRouter;
+    scheduleDreamCheck() {
+        if (!this.validationAllowsStableMutation())
+            return;
+        if (!this.config.dream.scheduler.enabled || !this.consolidationCoordinator)
+            return;
+        if (this.dreamTimer)
+            clearTimeout(this.dreamTimer);
+        this.dreamTimer = setTimeout(() => {
+            this.dreamTimer = null;
+            void this.consolidationCoordinator.maybeDream().catch((error) => {
+                logger.error('[Atlas] Scheduled dream failed:', error instanceof Error ? error.message : String(error));
+            });
+        }, this.config.dream.scheduler.idleMs);
+        this.dreamTimer.unref?.();
     }
     /**
-     * Get the team meta-learner for direct access.
+     * Flip the validation mutation policy at runtime. Used by the live eval
+     * harness to FREEZE the learner during the held-out eval phase of a
+     * train/eval split: with `frozen`, `processTrajectory` becomes a no-op (no
+     * experience store, no dream-queue enqueue) and all write channels are
+     * gated off, so eval trajectories never train the learner — while retrieval
+     * and serving stay live so the trained memory is still injected. This
+     * enforces the train/eval isolation described in
+     * docs/DESIGN-meta-learning-validation.md § "Train-time oracle signal vs
+     * solve-time firewall". The pipeline shares this validation object by
+     * reference, so the flip applies to both Atlas and the pipeline gates.
      */
-    getTeamMetaLearner() {
-        return this.teamMetaLearner;
+    setValidationMutationMode(mode) {
+        this.config.validation.mutationMode = mode;
+        this.memory.setValidationControls(this.config.validation);
     }
-    /**
-     * Get the team skill library for direct access.
-     */
-    getTeamSkillLibrary() {
-        return this.teamSkillLibrary;
+    validationAllowsStableMutation() {
+        return !this.config.validation.enabled || this.config.validation.mutationMode === 'active';
     }
-    /**
-     * 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) {
-        if (!this.teamSkillLibrary) {
-            throw new Error('Team learning is not enabled. Set teamLearning.enabled = true in config.');
-        }
-        await this.teamSkillLibrary.recordTeamOutcome(feedback);
+    validationCanWrite(channel) {
+        if (!this.config.validation.enabled)
+            return true;
+        if (this.config.validation.mutationMode !== 'active')
+            return false;
+        return this.config.validation.channelMasks.write.includes(channel);
     }
-    /**
-     * Format role guidance for injection into an agent's system prompt.
-     * Returns markdown-formatted role playbook content for the given role.
-     */
-    async formatRoleGuidance(role, context) {
-        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));
+    validationCanRetrieve(channel) {
+        if (!this.config.validation.enabled)
+            return true;
+        return this.config.validation.channelMasks.retrieval.includes(channel);
     }
-    /**
-     * Query team memory for coordination patterns.
-     */
-    async queryTeamMemory(query, options) {
-        const results = {
-            experiences: [],
-            playbooks: [],
+    validationCanServe(channel) {
+        if (!this.config.validation.enabled)
+            return true;
+        return this.config.validation.channelMasks.serving.includes(channel);
+    }
+    filterMemoryForServing(memoryContext) {
+        if (!this.config.validation.enabled)
+            return memoryContext;
+        return {
+            ...memoryContext,
+            experiences: this.validationCanServe('experiences') ? memoryContext.experiences : [],
+            playbooks: this.validationCanServe('playbooks') ? memoryContext.playbooks : [],
+            knowledge: this.validationCanServe('knowledge') ? memoryContext.knowledge : [],
         };
-        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
+     * Run batch learning explicitly. Drains the durable dream_queue via `dream()`
+     * and returns the aggregate batch result.
      */
     async runBatchLearning() {
-        return this.unifiedPipeline.runBatch();
+        return (await this.dream({ drainAll: true })).batch;
     }
     /**
      * Query memory for relevant context
@@ -573,19 +1040,8 @@ export class Atlas {
             learning: {
                 trajectoriesProcessed: this.trajectoriesProcessed,
                 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 = {
@@ -611,6 +1067,14 @@ export class Atlas {
     getMemory() {
         return this.memory;
     }
+    /**
+     * Get the unified SQLite persistence handle for direct access — e.g. to
+     * inspect the dream_queue (pending/processing counts) or drive a dream from
+     * an external scheduler.
+     */
+    getPersistence() {
+        return this.persistence;
+    }
     /**
      * Get the knowledge bank for direct access (null if not enabled)
      */
@@ -651,7 +1115,12 @@ export class Atlas {
         if (this.mcpServer) {
             return; // Already started
         }
-        this.mcpServer = createPlaybookMCPServer(this.memory.playbooks, this.skillLibrary ?? undefined, this.config.mcp);
+        // Pass `this` as the in-process learning surface (G7) so the server can
+        // expose ingest/extract/promote tools that drive the same-process loop.
+        // Because the server is long-running and shares this Atlas instance, the
+        // ingest tool keeps the in-memory batch accumulator warm — sidestepping
+        // the fresh-process-empties-the-accumulator problem of CLI-per-trajectory.
+        this.mcpServer = createPlaybookMCPServer(this.memory.playbooks, this.skillLibrary ?? undefined, this.config.mcp, this);
     }
     /**
      * Stop the MCP server
@@ -687,7 +1156,7 @@ export class Atlas {
                 return result.output;
             }
             catch (error) {
-                console.error('Workspace-based usage inference failed, falling back to heuristic:', error instanceof Error ? error.message : error);
+                logger.error('Workspace-based usage inference failed, falling back to heuristic:', error instanceof Error ? error.message : error);
             }
         }
         // Heuristic fallback
@@ -696,41 +1165,6 @@ export class Atlas {
         }
         return [];
     }
-    /**
-     * Reflect on execution via workspace template when taskRunner available,
-     * otherwise fall back to MetaLearner's built-in heuristic reflection.
-     */
-    async reflectOnExecution(trajectory, routing) {
-        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
      */
@@ -746,16 +1180,17 @@ export class Atlas {
     async close() {
         // Stop MCP server if running
         await this.stopMCPServer();
-        // Flush unified pipeline
-        if (this.unifiedPipeline.getAccumulatedCount() > 0) {
-            await this.unifiedPipeline.runBatch();
+        // Cancel any pending idle-dream timer.
+        if (this.dreamTimer) {
+            clearTimeout(this.dreamTimer);
+            this.dreamTimer = null;
         }
-        // Flush team learning pipeline
-        if (this.teamLearning && this.teamLearning.getAccumulatedCount() > 0) {
-            await this.teamLearning.runBatchLearning();
+        // Flush unified pipeline by draining the durable queue via a dream. The
+        // `isInitialized` guard keeps a second close() (e.g. test teardown after an
+        // explicit close) from touching an already-closed database.
+        if (this.persistence.isInitialized && this.persistence.countPendingDreamRows() > 0) {
+            await this.dream({ drainAll: true });
         }
-        // Flush MoE gate state before closing persistence
-        this.router.persistGateState();
         // Close effectiveness tracker
         const tracker = this.unifiedPipeline.getEffectivenessTracker();
         if (tracker) {
@@ -765,6 +1200,10 @@ export class Atlas {
         if (this.skillTreeStorage) {
             this.skillTreeStorage.close();
         }
+        // Close the shared-bank mirror (best-effort)
+        if (this.sharedSkillBank) {
+            await this.sharedSkillBank.close();
+        }
         // Close memory system
         await this.memory.close();
         // Close SQLite persistence
@@ -778,13 +1217,40 @@ export function createAtlas(config) {
     return new Atlas(config);
 }
 /**
- * Create an Atlas instance with an LLM provider
- * @deprecated Use createAtlasWithAgents() for real action execution
+ * F6: Compute relevance-weighted credit shares for injection-presence attribution.
+ *
+ * Given a list of injected playbooks with retrieval scores, returns an array of
+ * `{ id, weight }` entries where weights sum to 1. When all scores are zero or
+ * the list is empty the function returns uniform weights (1/k each).
+ *
+ * This is a pure function (no side-effects) so it can be unit-tested in isolation
+ * and imported by tests without a full Atlas instance.
+ *
+ * @param playbooks - Playbooks that were injected, with their retrieval scores
+ * @returns Attribution entries — one per injected playbook, weights summing to 1
+ *
+ * @example
+ * // scores [0.9, 0.6, 0.3] → weights [0.5, 0.333, 0.167]
+ * attributeCredit([
+ *   { playbook: { id: 'a', ... }, score: 0.9, matchType: 'situation' },
+ *   { playbook: { id: 'b', ... }, score: 0.6, matchType: 'situation' },
+ *   { playbook: { id: 'c', ... }, score: 0.3, matchType: 'situation' },
+ * ])
+ * // → [{ id: 'a', weight: 0.5 }, { id: 'b', weight: 0.333 }, { id: 'c', weight: 0.167 }]
  */
-export function createAtlasWithProvider(provider, config) {
-    const atlas = new Atlas(config);
-    atlas.setProvider(provider);
-    return atlas;
+export function attributeCredit(playbooks) {
+    if (playbooks.length === 0)
+        return [];
+    const totalScore = playbooks.reduce((sum, p) => sum + p.score, 0);
+    if (totalScore <= 0) {
+        // Uniform fallback when all scores are zero or absent
+        const uniform = 1 / playbooks.length;
+        return playbooks.map((p) => ({ id: p.playbook.id, weight: uniform }));
+    }
+    return playbooks.map((p) => ({
+        id: p.playbook.id,
+        weight: p.score / totalScore,
+    }));
 }
 /**
  * Create an Atlas instance with AgentManager backends