cognitive-core 0.2.4 → 0.3.1

package/dist/learning/unified-pipeline.js

@@ -11,37 +11,49 @@
  *      Stores experience, bumps playbooks, extracts lightweight knowledge,
  *      causal edges, and reflexion episodes.
  *
- *   2. **Batch** (cold pipeline): Triggered by energy-threshold evaluation
- *      (not just count). Runs full analysis, playbook extraction, temporal
+ *   2. **Batch** (cold pipeline): Drained from the durable dream queue via
+ *      `dream()`. Runs full analysis, playbook extraction, temporal
  *      compression, and experience clustering.
  *
  *   3. **Maintenance** (circadian-gated): Runs periodically or after N batches.
- *      Knowledge defrag, healing orchestrator, meta-strategy generation,
- *      effectiveness reporting.
+ *      Knowledge defrag, meta-strategy generation, effectiveness reporting.
  *
  * The pipeline owns all components and coordinates them. Atlas delegates
  * learning to this pipeline rather than managing components directly.
  */
+import { randomUUID } from 'node:crypto';
+import { logger } from '../utils/logger.js';
+import { AgenticTaskOutputError, AgenticTaskRunError } from '../workspace/types.js';
 // Immediate-phase components
 import { InstantLoop } from './instant-loop.js';
 // Batch-phase components
-import { createAnalyzer, } from './analyzer.js';
+import { createAnalyzer } from './analyzer.js';
 import { createPlaybookExtractor, } from './playbook-extractor.js';
 import { KnowledgeExtractor } from './knowledge-extractor.js';
+import { taskSignature } from '../utils/task-signature.js';
+import { deriveObjectives } from '../utils/objectives.js';
+import { canonicalizeSolver } from '../utils/solver-canonicalizer.js';
+import { MergeProposer } from './merge-proposer.js';
+import { MutationGate } from './mutation-gate.js';
+import { ReflectiveMutationProposer } from './reflective-proposer.js';
+import { createMechanismTraceEvent, noopMechanismTraceCollector, } from './mechanism-trace.js';
+import { createTrajectoryDistiller } from './distiller.js';
+import { readOracleSignal, oracleVerifierText } from './oracle-signal.js';
 import { TemporalCompressor } from '../memory/temporal-compressor.js';
-import { ReasoningBank } from '../memory/reasoning-bank.js';
 import { trajectoryAnalysisTemplate } from '../workspace/templates/trajectory-analysis.js';
 import { playbookExtractionTemplate } from '../workspace/templates/playbook-extraction.js';
 // Efficacy templates (used in maintenance tasks)
-import { playbookDecayDetectionTemplate } from '../workspace/templates/playbook-decay-detection.js';
+import { playbookDecayDetectionTemplate, } from '../workspace/templates/playbook-decay-detection.js';
 import { playbookEfficacyAuditTemplate } from '../workspace/templates/playbook-efficacy-audit.js';
 import { playbookLifecycleReviewTemplate } from '../workspace/templates/playbook-lifecycle-review.js';
-// Energy evaluator (batch trigger)
-import { EnergyEvaluator, } from './energy-evaluator.js';
 // Maintenance scheduler
 import { MaintenanceScheduler, } from './maintenance-scheduler.js';
-// Healing orchestrator
-import { HealingOrchestrator, PlaybookDriftDetector, MemoryBloatDetector, } from './healing-orchestrator.js';
+const DEFAULT_PIPELINE_DREAM_CONFIG = {
+    maxRowsPerDream: 200,
+    maxBatchesPerDream: 50,
+    leaseTtlMs: 900_000,
+    maxAttempts: 3,
+};
 const DEFAULT_EFFICACY_CONFIG = {
     lifecycleReviewFrequency: 3,
     minPlaybooks: 1,
@@ -51,14 +63,52 @@ const DEFAULT_UNIFIED_CONFIG = {
     instant: {},
     batch: {
         learning: {},
-        energy: {},
     },
     maintenance: {},
     metaLearner: {},
     features: {},
     efficacy: DEFAULT_EFFICACY_CONFIG,
+    dream: {},
     maxInstantLatencyMs: 200,
+    validation: undefined,
 };
+/** Compute the Tier-0 quality signal from a batch of emitted playbooks. Pure. */
+export function computeExtractionTier0(playbooks, trajectoryCount) {
+    const n = playbooks.length;
+    const frac = (pred) => n > 0 ? playbooks.filter(pred).length / n : 0;
+    return {
+        yieldPerTrajectory: trajectoryCount > 0 ? n / trajectoryCount : 0,
+        unconditionedRate: frac((p) => p.applicability.antiPatterns.length === 0),
+        triggerCoverage: frac((p) => p.applicability.triggers.length > 0),
+        situationCoverage: frac((p) => p.applicability.situations.length > 0),
+        meanConfidence: n > 0 ? playbooks.reduce((s, p) => s + p.confidence, 0) / n : 0,
+    };
+}
+function emptyMutationTaskStats() {
+    return {
+        runs: 0,
+        skipped: 0,
+        proposalsConsidered: 0,
+        proposalsAccepted: 0,
+        proposalsRejected: 0,
+        reasonCounts: {},
+    };
+}
+/** Truncate `text` to `max` chars, appending an ellipsis when clipped. */
+function truncate(text, max) {
+    return text.length > max ? text.slice(0, max) + '…' : text;
+}
+/**
+ * Compact one-line rendering of a playbook's guidance (strategy + tactics),
+ * truncated — used for the mutation trace's before/after diff and the journal
+ * entry. Returns undefined for a missing playbook.
+ */
+function compactGuidanceText(pb, max = 400) {
+    if (!pb)
+        return undefined;
+    const parts = [pb.guidance.strategy, ...(pb.guidance.tactics ?? [])].filter((p) => typeof p === 'string' && p.trim().length > 0);
+    return truncate(parts.join(' | '), max);
+}
 // =========================================================================
 // Unified Pipeline
 // =========================================================================
@@ -75,57 +125,102 @@ export class UnifiedLearningPipeline {
     // Batch-phase components
     analyzer;
     playbookExtractor;
+    /** PR-D1: LLM-backed distiller; null when no LLM provider is wired. */
+    distiller = null;
     knowledgeExtractor;
     temporalCompressor;
-    reasoningBank;
     // Meta-learning and effectiveness
     metaLearner = null;
     effectivenessTracker = null;
     // Orchestration
-    energyEvaluator;
     maintenanceScheduler;
-    healingOrchestrator;
     // State
     memory;
+    persistence;
+    judge;
+    llm;
     taskRunner = null;
-    accumulated = [];
-    accumulatedAnalyses = [];
+    /**
+     * G2: tracks whether the "LLM extractor requested but no backend wired"
+     * warning has already fired this run, so we warn loudly but only once.
+     */
+    warnedHeuristicFallback = false;
     totalProcessed = 0;
     batchCyclesRun = 0;
     maintenanceCyclesRun = 0;
+    mutationActivity = {
+        maintenanceCyclesRun: 0,
+        reflective: emptyMutationTaskStats(),
+        merge: emptyMutationTaskStats(),
+    };
     _onLatencyWarning = null;
+    diagnosticsCollector = null;
+    /**
+     * Sink for per-mutation-decision mechanism traces. Defaults to a no-op;
+     * callers (e.g. the eval runner) inject one via
+     * {@link setMechanismTraceCollector} to make the GEPA-style mutation loop
+     * observable (every considered proposal → one `mutation` trace event).
+     */
+    mechanismTraceCollector = noopMechanismTraceCollector;
+    lastPlaybookExtractionDiagnostics = null;
     lastDecayResult = null;
-    constructor(memory, config, persistence) {
+    dreamConfig;
+    /** In-process guard so two dreams can't run concurrently in one process. */
+    dreaming = false;
+    constructor(memory, config, persistence, 
+    /**
+     * Optional replay judge. Required only when `features.mergeProposing`
+     * is enabled — otherwise the merge maintenance task no-ops with a
+     * `skipped` result.
+     */
+    judge, 
+    /**
+     * Optional LLM provider. Required only when `features.reflectiveMutation`
+     * is enabled — the reflective proposer uses it to revise playbook
+     * guidance. The reflective maintenance task no-ops with a `skipped`
+     * result when it (or the judge) is absent.
+     */
+    llm) {
         this.config = {
             ...DEFAULT_UNIFIED_CONFIG,
             ...config,
             instant: { ...DEFAULT_UNIFIED_CONFIG.instant, ...config?.instant },
             batch: {
                 learning: { ...DEFAULT_UNIFIED_CONFIG.batch.learning, ...config?.batch?.learning },
-                energy: { ...DEFAULT_UNIFIED_CONFIG.batch.energy, ...config?.batch?.energy },
             },
             maintenance: { ...DEFAULT_UNIFIED_CONFIG.maintenance, ...config?.maintenance },
             metaLearner: { ...DEFAULT_UNIFIED_CONFIG.metaLearner, ...config?.metaLearner },
             features: { ...DEFAULT_UNIFIED_CONFIG.features, ...config?.features },
             efficacy: { ...DEFAULT_EFFICACY_CONFIG, ...config?.efficacy },
+            dream: { ...DEFAULT_UNIFIED_CONFIG.dream, ...config?.dream },
+            validation: config?.validation,
         };
         this.memory = memory;
+        this.persistence = persistence;
+        this.judge = judge;
+        this.llm = llm;
+        this.dreamConfig = { ...DEFAULT_PIPELINE_DREAM_CONFIG, ...this.config.dream };
         // Resolve learning config with defaults
         const lc = this.config.batch.learning;
         this.learningConfig = {
             creditStrategy: lc.creditStrategy ?? 'simple',
             patternExtractor: lc.patternExtractor ?? 'llm',
+            strictExtraction: lc.strictExtraction ?? false,
             minTrajectories: lc.minTrajectories ?? 10,
             minHoursSinceLast: lc.minHoursSinceLast,
             minSuccessRate: lc.minSuccessRate,
             deduplicationThreshold: lc.deduplicationThreshold ?? 0.9,
             maxExperiences: lc.maxExperiences ?? 1000,
+            additiveMergeThreshold: lc.additiveMergeThreshold ?? 0.55,
         };
         // Immediate phase
         this.instantLoop = new InstantLoop(memory, {
             ...this.config.instant,
             enableReflexion: this.config.features.reflexion ?? true,
-            enableCausalExtraction: this.config.features.causalExtraction ?? true,
+            // Decoupled learning trims the hot path: knowledge and reflexion are
+            // replayed in the dream instead of on capture.
+            deferAnalytics: true,
+            validation: this.config.validation,
         });
         // Batch phase
         this.analyzer = createAnalyzer(this.learningConfig.creditStrategy);
@@ -134,27 +229,14 @@ export class UnifiedLearningPipeline {
             mergeThreshold: this.learningConfig.deduplicationThreshold,
             minSuccessRate: this.learningConfig.minSuccessRate ?? 0.6,
         });
-        this.knowledgeExtractor = (this.config.features.knowledgeExtraction ?? true)
-            ? new KnowledgeExtractor()
-            : null;
-        this.temporalCompressor = (this.config.features.temporalCompression ?? true)
-            ? new TemporalCompressor(undefined, persistence)
-            : null;
-        this.reasoningBank = (this.config.features.reasoningBank ?? true)
-            ? new ReasoningBank(undefined, persistence)
-            : null;
+        this.knowledgeExtractor =
+            (this.config.features.knowledgeExtraction ?? true) ? new KnowledgeExtractor() : null;
+        this.temporalCompressor =
+            (this.config.features.temporalCompression ?? true)
+                ? new TemporalCompressor(undefined, persistence)
+                : null;
         // Orchestration
-        this.energyEvaluator = new EnergyEvaluator({
-            countThreshold: this.learningConfig.minTrajectories,
-            ...this.config.batch.energy,
-        });
         this.maintenanceScheduler = new MaintenanceScheduler(this.config.maintenance);
-        this.healingOrchestrator = new HealingOrchestrator();
-        // Register built-in healing detectors if healing feature is enabled
-        if (this.config.features.healing ?? true) {
-            this.healingOrchestrator.addDetector(new PlaybookDriftDetector());
-            this.healingOrchestrator.addDetector(new MemoryBloatDetector(this.learningConfig.maxExperiences));
-        }
         // Register built-in maintenance tasks
         this.registerBuiltInMaintenanceTasks();
     }
@@ -164,21 +246,11 @@ export class UnifiedLearningPipeline {
      */
     loadPersistedState() {
         this.temporalCompressor?.loadPersistedState();
-        this.reasoningBank?.loadPersistedState();
     }
     /**
      * Initialize components that require async setup.
      */
     async init() {
-        // Seed known domains from existing playbooks for energy evaluator
-        const allPlaybooks = await this.memory.playbooks.getAll();
-        const domains = new Set();
-        for (const pb of allPlaybooks) {
-            for (const d of pb.applicability.domains) {
-                domains.add(d);
-            }
-        }
-        this.energyEvaluator.seedKnownDomains([...domains]);
         // Initialize meta-learner if enabled and meta memory available
         if ((this.config.features.metaLearning ?? true) && this.memory.meta) {
             const { createMetaLearner: createML } = await import('./meta-learner.js');
@@ -197,19 +269,126 @@ export class UnifiedLearningPipeline {
     setTaskRunner(runner) {
         this.taskRunner = runner;
     }
+    setDiagnosticsCollector(collector) {
+        this.diagnosticsCollector = collector;
+    }
+    /**
+     * Inject a sink for per-mutation-decision mechanism traces. Pass `null`
+     * to reset to the no-op collector. Emitted for EVERY considered mutation
+     * proposal (accepted / rejected / regression / sparse- or empty-minibatch
+     * auto-accept), so a fired — or suppressed — mutation is recoverable.
+     */
+    setMechanismTraceCollector(collector) {
+        this.mechanismTraceCollector = collector ?? noopMechanismTraceCollector;
+    }
+    /**
+     * Late-bind the LLM provider used by LLM-backed maintenance tasks
+     * (reflective mutation) and, optionally, the ReplayJudge used to gate
+     * mutations and merges.
+     *
+     * The maintenance-task closures read `this.llm` / `this.judge` at
+     * execution time, so this can be called any time after construction —
+     * e.g. when Atlas receives a provider via `setLearningProvider`,
+     * which happens after the pipeline is built.
+     *
+     * Without a judge, the merge and reflective-mutation tasks no-op (they
+     * have no way to gate candidates); callers that enable those features
+     * should pass one.
+     */
+    setLearningLLM(llm, judge) {
+        this.llm = llm;
+        if (judge)
+            this.judge = judge;
+        // PR-D1: build/replace the distiller whenever the LLM provider is (re)wired.
+        this.distiller = createTrajectoryDistiller(llm, this.persistence);
+    }
+    /**
+     * Set (or replace) the ReplayJudge used to gate mutations and merges,
+     * without binding an LLM generator. Used to upgrade gating to a
+     * {@link LiveReplay} judge for high-stakes acceptance, or to enable merge
+     * proposing (which needs only a judge) on the agent-backend path where
+     * there's no standalone LLMProvider.
+     */
+    setJudge(judge) {
+        this.judge = judge;
+    }
+    /**
+     * Set the judge only if none is configured yet. Lets `setLearningProvider`
+     * install a default LLM judge without clobbering an explicitly-installed
+     * one (e.g. a LiveReplay judge from `enableLiveReplayGating`), regardless
+     * of call order.
+     */
+    setJudgeIfUnset(judge) {
+        if (!this.judge)
+            this.judge = judge;
+    }
+    validationAllowsStableMutation() {
+        const validation = this.config.validation;
+        return !validation?.enabled || validation.mutationMode === 'active';
+    }
+    validationCanWrite(channel) {
+        const validation = this.config.validation;
+        if (!validation?.enabled)
+            return true;
+        if (validation.mutationMode !== 'active')
+            return false;
+        return validation.channelMasks.write.includes(channel);
+    }
+    validationAllowsExtraction() {
+        const validation = this.config.validation;
+        if (!validation?.enabled)
+            return true;
+        if (!validation.channelMasks.maintenance.extraction)
+            return false;
+        return (this.validationCanWrite('playbook') ||
+            this.validationCanWrite('metaPlaybook') ||
+            this.validationCanWrite('knowledgeNote') ||
+            this.validationCanWrite('reflexion') ||
+            this.validationCanWrite('causal') ||
+            this.validationCanWrite('frontier'));
+    }
+    validationAllowsScheduling() {
+        const validation = this.config.validation;
+        return !validation?.enabled || validation.channelMasks.maintenance.scheduling;
+    }
+    noopInstantLoopResult() {
+        return {
+            experienceId: '',
+            matchedPlaybooks: [],
+            knowledgeNotesExtracted: 0,
+            durationMs: 0,
+        };
+    }
     // =========================================================================
     // IMMEDIATE PHASE
     // =========================================================================
     /**
-     * Process a single trajectory through the full pipeline.
+     * Process a single trajectory through the immediate phase and durably enqueue
+     * it for offline consolidation.
      *
-     * 1. Runs the instant loop (immediate phase)
-     * 2. Evaluates energy to decide on batch trigger
-     * 3. If batch triggered, runs batch + checks maintenance
+     * Learning is always decoupled: the instant loop runs on the hot path, then
+     * the trajectory is enqueued on the durable dream queue. Consolidation happens
+     * only via `dream()` — explicitly, on a schedule, or at close.
      *
      * This is the primary entry point for trajectory processing.
      */
-    async processTrajectory(trajectory, signals) {
+    async processTrajectory(trajectory, 
+    /**
+     * Optional serialized routing snapshot (a `DeferredRoutingSnapshot`). When
+     * present, the dream replays the deferred Phase-2 processing (meta-reflection
+     * + effectiveness) from it. Null/absent for external trajectories with no
+     * routing context.
+     */
+    routingJson) {
+        if (!this.validationAllowsStableMutation()) {
+            const instantResult = this.noopInstantLoopResult();
+            this.totalProcessed++;
+            return {
+                instantLoop: instantResult,
+                batchTriggered: false,
+                maintenanceTriggered: false,
+            };
+        }
         // 1. Immediate phase — InstantLoop
         const instantResult = await this.instantLoop.process(trajectory);
         this.totalProcessed++;
@@ -217,90 +396,150 @@ export class UnifiedLearningPipeline {
         if (instantResult.durationMs > this.config.maxInstantLatencyMs) {
             this._onLatencyWarning?.(instantResult.durationMs);
         }
-        // 2. Accumulate for batch
-        let analysis;
-        if (this.taskRunner) {
-            analysis = await this.analyzeWithTemplate(trajectory);
-        }
-        else {
-            analysis = await this.analyzer.analyze(trajectory);
+        // 2. Durably enqueue the trajectory for offline consolidation — the dream is
+        // the consumer. Non-fatal: a queue-write failure must never break the
+        // learning hot path.
+        if ((this.config.features.dreamQueue ?? true) &&
+            this.validationAllowsScheduling() &&
+            this.validationAllowsExtraction() &&
+            this.persistence) {
+            try {
+                this.persistence.enqueueDreamRow({
+                    trajectoryId: trajectory.id,
+                    trajectoryJson: JSON.stringify(trajectory),
+                    routingJson: routingJson ?? null,
+                    source: 'pipeline',
+                });
+            }
+            catch {
+                // Non-fatal — consolidation is best-effort; a missed enqueue just means
+                // this trajectory isn't dreamed over.
+            }
         }
-        this.accumulated.push(trajectory);
-        this.accumulatedAnalyses.push(analysis);
-        // 3. Energy evaluation
-        const energyEval = this.energyEvaluator.evaluate(trajectory, instantResult, signals);
-        const result = {
+        return {
             instantLoop: instantResult,
-            energyEval,
             batchTriggered: false,
             maintenanceTriggered: false,
         };
-        // 4. Batch trigger
-        if (energyEval.shouldTriggerBatch) {
-            const batchResult = await this.runBatch(energyEval.reasons);
-            result.batchTriggered = true;
-            result.batchResult = batchResult;
-            // 5. Check maintenance after batch
-            this.maintenanceScheduler.onBatchComplete();
-            if (this.maintenanceScheduler.shouldRunMaintenance()) {
-                const maintenanceResult = await this.runMaintenance();
-                result.maintenanceTriggered = true;
-                result.maintenanceResult = maintenanceResult;
-            }
-        }
-        return result;
     }
     // =========================================================================
     // BATCH PHASE
     // =========================================================================
     /**
-     * Run batch learning on accumulated trajectories.
-     * Can be called manually or triggered by energy evaluation.
+     * Run a batch over an explicit set of trajectories + analyses. The caller
+     * supplies the working set — the durable dream_queue (via `dream`) — and this
+     * method never reads or mutates shared accumulation state.
      */
-    async runBatch(triggerReasons) {
-        if (this.accumulated.length === 0) {
+    async runBatchOver(trajectories, analyses, triggerReasons) {
+        if (trajectories.length === 0) {
             return this.emptyBatchResult(triggerReasons ?? []);
         }
         this.maintenanceScheduler.onBatchStart();
         try {
             // Extract playbooks
             let playbooksAdded = 0;
-            const existingPlaybooks = await this.memory.playbooks.getAll();
-            const playbookExtraction = await this.extractPlaybooks(existingPlaybooks);
-            for (const playbook of playbookExtraction.new) {
-                const exists = await this.memory.playbooks.exists(playbook.name, this.learningConfig.deduplicationThreshold);
-                if (!exists) {
-                    await this.memory.playbooks.add(playbook);
-                    playbooksAdded++;
-                }
-            }
-            // Apply updates to existing playbooks
-            for (const update of playbookExtraction.updates) {
-                if (update.refinement) {
-                    await this.memory.playbooks.addRefinement(update.id, update.refinement.context, update.refinement.addition, update.refinement.source);
-                }
-                if (update.newTrigger) {
-                    const playbook = await this.memory.playbooks.get(update.id);
-                    if (playbook && !playbook.applicability.triggers.includes(update.newTrigger)) {
-                        playbook.applicability.triggers.push(update.newTrigger);
+            let playbooksSkippedDedup = 0;
+            let updatesApplied = 0;
+            const canWritePlaybooks = this.validationCanWrite('playbook');
+            const canWriteFrontier = this.validationCanWrite('frontier');
+            const canWriteKnowledge = this.validationCanWrite('knowledgeNote');
+            const canWriteExperiences = this.validationCanWrite('experience');
+            const canWriteMetaPlaybooks = this.validationCanWrite('metaPlaybook');
+            if (canWritePlaybooks) {
+                const existingPlaybooks = await this.memory.playbooks.getAll();
+                const playbookExtraction = await this.extractPlaybooks(existingPlaybooks, trajectories, analyses);
+                for (const playbook of playbookExtraction.new) {
+                    // ADDITIVE LEARNING (PR-D2 hook, default OFF): before minting a new
+                    // `distilled-<uuid>`, try to REFINE a sufficiently-similar existing
+                    // playbook so evidence COMPOUNDS onto one record instead of
+                    // proliferating 1:1 per trajectory. The scan is over the LIVE library
+                    // which, mid-loop, already contains playbooks added earlier in THIS
+                    // batch — so both the already-distilled-this-batch set and the
+                    // persisted library are covered. Similarity is embeddings-optional
+                    // and domain-gated (see PlaybookLibrary.findRefineTarget), so it works
+                    // under the eval default of embedProvider:'none'.
+                    //
+                    // Over-merge tradeoff: a too-low threshold conflates distinct lessons
+                    // into one bloated playbook; the domain-overlap hard gate + the
+                    // `additiveMergeThreshold` floor bound that risk. See
+                    // LearningConfig.additiveMergeThreshold.
+                    if (this.config.features.additiveConsolidation) {
+                        const targetId = await this.memory.playbooks.findRefineTarget(playbook, this.learningConfig.additiveMergeThreshold);
+                        if (targetId) {
+                            await this.applyReflexionAntiPatterns(playbook);
+                            const refined = await this.memory.playbooks.refineWithDistilled(targetId, playbook);
+                            updatesApplied++;
+                            // Seed the frontier from this trajectory's experiences onto the
+                            // refined (reused) playbook so it accrues attested evidence.
+                            if (refined && canWriteFrontier) {
+                                await this.seedFrontierForNewPlaybook(refined, trajectories);
+                            }
+                            continue;
+                        }
+                    }
+                    const exists = await this.memory.playbooks.exists(playbook.name, this.learningConfig.deduplicationThreshold);
+                    if (!exists) {
+                        // G3: durably apply reflexion `suggestedPlaybookUpdates` (esp.
+                        // avoid/anti-pattern rules) from the source trajectories onto the
+                        // playbook record before persisting, so reflexion is no longer
+                        // write-only on the cross-run path (G1 only used it ephemerally).
+                        await this.applyReflexionAntiPatterns(playbook);
                         await this.memory.playbooks.add(playbook);
+                        playbooksAdded++;
+                        // Seed the Pareto frontier from the source trajectories so the
+                        // newly minted playbook starts with attested wins — otherwise
+                        // the frontier stays empty until the playbook gets matched at
+                        // routing time, which can take many solves.
+                        if (canWriteFrontier) {
+                            await this.seedFrontierForNewPlaybook(playbook, trajectories);
+                        }
+                    }
+                    else {
+                        playbooksSkippedDedup++;
                     }
                 }
-                if (update.newAntiPattern) {
-                    const playbook = await this.memory.playbooks.get(update.id);
-                    if (playbook && !playbook.applicability.antiPatterns.includes(update.newAntiPattern)) {
-                        playbook.applicability.antiPatterns.push(update.newAntiPattern);
-                        await this.memory.playbooks.add(playbook);
+                // Apply updates to existing playbooks
+                for (const update of playbookExtraction.updates) {
+                    if (update.refinement) {
+                        await this.memory.playbooks.addRefinement(update.id, update.refinement.context, update.refinement.addition, update.refinement.source);
+                        updatesApplied++;
+                    }
+                    if (update.newTrigger) {
+                        const playbook = await this.memory.playbooks.get(update.id);
+                        if (playbook && !playbook.applicability.triggers.includes(update.newTrigger)) {
+                            playbook.applicability.triggers.push(update.newTrigger);
+                            await this.memory.playbooks.add(playbook);
+                            updatesApplied++;
+                        }
+                    }
+                    if (update.newAntiPattern) {
+                        const playbook = await this.memory.playbooks.get(update.id);
+                        if (playbook && !playbook.applicability.antiPatterns.includes(update.newAntiPattern)) {
+                            playbook.applicability.antiPatterns.push(update.newAntiPattern);
+                            await this.memory.playbooks.add(playbook);
+                            updatesApplied++;
+                        }
                     }
                 }
             }
+            if (this.lastPlaybookExtractionDiagnostics) {
+                this.emitDiagnostics({
+                    ...this.lastPlaybookExtractionDiagnostics,
+                    storage: {
+                        added: playbooksAdded,
+                        skippedDedup: playbooksSkippedDedup,
+                        updatesApplied,
+                    },
+                });
+                this.lastPlaybookExtractionDiagnostics = null;
+            }
             // Knowledge extraction (batch-level, richer than instant-loop)
             let knowledgeExtracted = 0;
-            if (this.knowledgeExtractor && this.memory.knowledgeBank) {
+            if (canWriteKnowledge && this.knowledgeExtractor && this.memory.knowledgeBank) {
                 const existingEntities = await this.memory.knowledgeBank.listEntities();
                 const context = { existingEntities };
-                for (let i = 0; i < this.accumulated.length; i++) {
-                    const extracted = this.knowledgeExtractor.extract(this.accumulated[i], this.accumulatedAnalyses[i], context);
+                for (let i = 0; i < trajectories.length; i++) {
+                    const extracted = this.knowledgeExtractor.extract(trajectories[i], analyses[i], context);
                     for (const obs of extracted.observations) {
                         try {
                             await this.memory.knowledgeBank.addObservation(obs);
@@ -316,7 +555,7 @@ export class UnifiedLearningPipeline {
             let compressionEvicted = 0;
             let compressionPromoted = 0;
             let compressionDemoted = 0;
-            if (this.temporalCompressor) {
+            if (canWriteExperiences && this.temporalCompressor) {
                 const allExperiences = await this.memory.experiences.getAll();
                 const compressionResult = await this.temporalCompressor.compress(allExperiences);
                 for (const [id, updates] of compressionResult.updates) {
@@ -329,20 +568,17 @@ export class UnifiedLearningPipeline {
                 compressionPromoted = compressionResult.promoted.length;
                 compressionDemoted = compressionResult.demoted.length;
             }
-            // Re-cluster experiences
-            const currentExperiences = await this.memory.experiences.getAll();
-            if (this.reasoningBank) {
-                this.reasoningBank.buildClusters(currentExperiences);
-            }
             // Prune experiences
-            const pruned = await this.memory.experiences.prune({
-                maxCount: this.learningConfig.maxExperiences,
-            });
+            const pruned = canWriteExperiences
+                ? await this.memory.experiences.prune({
+                    maxCount: this.learningConfig.maxExperiences,
+                })
+                : { totalPruned: 0 };
             // Calculate success rate
-            const successCount = this.accumulatedAnalyses.filter(a => a.success).length;
-            const successRate = successCount / this.accumulated.length;
+            const successCount = analyses.filter((a) => a.success).length;
+            const successRate = successCount / trajectories.length;
             // Meta-learning: generate strategies periodically
-            if (this.metaLearner) {
+            if (canWriteMetaPlaybooks && this.metaLearner) {
                 try {
                     await this.metaLearner.learn();
                 }
@@ -350,11 +586,7 @@ export class UnifiedLearningPipeline {
                     // Non-critical
                 }
             }
-            const trajectoriesProcessed = this.accumulated.length;
-            // Clear accumulated and reset energy evaluator
-            this.accumulated = [];
-            this.accumulatedAnalyses = [];
-            this.energyEvaluator.resetAfterBatch();
+            const trajectoriesProcessed = trajectories.length;
             this.batchCyclesRun++;
             return {
                 trajectoriesProcessed,
@@ -365,7 +597,7 @@ export class UnifiedLearningPipeline {
                     demoted: compressionDemoted,
                     evicted: compressionEvicted,
                 },
-                experiencesClustered: currentExperiences.length,
+                experiencesClustered: 0,
                 knowledgeExtracted,
                 successRate,
                 triggerReasons: triggerReasons ?? ['manual_override'],
@@ -380,33 +612,439 @@ export class UnifiedLearningPipeline {
     // =========================================================================
     /**
      * Run a maintenance cycle.
-     * Executes registered maintenance tasks (defrag, healing, etc.).
+     * Executes registered maintenance tasks (defrag, meta-strategies, etc.).
      * Can be called manually regardless of mode.
      */
     async runMaintenance(options) {
+        if (!this.validationAllowsStableMutation() || !this.validationAllowsScheduling()) {
+            return {
+                ran: false,
+                skipReason: 'validation_disabled',
+                taskResults: [],
+                totalDurationMs: 0,
+                timestamp: new Date(),
+            };
+        }
         const result = await this.maintenanceScheduler.runMaintenance(options);
         if (result.ran) {
             this.maintenanceCyclesRun++;
+            this.recordMutationActivity(result);
         }
         return result;
     }
     /**
-     * Register a custom maintenance task.
+     * Fold one maintenance cycle's mutation-task results into the accumulated
+     * activity counters. The task closures already report per-cycle counts in
+     * their `details`; this aggregates them so eval harnesses (and any caller
+     * of `getStats()` / `getMutationActivity()`) can prove whether the
+     * mutation path executed across a whole run without parsing cycle logs.
      */
-    registerMaintenanceTask(task) {
-        this.maintenanceScheduler.registerTask(task);
+    recordMutationActivity(result) {
+        this.mutationActivity.maintenanceCyclesRun++;
+        const tasks = [
+            ['reflective-mutation', this.mutationActivity.reflective],
+            ['pareto-merge-proposing', this.mutationActivity.merge],
+        ];
+        for (const [taskName, stats] of tasks) {
+            const taskResult = result.taskResults.find((t) => t.taskName === taskName);
+            if (!taskResult)
+                continue;
+            stats.runs++;
+            const details = taskResult.details ?? {};
+            if (details.skipped) {
+                stats.skipped++;
+                stats.lastSkipReason = typeof details.reason === 'string' ? details.reason : 'unknown';
+                continue;
+            }
+            const considered = typeof details.proposalsConsidered === 'number' ? details.proposalsConsidered : 0;
+            const accepted = typeof details.proposalsAccepted === 'number' ? details.proposalsAccepted : 0;
+            stats.proposalsConsidered += considered;
+            stats.proposalsAccepted += accepted;
+            stats.proposalsRejected += Math.max(0, considered - accepted);
+            // Fold in the per-GateReason breakdown so reports can tell genuine
+            // `improved` accepts apart from sparse/empty-minibatch auto-accepts.
+            const reasonCounts = details.reasonCounts;
+            if (reasonCounts && typeof reasonCounts === 'object') {
+                for (const [reason, count] of Object.entries(reasonCounts)) {
+                    if (typeof count !== 'number')
+                        continue;
+                    const key = reason;
+                    stats.reasonCounts[key] = (stats.reasonCounts[key] ?? 0) + count;
+                }
+            }
+        }
+    }
+    /**
+     * Accumulated mutation/merge proposing activity across all maintenance
+     * cycles this pipeline has run.
+     */
+    getMutationActivity() {
+        return this.mutationActivity;
+    }
+    /**
+     * Record one mutation gate decision to BOTH observability sinks:
+     *   1. the injected mechanism-trace collector (a `mutation` trace event
+     *      for every considered proposal — accepted, rejected, or auto-accept),
+     *   2. the durable `mutation_journal` table (learning content fed back into
+     *      the proposer's next prompt).
+     *
+     * Best-effort: a trace/journal write must never break the maintenance loop,
+     * so failures are swallowed. Returns nothing.
+     */
+    recordMutationDecision(args) {
+        const guidanceAfter = compactGuidanceText(args.candidate);
+        const scoreDelta = args.childSum - args.parentSum;
+        try {
+            this.mechanismTraceCollector(createMechanismTraceEvent({
+                family: 'mutation',
+                source: `UnifiedLearningPipeline.${args.mutationType}-mutation`,
+                mutationType: args.mutationType,
+                taskSignature: args.taskSignature,
+                parentId: args.parentId,
+                secondaryParentId: args.secondaryParentId,
+                candidateId: args.candidate.id,
+                candidateName: args.candidate.name,
+                reason: args.reason,
+                accepted: args.accepted,
+                parentSum: args.parentSum,
+                childSum: args.childSum,
+                scoreDelta,
+                judgeCalls: args.judgeCalls,
+                guidanceBefore: args.guidanceBefore,
+                guidanceAfter,
+                rationale: args.rationale ? truncate(args.rationale, 400) : undefined,
+            }));
+        }
+        catch {
+            // best-effort trace emission must not affect the maintenance loop
+        }
+        try {
+            this.persistence?.recordMutationJournalEntry({
+                parentId: args.parentId,
+                taskSignature: args.taskSignature,
+                mutationType: args.mutationType,
+                candidateId: args.candidate.id,
+                candidateName: args.candidate.name,
+                guidanceAfter,
+                reason: args.reason,
+                accepted: args.accepted,
+                parentSum: args.parentSum,
+                childSum: args.childSum,
+                scoreDelta,
+                rationale: args.rationale ? truncate(args.rationale, 400) : undefined,
+            });
+        }
+        catch {
+            // best-effort journal write must not affect the maintenance loop
+        }
+    }
+    // =========================================================================
+    // DREAM PHASE (queue-sourced consolidation)
+    // =========================================================================
+    /**
+     * Drain the durable dream_queue and consolidate offline. Reclaims rows
+     * orphaned by a crashed dreamer, then repeatedly claims a batch of pending
+     * rows, re-derives analyses, and runs a batch over them — followed by a
+     * maintenance check. This is the decoupled replacement for the inline batch
+     * trigger; being queue-sourced it survives process restarts (and, in a later
+     * phase, runs from a separate process).
+     *
+     * Single-flight within a process: a concurrent call returns an empty result.
+     * No-op (empty result) when there is no persistence handle.
+     */
+    async dream(opts) {
+        const start = Date.now();
+        const drainAll = opts?.drainAll ?? true;
+        if (!this.persistence ||
+            this.dreaming ||
+            !this.validationAllowsStableMutation() ||
+            !this.validationAllowsScheduling() ||
+            !this.validationAllowsExtraction()) {
+            return this.emptyDreamResult(start);
+        }
+        // Cross-process single-flight: bail if another process (e.g. a `dream` CLI
+        // or another server) currently holds the lock. The in-process `dreaming`
+        // flag guards within this process; the lock guards across processes.
+        const owner = randomUUID();
+        if (!this.persistence.acquireDreamLock(owner, this.dreamConfig.leaseTtlMs)) {
+            return this.emptyDreamResult(start);
+        }
+        this.dreaming = true;
+        let rowsClaimed = 0;
+        let rowsCompleted = 0;
+        let rowsFailed = 0;
+        const batches = [];
+        try {
+            const { reclaimed } = this.persistence.reclaimExpiredDreamRows(this.dreamConfig.maxAttempts);
+            for (let b = 0; b < this.dreamConfig.maxBatchesPerDream; b++) {
+                // Heartbeat the cross-process lock so a long multi-batch drain doesn't
+                // lose it mid-flight (which would let another process start a colliding
+                // dream and double-process). Same-owner re-acquire refreshes the lease;
+                // a false return means our lease expired and someone else took over —
+                // yield to them.
+                if (!this.persistence.acquireDreamLock(owner, this.dreamConfig.leaseTtlMs)) {
+                    break;
+                }
+                const rows = this.persistence.claimDreamRows(this.dreamConfig.maxRowsPerDream, owner, this.dreamConfig.leaseTtlMs);
+                if (rows.length === 0)
+                    break;
+                rowsClaimed += rows.length;
+                try {
+                    // Keep (row, trajectory) pairs so the per-row routing snapshot is
+                    // available for deferred Phase-2 replay.
+                    const pairs = [];
+                    const corruptIds = [];
+                    for (const row of rows) {
+                        const traj = parseQueuedTrajectory(row.trajectory_json);
+                        if (traj)
+                            pairs.push({ row, traj });
+                        else
+                            corruptIds.push(row.id);
+                    }
+                    const trajectories = pairs.map((p) => p.traj);
+                    // Idempotency sentinel (B): a trajectory already consolidated by a
+                    // prior (failed-then-retried) dream has a reflexion episode. Skip its
+                    // per-trajectory replay so the one non-idempotent output (knowledge
+                    // notes) isn't re-extracted. Reflexion + meta are also idempotent by
+                    // construction (deterministic ids), so this is belt-and-suspenders;
+                    // the skip mainly protects knowledge. NOTE: relies on reflexion being
+                    // enabled (the default) as the sentinel.
+                    const freshPairs = [];
+                    for (const p of pairs) {
+                        let alreadyConsolidated = false;
+                        try {
+                            alreadyConsolidated = !!(await this.memory.reflexion.getByTrajectory(p.traj.id));
+                        }
+                        catch {
+                            // Treat a lookup failure as not-consolidated (safe: at worst re-runs).
+                        }
+                        if (!alreadyConsolidated)
+                            freshPairs.push(p);
+                    }
+                    // Replay the deferred immediate-phase analytics (knowledge / causal /
+                    // reflexion) the trimmed hot path skipped. Only when analytics were
+                    // actually deferred (decoupled mode) — otherwise the capture already
+                    // ran them inline and re-running would double-count.
+                    if (this.instantLoop.deferAnalytics) {
+                        for (const { traj } of freshPairs) {
+                            try {
+                                await this.instantLoop.runAnalytics(traj);
+                            }
+                            catch {
+                                // Non-fatal — analytics are best-effort; the batch still runs.
+                            }
+                        }
+                    }
+                    // Replay the deferred Phase-2 processing (meta-reflection +
+                    // effectiveness) from each row's routing snapshot. Skip
+                    // already-consolidated trajectories (idempotent anyway, but avoids
+                    // redundant work).
+                    for (const { row, traj } of freshPairs) {
+                        await this.runDeferredPhase2(traj, row.routing_json);
+                    }
+                    // Re-derive analyses from the drained trajectories — the in-memory
+                    // analyses don't survive a separate process, so recomputing here
+                    // makes the queue the single source of truth.
+                    const analyses = [];
+                    for (const traj of trajectories) {
+                        analyses.push(this.taskRunner
+                            ? await this.analyzeWithTemplate(traj)
+                            : await this.analyzer.analyze(traj));
+                    }
+                    const batch = await this.runBatchOver(trajectories, analyses, ['manual_override']);
+                    batches.push(batch);
+                    // Complete only successfully-parsed rows. Unparseable rows are parked
+                    // as `failed` directly (corrupt JSON won't fix itself on retry) —
+                    // observable via getDreamQueueStats, not silently DELETEd, and not
+                    // requeued into an infinite re-parse loop.
+                    this.persistence.completeDreamRows(pairs.map((p) => p.row.id));
+                    rowsCompleted += pairs.length;
+                    if (corruptIds.length > 0) {
+                        this.persistence.failDreamRows(corruptIds);
+                        rowsFailed += corruptIds.length;
+                    }
+                }
+                catch {
+                    // Recoverable: return the rows to pending for a later dream. The
+                    // attempts counter (bumped on claim) eventually parks poison rows.
+                    this.persistence.releaseDreamRows(rows.map((r) => r.id));
+                    rowsFailed += rows.length;
+                    break;
+                }
+                if (!drainAll)
+                    break;
+            }
+            // Maintenance check after draining (mirrors the inline path's ordering).
+            let maintenance;
+            if (rowsCompleted > 0 && this.validationAllowsScheduling()) {
+                this.maintenanceScheduler.onBatchComplete();
+                if (this.maintenanceScheduler.shouldRunMaintenance()) {
+                    maintenance = await this.runMaintenance();
+                }
+            }
+            return {
+                dreamedAt: new Date(),
+                rowsClaimed,
+                rowsCompleted,
+                rowsFailed,
+                reclaimed,
+                batch: aggregateBatchResults(batches),
+                maintenance,
+                durationMs: Date.now() - start,
+            };
+        }
+        finally {
+            this.dreaming = false;
+            this.persistence.releaseDreamLock(owner);
+        }
+    }
+    emptyDreamResult(start) {
+        return {
+            dreamedAt: new Date(),
+            rowsClaimed: 0,
+            rowsCompleted: 0,
+            rowsFailed: 0,
+            reclaimed: 0,
+            batch: this.emptyBatchResult(['manual_override']),
+            durationMs: Date.now() - start,
+        };
+    }
+    /**
+     * Replay deferred Phase-2 processing (C2) for one trajectory from its routing
+     * snapshot: meta-reflection (heuristic) + effectiveness annotation. Playbook
+     * matches are rehydrated by id from memory (current state). Best-effort —
+     * never fails the dream. (Usage inference stays inline in `solve()`; it is
+     * SkillLibrary-coupled and produces the synchronous solve result.)
+     */
+    async runDeferredPhase2(trajectory, routingJson) {
+        if (!routingJson) {
+            // External trajectory (no routing happened). Meta-reflection and strategy
+            // credit are genuinely inapplicable — but effectiveness annotation is
+            // not: detect out-of-band exposure (declared metadata / explicit skill
+            // references in the transcript) so production learn/dream traffic feeds
+            // the guided-vs-unguided scorecard instead of being invisible to it.
+            await this.annotateExternalTrajectory(trajectory);
+            return;
+        }
+        let snap;
+        try {
+            snap = JSON.parse(routingJson);
+        }
+        catch {
+            return;
+        }
+        // Rehydrate playbook matches by id (skip any since-deleted playbooks).
+        const playbookMatches = [];
+        for (const ref of snap.playbookMatchRefs ?? []) {
+            try {
+                const pb = await this.memory.playbooks.get(ref.id);
+                if (pb) {
+                    playbookMatches.push({
+                        playbook: pb,
+                        score: ref.score,
+                        matchType: ref.matchType,
+                    });
+                }
+            }
+            catch {
+                // Skip a bad ref.
+            }
+        }
+        if (this.validationCanWrite('metaPlaybook') && this.metaLearner) {
+            try {
+                await this.metaLearner.generateReflection(trajectory, snap.routingInfo, playbookMatches);
+            }
+            catch {
+                // Non-fatal.
+            }
+        }
+        if (this.validationCanWrite('diagnosticOnly') && this.effectivenessTracker) {
+            try {
+                await this.effectivenessTracker.annotate(trajectory, playbookMatches, snap.surfacedExperienceIds ?? [], snap.appliedPlaybookIds ?? [], snap.surfacedKnowledgeNoteIds ?? []);
+                // Guided = anything was surfaced (same definition the annotation's
+                // totalItems uses: playbooks + experiences + knowledge notes).
+                this.recordLiftCell(trajectory, playbookMatches.length +
+                    (snap.surfacedExperienceIds?.length ?? 0) +
+                    (snap.surfacedKnowledgeNoteIds?.length ?? 0) >
+                    0);
+            }
+            catch {
+                // Non-fatal.
+            }
+        }
     }
     /**
-     * Register a custom anomaly detector for the healing orchestrator.
+     * Production lift rollup: fold one annotated trajectory into its
+     * per-(scope, family, solver) `lift_cells` row in the instance DB.
+     * scope='production' (never pooled with eval scopes), family=task.domain,
+     * solver canonicalized from trajectory metadata. Write-only and cheap —
+     * one upsert, dream-time only. Best-effort: never fails the dream.
      */
-    addAnomalyDetector(detector) {
-        this.healingOrchestrator.addDetector(detector);
+    recordLiftCell(trajectory, guided) {
+        if (!(this.config.features.liftTracking ?? true))
+            return;
+        if (!this.persistence)
+            return;
+        try {
+            const rawModel = trajectory.metadata?.model;
+            this.persistence.recordLiftOutcome({
+                scope: 'production',
+                family: trajectory.task.domain || 'unknown',
+                solver: canonicalizeSolver(typeof rawModel === 'string' ? rawModel : undefined),
+                guided,
+                success: trajectory.outcome.success,
+            });
+        }
+        catch {
+            // Non-fatal.
+        }
     }
     /**
-     * Register a custom repair strategy for the healing orchestrator.
+     * Effectiveness annotation for an external trajectory (no routing snapshot).
+     *
+     * Exposure is inferred rather than known: playbooks declared in trajectory
+     * metadata (`SURFACED_PLAYBOOKS_METADATA_KEY`, the serving-layer contract)
+     * or explicitly referenced in the steps count as surfaced; explicit
+     * references count as applied; declared-only playbooks go through the same
+     * tactic-level usage inference `solve()` uses. Trajectories with no detected
+     * exposure are annotated unguided — they form the lift baseline.
+     * Best-effort — never fails the dream.
      */
-    addRepairStrategy(strategy) {
-        this.healingOrchestrator.addRepairStrategy(strategy);
+    async annotateExternalTrajectory(trajectory) {
+        if (!this.validationCanWrite('diagnosticOnly') || !this.effectivenessTracker)
+            return;
+        try {
+            const { detectExternalPlaybookExposure } = await import('./external-exposure.js');
+            const exposure = detectExternalPlaybookExposure(trajectory, await this.memory.playbooks.getAll());
+            const appliedIds = new Set(exposure.applied.map((p) => p.id));
+            // Declared-but-not-referenced playbooks: fall back to tactic-level
+            // usage inference to decide whether they were actually followed.
+            const declaredOnly = exposure.surfaced.filter((p) => !appliedIds.has(p.id));
+            if (declaredOnly.length > 0) {
+                const { createUsageInference } = await import('./usage-inference.js');
+                const usage = await createUsageInference().inferUsage(trajectory, declaredOnly);
+                for (const u of usage) {
+                    if (u.wasUsed)
+                        appliedIds.add(u.playbookId);
+                }
+            }
+            const surfacedMatches = exposure.surfaced.map((playbook) => ({
+                playbook,
+                score: 1,
+                matchType: 'situation',
+            }));
+            await this.effectivenessTracker.annotate(trajectory, surfacedMatches, [], [...appliedIds]);
+            this.recordLiftCell(trajectory, exposure.surfaced.length > 0);
+        }
+        catch {
+            // Non-fatal.
+        }
+    }
+    /**
+     * Register a custom maintenance task.
+     */
+    registerMaintenanceTask(task) {
+        this.maintenanceScheduler.registerTask(task);
     }
     // =========================================================================
     // ACCESSORS
@@ -423,12 +1061,6 @@ export class UnifiedLearningPipeline {
     getEffectivenessTracker() {
         return this.effectivenessTracker;
     }
-    /**
-     * Get the energy evaluator.
-     */
-    getEnergyEvaluator() {
-        return this.energyEvaluator;
-    }
     /**
      * Get the maintenance scheduler.
      */
@@ -436,25 +1068,18 @@ export class UnifiedLearningPipeline {
         return this.maintenanceScheduler;
     }
     /**
-     * Get the healing orchestrator.
-     */
-    getHealingOrchestrator() {
-        return this.healingOrchestrator;
-    }
-    /**
-     * Get accumulated trajectory count.
+     * Get accumulated trajectory count. Always 0 — learning is decoupled, so
+     * trajectories are durably enqueued for `dream()` rather than held in memory.
      */
     getAccumulatedCount() {
-        return this.accumulated.length;
+        return 0;
     }
     /**
-     * Get accumulated trajectories with analyses (read-only).
+     * Get accumulated trajectories with analyses (read-only). Always empty —
+     * learning is decoupled (see {@link getAccumulatedCount}).
      */
     getAccumulated() {
-        return this.accumulated.map((trajectory, i) => ({
-            trajectory,
-            analysis: this.accumulatedAnalyses[i],
-        }));
+        return [];
     }
     /**
      * Get pipeline statistics.
@@ -464,11 +1089,9 @@ export class UnifiedLearningPipeline {
             totalProcessed: this.totalProcessed,
             batchCyclesRun: this.batchCyclesRun,
             maintenanceCyclesRun: this.maintenanceCyclesRun,
-            pendingForBatch: this.energyEvaluator.getPendingCount(),
             batchesSinceLastMaintenance: this.maintenanceScheduler.getBatchesSinceLastMaintenance(),
-            maintenanceTasks: this.maintenanceScheduler.getRegisteredTasks().map(t => t.name),
-            anomalyDetectors: this.healingOrchestrator.getDetectors().map(d => d.name),
-            repairStrategies: this.healingOrchestrator.getRepairStrategies().map(s => s.name),
+            maintenanceTasks: this.maintenanceScheduler.getRegisteredTasks().map((t) => t.name),
+            mutation: this.mutationActivity,
         };
     }
     /**
@@ -493,26 +1116,6 @@ export class UnifiedLearningPipeline {
      * Register built-in maintenance tasks.
      */
     registerBuiltInMaintenanceTasks() {
-        // Healing cycle
-        this.maintenanceScheduler.registerTask({
-            name: 'healing-cycle',
-            priority: 100,
-            execute: async () => {
-                const start = Date.now();
-                const context = await this.buildHealthContext();
-                const result = await this.healingOrchestrator.runCycle(context);
-                return {
-                    taskName: 'healing-cycle',
-                    success: true,
-                    durationMs: Date.now() - start,
-                    details: {
-                        anomaliesDetected: result.anomaliesDetected.length,
-                        repairsAttempted: result.repairs.length,
-                        repairsSucceeded: result.repairs.filter(r => r.success).length,
-                    },
-                };
-            },
-        });
         // Knowledge defrag (if knowledge bank is available)
         if (this.memory.knowledgeBank) {
             this.maintenanceScheduler.registerTask({
@@ -520,6 +1123,14 @@ export class UnifiedLearningPipeline {
                 priority: 80,
                 execute: async () => {
                     const start = Date.now();
+                    if (!this.validationCanWrite('knowledgeNote')) {
+                        return {
+                            taskName: 'knowledge-defrag',
+                            success: true,
+                            durationMs: Date.now() - start,
+                            details: { skipped: true, reason: 'validation write mask excludes knowledgeNote' },
+                        };
+                    }
                     const kb = this.memory.knowledgeBank;
                     const shouldDefrag = await kb.shouldDefragment();
                     if (!shouldDefrag) {
@@ -547,6 +1158,14 @@ export class UnifiedLearningPipeline {
                 priority: 60,
                 execute: async () => {
                     const start = Date.now();
+                    if (!this.validationCanWrite('metaPlaybook')) {
+                        return {
+                            taskName: 'meta-strategy-generation',
+                            success: true,
+                            durationMs: Date.now() - start,
+                            details: { skipped: true, reason: 'validation write mask excludes metaPlaybook' },
+                        };
+                    }
                     if (!this.metaLearner) {
                         return {
                             taskName: 'meta-strategy-generation',
@@ -567,6 +1186,302 @@ export class UnifiedLearningPipeline {
         }
         // Efficacy maintenance tasks
         this.registerEfficacyMaintenanceTasks();
+        // Pareto merge proposing
+        this.registerMergeProposingTask();
+        // Reflective single-parent mutation
+        this.registerReflectiveMutationTask();
+        // PR-D2: harmful-playbook prune pass
+        this.registerCurationPruneTask();
+    }
+    /**
+     * Register the curation prune maintenance task (PR-D2).
+     *
+     * Prunes playbooks where failureCount >= successCount + MIN_EVIDENCE so
+     * net-harmful guidance is retired before it degrades future injection.
+     * MIN_EVIDENCE (default 3) prevents premature pruning of zero/low-count
+     * items. Gated on features.curation — setting it false disables the prune
+     * entirely (append-only ablation).
+     */
+    registerCurationPruneTask() {
+        this.maintenanceScheduler.registerTask({
+            name: 'curation-prune',
+            priority: 50,
+            execute: async () => {
+                const start = Date.now();
+                if (!this.validationCanWrite('playbook')) {
+                    return {
+                        taskName: 'curation-prune',
+                        success: true,
+                        durationMs: Date.now() - start,
+                        details: { skipped: true, reason: 'validation write mask excludes playbook' },
+                    };
+                }
+                if (!this.config.features?.curation) {
+                    return {
+                        taskName: 'curation-prune',
+                        success: true,
+                        durationMs: Date.now() - start,
+                        details: { skipped: true, reason: 'features.curation disabled' },
+                    };
+                }
+                const pruned = await this.memory.playbooks.pruneHarmful();
+                return {
+                    taskName: 'curation-prune',
+                    success: true,
+                    durationMs: Date.now() - start,
+                    details: { pruned: pruned.length, prunedIds: pruned },
+                };
+            },
+        });
+    }
+    /**
+     * Register the merge-proposing maintenance task. Scans active task
+     * signatures, asks the MergeProposer for candidate pairs (Pareto
+     * dominators with a common ancestor), then gates each proposal via
+     * MutationGate. Skips if the feature is disabled, no judge was
+     * provided, or there's no persistence handle to enumerate signatures.
+     */
+    registerMergeProposingTask() {
+        this.maintenanceScheduler.registerTask({
+            name: 'pareto-merge-proposing',
+            priority: 50,
+            execute: async () => {
+                const start = Date.now();
+                if (!(this.config.features.mergeProposing ?? false)) {
+                    return {
+                        taskName: 'pareto-merge-proposing',
+                        success: true,
+                        durationMs: Date.now() - start,
+                        details: { skipped: true, reason: 'feature disabled' },
+                    };
+                }
+                if (!this.validationCanWrite('playbook')) {
+                    return {
+                        taskName: 'pareto-merge-proposing',
+                        success: true,
+                        durationMs: Date.now() - start,
+                        details: { skipped: true, reason: 'validation write mask excludes playbook' },
+                    };
+                }
+                if (!this.persistence) {
+                    return {
+                        taskName: 'pareto-merge-proposing',
+                        success: true,
+                        durationMs: Date.now() - start,
+                        details: { skipped: true, reason: 'no persistence handle' },
+                    };
+                }
+                if (!this.judge) {
+                    return {
+                        taskName: 'pareto-merge-proposing',
+                        success: true,
+                        durationMs: Date.now() - start,
+                        details: { skipped: true, reason: 'no judge configured' },
+                    };
+                }
+                const proposer = new MergeProposer(this.memory.playbooks, this.persistence);
+                const gate = new MutationGate(this.memory.playbooks, this.persistence, this.judge);
+                // Bound judge/LLM spend per cycle, symmetric with reflective mutation.
+                const maxProposalsPerCycle = 5;
+                const signatures = this.persistence.getActiveSignatures(20);
+                let proposalsConsidered = 0;
+                let proposalsAccepted = 0;
+                const acceptedIds = [];
+                const reasonCounts = {};
+                outer: for (const sig of signatures) {
+                    const proposals = await proposer.proposePairsForSignature(sig);
+                    for (const proposal of proposals) {
+                        if (proposalsConsidered >= maxProposalsPerCycle)
+                            break outer;
+                        proposalsConsidered++;
+                        try {
+                            const primaryBefore = await this.memory.playbooks.get(proposal.primaryParentId);
+                            // Use the two-parent merge gate: stratified minibatch across
+                            // (A-beats-B, B-beats-A, tied) buckets + acceptance on
+                            // child >= max(parents). Matches GEPA's engine.py:688.
+                            const decision = await gate.proposeFromMerge(proposal.primaryParentId, proposal.secondaryParentId, proposal.merged, sig);
+                            reasonCounts[decision.reason] = (reasonCounts[decision.reason] ?? 0) + 1;
+                            // Trace + journal the merge decision. The acceptance threshold is
+                            // max(parents), so record that as the parent sum for the delta.
+                            this.recordMutationDecision({
+                                mutationType: 'merge',
+                                taskSignature: sig,
+                                parentId: proposal.primaryParentId,
+                                secondaryParentId: proposal.secondaryParentId,
+                                candidate: proposal.merged,
+                                reason: decision.reason,
+                                accepted: decision.accepted,
+                                parentSum: Math.max(decision.parentASum, decision.parentBSum),
+                                childSum: decision.childSum,
+                                judgeCalls: decision.judgeCalls,
+                                guidanceBefore: compactGuidanceText(primaryBefore),
+                            });
+                            // Record only definitive outcomes so transient sparse-data
+                            // attempts get retried next cycle when more data exists.
+                            if (decision.reason === 'improved' || decision.reason === 'regression') {
+                                this.persistence.recordMergeAttempt(proposal.primaryParentId, proposal.secondaryParentId, proposal.commonAncestorId, decision.reason === 'improved' ? 'accepted' : 'regression');
+                            }
+                            if (decision.accepted) {
+                                proposalsAccepted++;
+                                acceptedIds.push(proposal.merged.id);
+                            }
+                        }
+                        catch {
+                            // Non-fatal — one bad proposal shouldn't kill the cycle.
+                        }
+                    }
+                }
+                return {
+                    taskName: 'pareto-merge-proposing',
+                    success: true,
+                    durationMs: Date.now() - start,
+                    details: {
+                        signaturesScanned: signatures.length,
+                        proposalsConsidered,
+                        proposalsAccepted,
+                        acceptedIds,
+                        reasonCounts,
+                    },
+                };
+            },
+        });
+    }
+    /**
+     * Register the reflective-mutation maintenance task. Scans active task
+     * signatures, asks the ReflectiveMutationProposer to revise one
+     * Pareto-frontier playbook per signature from its failure traces, then
+     * gates each candidate via the single-parent MutationGate. Skips if the
+     * feature is disabled, there's no persistence handle, no judge, or no
+     * LLM provider.
+     *
+     * Mirrors `registerMergeProposingTask` — same scan/gate shape — but uses
+     * the generative single-parent path (`MutationGate.propose`) instead of
+     * the recombination path (`proposeFromMerge`). A per-cycle cap bounds LLM
+     * spend regardless of how many signatures are active.
+     */
+    registerReflectiveMutationTask() {
+        this.maintenanceScheduler.registerTask({
+            name: 'reflective-mutation',
+            priority: 50,
+            execute: async () => {
+                const start = Date.now();
+                if (!(this.config.features.reflectiveMutation ?? false)) {
+                    return {
+                        taskName: 'reflective-mutation',
+                        success: true,
+                        durationMs: Date.now() - start,
+                        details: { skipped: true, reason: 'feature disabled' },
+                    };
+                }
+                if (!this.validationCanWrite('playbook')) {
+                    return {
+                        taskName: 'reflective-mutation',
+                        success: true,
+                        durationMs: Date.now() - start,
+                        details: { skipped: true, reason: 'validation write mask excludes playbook' },
+                    };
+                }
+                if (!this.persistence) {
+                    return {
+                        taskName: 'reflective-mutation',
+                        success: true,
+                        durationMs: Date.now() - start,
+                        details: { skipped: true, reason: 'no persistence handle' },
+                    };
+                }
+                if (!this.judge) {
+                    return {
+                        taskName: 'reflective-mutation',
+                        success: true,
+                        durationMs: Date.now() - start,
+                        details: { skipped: true, reason: 'no judge configured' },
+                    };
+                }
+                if (!this.llm) {
+                    return {
+                        taskName: 'reflective-mutation',
+                        success: true,
+                        durationMs: Date.now() - start,
+                        details: { skipped: true, reason: 'no llm provider configured' },
+                    };
+                }
+                const proposer = new ReflectiveMutationProposer(this.memory.playbooks, this.persistence, this.llm);
+                const gate = new MutationGate(this.memory.playbooks, this.persistence, this.judge);
+                // Bound LLM spend per cycle: one proposal per signature, capped.
+                const maxProposalsPerCycle = 5;
+                const signatures = this.persistence.getActiveSignatures(20);
+                // Don't reflect the same parent on more than one signature this
+                // cycle — a parent failing across signatures would otherwise spawn
+                // several near-duplicate children at once.
+                const proposedParents = new Set();
+                let proposalsConsidered = 0;
+                let proposalsAccepted = 0;
+                const acceptedIds = [];
+                const reasonCounts = {};
+                for (const sig of signatures) {
+                    if (proposalsConsidered >= maxProposalsPerCycle)
+                        break;
+                    try {
+                        const proposal = await proposer.propose(sig, {
+                            excludeParents: proposedParents,
+                        });
+                        if (!proposal)
+                            continue;
+                        proposalsConsidered++;
+                        proposedParents.add(proposal.parentId);
+                        // Capture the parent's guidance BEFORE the gate commits/mutates so
+                        // the trace/journal record a faithful before→after diff.
+                        const parentBefore = await this.memory.playbooks.get(proposal.parentId);
+                        const decision = await gate.propose(proposal.parentId, proposal.candidate, sig);
+                        reasonCounts[decision.reason] = (reasonCounts[decision.reason] ?? 0) + 1;
+                        // Observability + statefulness: trace every considered proposal and
+                        // journal its learning content (candidate direction, reason, score
+                        // delta, rationale) for the proposer to reflect on next cycle.
+                        this.recordMutationDecision({
+                            mutationType: 'reflective',
+                            taskSignature: sig,
+                            parentId: proposal.parentId,
+                            candidate: proposal.candidate,
+                            rationale: proposal.rationale,
+                            reason: decision.reason,
+                            accepted: decision.accepted,
+                            parentSum: decision.parentSum,
+                            childSum: decision.childSum,
+                            judgeCalls: decision.judgeCalls,
+                            guidanceBefore: compactGuidanceText(parentBefore),
+                        });
+                        // Record any committed acceptance (incl. sparse/empty-minibatch
+                        // accepts) and definitive regressions, so the proposer doesn't
+                        // re-reflect the same parent on the same failures every cycle.
+                        // Non-definitive rejections (empty-minibatch policy reject,
+                        // no-mutation, parent-missing) are NOT recorded so they retry
+                        // once more data exists.
+                        if (decision.accepted || decision.reason === 'regression') {
+                            this.persistence.recordReflectionAttempt(proposal.parentId, proposal.failureFingerprint, decision.accepted ? 'accepted' : 'regression');
+                        }
+                        if (decision.accepted) {
+                            proposalsAccepted++;
+                            acceptedIds.push(proposal.candidate.id);
+                        }
+                    }
+                    catch {
+                        // Non-fatal — one bad proposal shouldn't kill the cycle.
+                    }
+                }
+                return {
+                    taskName: 'reflective-mutation',
+                    success: true,
+                    durationMs: Date.now() - start,
+                    details: {
+                        signaturesScanned: signatures.length,
+                        proposalsConsidered,
+                        proposalsAccepted,
+                        acceptedIds,
+                        reasonCounts,
+                    },
+                };
+            },
+        });
     }
     /**
      * Register efficacy maintenance tasks (decay detection, audit, lifecycle review).
@@ -584,7 +1499,8 @@ export class UnifiedLearningPipeline {
                 const start = Date.now();
                 this.lastDecayResult = null;
                 const { annotations, playbooks, playbookEffectiveness, unguidedSuccessRate } = await this.getEfficacyData();
-                if (playbooks.length < efficacyCfg.minPlaybooks || annotations.length < efficacyCfg.minAnnotations) {
+                if (playbooks.length < efficacyCfg.minPlaybooks ||
+                    annotations.length < efficacyCfg.minAnnotations) {
                     return {
                         taskName: 'playbook-decay-detection',
                         success: true,
@@ -628,10 +1544,7 @@ export class UnifiedLearningPipeline {
                         details: { skipped: true, reason: 'no decay detection results' },
                     };
                 }
-                const flagged = [
-                    ...this.lastDecayResult.decaying,
-                    ...this.lastDecayResult.atRisk,
-                ];
+                const flagged = [...this.lastDecayResult.decaying, ...this.lastDecayResult.atRisk];
                 if (flagged.length === 0) {
                     return {
                         taskName: 'playbook-efficacy-audit',
@@ -641,8 +1554,8 @@ export class UnifiedLearningPipeline {
                     };
                 }
                 const { annotations, playbooks, playbookEffectiveness, unguidedSuccessRate } = await this.getEfficacyData();
-                const playbookMap = new Map(playbooks.map(p => [p.id, p]));
-                const effectivenessMap = new Map(playbookEffectiveness.map(e => [e.playbookId, e]));
+                const playbookMap = new Map(playbooks.map((p) => [p.id, p]));
+                const effectivenessMap = new Map(playbookEffectiveness.map((e) => [e.playbookId, e]));
                 const trajectoryDomainMap = this.buildTrajectoryDomainMap(annotations);
                 const audits = [];
                 for (const signal of flagged) {
@@ -693,7 +1606,8 @@ export class UnifiedLearningPipeline {
                     };
                 }
                 const { annotations, playbooks, playbookEffectiveness, unguidedSuccessRate } = await this.getEfficacyData();
-                if (playbooks.length < efficacyCfg.minPlaybooks || annotations.length < efficacyCfg.minAnnotations) {
+                if (playbooks.length < efficacyCfg.minPlaybooks ||
+                    annotations.length < efficacyCfg.minAnnotations) {
                     return {
                         taskName: 'playbook-lifecycle-review',
                         success: true,
@@ -749,41 +1663,13 @@ export class UnifiedLearningPipeline {
     }
     /**
      * Build a trajectoryId→domain map from annotations.
-     * Uses accumulated trajectories when available, otherwise infers from task annotations.
+     *
+     * Learning is decoupled, so there are no in-memory trajectories to map from
+     * here. Annotations don't carry domain, so trajectories fall through to the
+     * toolkit's 'unknown' default — acceptable for log-only mode.
      */
     buildTrajectoryDomainMap(_annotations) {
-        const domainMap = new Map();
-        // Map from accumulated trajectories (has task.domain directly).
-        // Annotations don't carry domain, so historical trajectories will
-        // fall through to the toolkit's 'unknown' default — acceptable for log-only mode.
-        for (const t of this.accumulated) {
-            domainMap.set(t.id, t.task.domain);
-        }
-        return domainMap;
-    }
-    /**
-     * Build health context for the healing orchestrator.
-     */
-    async buildHealthContext() {
-        const [experienceCount, playbookCount] = await Promise.all([
-            this.memory.experiences.count(),
-            this.memory.playbooks.count(),
-        ]);
-        // Compute recent success rate from accumulated analyses
-        const recentAnalyses = this.accumulatedAnalyses.length > 0
-            ? this.accumulatedAnalyses
-            : [];
-        const recentSuccessRate = recentAnalyses.length > 0
-            ? recentAnalyses.filter(a => a.success).length / recentAnalyses.length
-            : 1.0;
-        return {
-            trajectoriesProcessed: this.totalProcessed,
-            experienceCount,
-            playbookCount,
-            recentSuccessRate,
-            batchesSinceLastMaintenance: this.maintenanceScheduler.getBatchesSinceLastMaintenance(),
-            metrics: {},
-        };
+        return new Map();
     }
     /**
      * Analyze a trajectory via workspace template or heuristic fallback.
@@ -800,24 +1686,338 @@ export class UnifiedLearningPipeline {
             return this.analyzer.analyze(trajectory);
         }
     }
+    /**
+     * Seed the Pareto frontier with rows attributing the source trajectories'
+     * successful outcomes to the newly minted playbook. Walks
+     * `playbook.evolution.createdFrom` (trajectory ids), looks up the
+     * corresponding experience and trajectory, and writes a frontier row
+     * (and live eval cache entry) per attested win.
+     *
+     * Without this, a freshly-extracted playbook starts with zero frontier
+     * presence and only earns rows once the router happens to match it on
+     * a live task — which can take weeks of solves before the frontier
+     * starts being useful.
+     */
+    /**
+     * G3(b): apply stored reflexion `suggestedPlaybookUpdates` to a playbook's
+     * `applicability.antiPatterns`, durably (cross-run). Walks the playbook's
+     * source trajectories (`evolution.createdFrom`), reads each one's reflexion
+     * episode, and lifts avoid/anti-pattern-style suggestions onto the record.
+     *
+     * G1 already feeds the same suggestions into the per-attempt *retry prompt*
+     * (ephemeral); this is the persist-to-playbook side and does not duplicate
+     * that path. Mutates `playbook` in place; the caller persists it.
+     */
+    async applyReflexionAntiPatterns(playbook) {
+        const trajectoryIds = playbook.evolution.createdFrom ?? [];
+        if (trajectoryIds.length === 0)
+            return;
+        for (const trajId of trajectoryIds) {
+            let episode;
+            try {
+                episode = await this.memory.reflexion.getByTrajectory(trajId);
+            }
+            catch {
+                continue; // Reflexion lookup is best-effort.
+            }
+            if (!episode)
+                continue;
+            for (const suggestion of episode.suggestedPlaybookUpdates) {
+                const antiPattern = reflexionSuggestionToAntiPattern(suggestion);
+                if (antiPattern && !playbook.applicability.antiPatterns.includes(antiPattern)) {
+                    playbook.applicability.antiPatterns.push(antiPattern);
+                }
+            }
+        }
+    }
+    async seedFrontierForNewPlaybook(playbook, batchTrajectories) {
+        if (!this.validationCanWrite('frontier'))
+            return;
+        const trajectoryIds = playbook.evolution.createdFrom ?? [];
+        if (trajectoryIds.length === 0)
+            return;
+        const trajById = new Map(batchTrajectories.map((t) => [t.id, t]));
+        for (const trajId of trajectoryIds) {
+            const traj = trajById.get(trajId);
+            if (!traj)
+                continue; // Trajectory not in current batch — skip.
+            const experiences = this.persistence?.getExperiencesByTrajectory(trajId);
+            if (!experiences || experiences.length === 0)
+                continue;
+            const sig = taskSignature(traj.task);
+            const score = traj.outcome.success
+                ? Math.max(traj.outcome.partialScore, 1.0)
+                : traj.outcome.partialScore;
+            // Derive multi-objective scores the same way the instant loop does
+            // (cost from totalTokens, latency from wallTimeSeconds, etc.) so the
+            // cartesian frontier is populated alongside the single-objective one.
+            // Otherwise `prefer: 'cheap' | 'fast'` routing treats freshly-extracted
+            // playbooks as invisible until live traffic accumulates.
+            const objectives = deriveObjectives(traj);
+            for (const expRow of experiences) {
+                try {
+                    await this.memory.playbooks.recordLiveOutcome(playbook.id, sig, expRow.id, score, objectives);
+                }
+                catch {
+                    // Non-fatal — playbook is still added, just lacks the seed row.
+                }
+            }
+        }
+    }
     /**
      * Extract playbooks via workspace template or heuristic fallback.
      */
-    async extractPlaybooks(existingPlaybooks) {
+    async extractPlaybooks(existingPlaybooks, trajectories, analyses) {
+        const startTime = Date.now();
+        // Routing domain(s) of this batch's trajectories — stamped onto every
+        // extracted playbook so it is retrievable by the key future same-domain
+        // tasks route with (see stampExtractionProvenance).
+        const sourceDomains = [...new Set(trajectories.map((t) => t.task.domain).filter(Boolean))];
+        const attemptedMethods = [];
+        let workspaceFallbackReason;
+        let workspaceDiag;
         if (this.taskRunner) {
             try {
+                attemptedMethods.push('workspace-agent');
                 const result = await this.taskRunner.run(playbookExtractionTemplate, {
-                    trajectories: this.accumulated,
-                    analyses: this.accumulatedAnalyses,
+                    trajectories,
+                    analyses,
+                    existingPlaybooks,
+                });
+                const output = this.stampExtractionProvenance(result.output, result.method === 'agentic' ? 'workspace-agent' : 'heuristic', {
+                    fallbackReason: result.method === 'heuristic'
+                        ? 'template complexity assessed as heuristic'
+                        : undefined,
+                    template: playbookExtractionTemplate.taskType,
+                    templateVersion: playbookExtractionTemplate.templateVersion,
+                    sourceDomains,
+                });
+                this.recordPlaybookExtractionDiagnostics({
+                    trajectories,
+                    analyses,
+                    existingPlaybooks,
+                    attemptedMethods,
+                    selectedMethod: result.method === 'agentic' ? 'workspace-agent' : 'heuristic',
+                    extracted: output,
+                    durationMs: Date.now() - startTime,
+                    fallbackReason: result.method === 'heuristic' ? 'template complexity assessed as heuristic' : undefined,
+                    workspace: {
+                        id: result.workspaceId,
+                        path: result.workspacePath,
+                        complexity: result.complexity,
+                    },
+                    agent: {
+                        trajectoryId: result.agentTrajectoryId,
+                        totalTimeMs: result.metrics.totalTimeMs,
+                        tokensUsed: result.metrics.tokensUsed,
+                        toolCalls: result.metrics.toolCalls,
+                    },
+                    injectedMetaPlaybookIds: result.injectedMetaPlaybookIds,
+                });
+                return output;
+            }
+            catch (error) {
+                if (error instanceof AgenticTaskRunError) {
+                    workspaceDiag = {
+                        id: error.workspaceId,
+                        path: error.workspacePath,
+                        complexity: error.complexity,
+                        elapsedMs: error.elapsedMs,
+                        error: error.cause.message,
+                    };
+                }
+                else if (error instanceof AgenticTaskOutputError) {
+                    workspaceDiag = {
+                        id: error.workspaceId,
+                        path: error.workspacePath,
+                        complexity: error.complexity,
+                        elapsedMs: error.elapsedMs,
+                        error: error.cause.message,
+                        agentState: error.agentState,
+                        agentResultPreview: error.agentResultPreview,
+                        agentMessageCount: error.agentMessageCount,
+                    };
+                }
+                workspaceFallbackReason = `workspace-agent failed: ${error instanceof Error ? error.message : String(error)}`;
+                // Fall through to distiller or heuristic
+            }
+        }
+        // PR-D1: LLM distillation path — when patternExtractor==='llm' and a
+        // TrajectoryDistiller is wired, distill each trajectory individually and
+        // return the results as new playbooks. Failures distill to anti-pattern-only
+        // items. The heuristic PlaybookExtractor is the no-LLM fallback below.
+        //
+        // Design note: this runs in the batch/dream phase, never the <200ms hot
+        // path. Cache in distillation_cache keyed by trajectory hash + prompt
+        // version makes re-runs LLM-free.
+        //
+        // PR-D2 hook: near-dup check (embedding cosine > τ → merge instead of
+        // append) will be added here before the return, replacing the simple
+        // "add if not exists" check in runBatchOver. For now we return new items
+        // as-is and let the existing deduplicationThreshold check in runBatchOver
+        // handle coarse dedup by name similarity.
+        const wantsDistiller = this.learningConfig.patternExtractor === 'llm' ||
+            this.learningConfig.patternExtractor === 'both';
+        if (wantsDistiller && this.distiller) {
+            attemptedMethods.push('trajectory-distiller');
+            const result = { new: [], updates: [] };
+            for (let i = 0; i < trajectories.length; i++) {
+                const traj = trajectories[i];
+                try {
+                    // Thread the train-time oracle signal (verifier expected/diff/score)
+                    // so the distiller captures the output CONTRACT, not just process.
+                    // Legitimately available at dream time; never reaches the solver.
+                    // See docs/DESIGN-meta-learning-validation.md § "Train-time oracle
+                    // signal vs solve-time firewall".
+                    const verifierOutput = oracleVerifierText(readOracleSignal(traj.outcome.verificationDetails));
+                    const playbook = await this.distiller.distill(traj, traj.outcome, verifierOutput);
+                    if (playbook) {
+                        result.new.push(playbook);
+                    }
+                }
+                catch {
+                    // Non-fatal: skip this trajectory, heuristic fallback at the
+                    // trajectory level is omitted by design (distiller returns null on
+                    // failure; we just skip).
+                }
+            }
+            // Return distilled results if we got any; otherwise fall through to
+            // heuristic so a total LLM failure doesn't silently produce zero output.
+            if (result.new.length > 0) {
+                // eslint-disable-next-line no-console
+                logger.error(`[distiller] distilled ${result.new.length}/${trajectories.length} trajectories into playbooks`);
+                const output = this.stampExtractionProvenance(result, 'trajectory-distiller', {
+                    sourceDomains,
+                });
+                this.recordPlaybookExtractionDiagnostics({
+                    trajectories,
+                    analyses,
                     existingPlaybooks,
+                    attemptedMethods,
+                    selectedMethod: 'trajectory-distiller',
+                    extracted: output,
+                    durationMs: Date.now() - startTime,
+                    fallbackReason: workspaceFallbackReason,
+                    workspace: workspaceDiag,
                 });
-                return result.output;
+                return output;
             }
-            catch {
-                // Fall through to heuristic
+            // eslint-disable-next-line no-console
+            logger.error(`[distiller] produced 0 playbooks from ${trajectories.length} trajectories (self-check/parse rejects or LLM unavailable) — falling back to heuristic`);
+        }
+        // G2 / heuristic fallback: warn when LLM was requested but unavailable or
+        // produced no output, then run the low-fidelity heuristic extractor.
+        if (!this.taskRunner) {
+            // Only warn when an LLM-backed path was explicitly requested but not
+            // available — either no distiller (no LLM provider wired) or the
+            // distiller produced nothing.
+            this.warnHeuristicFallback();
+        }
+        attemptedMethods.push('heuristic');
+        const output = this.stampExtractionProvenance(await this.playbookExtractor.extract(trajectories, analyses, existingPlaybooks), 'heuristic', {
+            fallbackReason: workspaceFallbackReason,
+            sourceDomains,
+        });
+        this.recordPlaybookExtractionDiagnostics({
+            trajectories,
+            analyses,
+            existingPlaybooks,
+            attemptedMethods,
+            selectedMethod: 'heuristic',
+            extracted: output,
+            durationMs: Date.now() - startTime,
+            fallbackReason: workspaceFallbackReason,
+            workspace: workspaceDiag,
+        });
+        return output;
+    }
+    recordPlaybookExtractionDiagnostics(input) {
+        this.lastPlaybookExtractionDiagnostics = {
+            event: 'playbook-extraction',
+            injectedMetaPlaybookIds: input.injectedMetaPlaybookIds ?? [],
+            tier0: computeExtractionTier0(input.extracted.new, input.trajectories.length),
+            batchSize: input.trajectories.length,
+            existingPlaybookCount: input.existingPlaybooks.length,
+            trajectoryIds: input.trajectories.map((t) => t.id),
+            taskIds: input.trajectories.map((t) => t.task.id),
+            domains: [...new Set(input.trajectories.map((t) => t.task.domain))],
+            abstractableCount: input.analyses.filter((a) => a.abstractable).length,
+            attemptedMethods: input.attemptedMethods,
+            selectedMethod: input.selectedMethod,
+            durationMs: input.durationMs,
+            newCount: input.extracted.new.length,
+            updateCount: input.extracted.updates.length,
+            newPlaybooks: input.extracted.new.map((playbook) => ({
+                id: playbook.id,
+                name: playbook.name,
+                extractionMethod: playbook.provenance?.extractionMethod,
+                confidence: playbook.confidence,
+                triggers: playbook.applicability.triggers,
+                domains: playbook.applicability.domains,
+            })),
+            fallbackReason: input.fallbackReason,
+            workspace: input.workspace,
+            agent: input.agent,
+        };
+    }
+    emitDiagnostics(event) {
+        try {
+            this.diagnosticsCollector?.(event);
+        }
+        catch {
+            // diagnostics must never break learning
+        }
+    }
+    stampExtractionProvenance(extracted, method, options = {}) {
+        for (const playbook of extracted.new) {
+            playbook.provenance = {
+                ...(playbook.provenance ?? { origin: 'extracted', recordedAt: new Date() }),
+                origin: playbook.provenance?.origin ?? 'extracted',
+                recordedAt: playbook.provenance?.recordedAt ?? new Date(),
+                extractionMethod: method,
+                fallbackReason: options.fallbackReason,
+                template: options.template,
+                templateVersion: options.templateVersion,
+            };
+            if (options.sourceDomains && options.sourceDomains.length > 0) {
+                // PREPEND so the source routing domain becomes domains[0], which is what
+                // persistence stores as `primary_domain` and `getPlaybooksByDomain` matches
+                // on (sqlite-persistence.ts:791). Appending would leave the agent's invented
+                // domain (e.g. "office-automation") as primary, so the playbook stays
+                // unretrievable for its own family's tasks (e.g. domain "Office Operation").
+                playbook.applicability.domains = [
+                    ...new Set([...options.sourceDomains, ...playbook.applicability.domains]),
+                ];
             }
         }
-        return this.playbookExtractor.extract(this.accumulated, this.accumulatedAnalyses, existingPlaybooks);
+        return extracted;
+    }
+    /**
+     * G2: warn (or throw, under `strictExtraction`) when an LLM-backed
+     * extraction/credit path was requested but no agent backend is wired, so
+     * the silent heuristic fallback is no longer silent. Autonomous,
+     * high-fidelity extraction requires a backend (call `Atlas.setAgentManager`).
+     * Headless ingest still functions on the heuristic path when not strict.
+     */
+    warnHeuristicFallback() {
+        // Only relevant when an LLM-backed path was actually requested.
+        const wantsLlm = this.learningConfig.patternExtractor === 'llm' ||
+            this.learningConfig.patternExtractor === 'both' ||
+            this.learningConfig.creditStrategy === 'llm';
+        if (!wantsLlm)
+            return;
+        const msg = `[unified-pipeline] patternExtractor='${this.learningConfig.patternExtractor}'` +
+            ` (creditStrategy='${this.learningConfig.creditStrategy}') but no agent backend wired` +
+            ` (call Atlas.setAgentManager); using heuristic extractor — autonomous playbooks` +
+            ` will be low-fidelity.`;
+        if (this.learningConfig.strictExtraction) {
+            throw new Error(msg + ' [strictExtraction is ON]');
+        }
+        // Loud, but once-per-run.
+        if (!this.warnedHeuristicFallback) {
+            this.warnedHeuristicFallback = true;
+            logger.warn(msg);
+        }
     }
     /**
      * Empty batch result for when there's nothing to process.
@@ -835,10 +2035,79 @@ export class UnifiedLearningPipeline {
         };
     }
 }
+/**
+ * G3(b): convert a reflexion `suggestedPlaybookUpdates` entry into a playbook
+ * anti-pattern, conservatively. Only suggestions phrased as avoid/don't/never
+ * rules become anti-patterns (a generic "improve X" suggestion is not an
+ * anti-pattern and is left for other channels). Returns undefined when the
+ * suggestion is not avoid-shaped, so no spurious anti-patterns are emitted.
+ */
+function reflexionSuggestionToAntiPattern(suggestion) {
+    const trimmed = suggestion.trim();
+    if (!trimmed)
+        return undefined;
+    // Match avoid-shaped guidance anywhere in the suggestion.
+    const isAvoidShaped = /\b(avoid|don'?t|do not|never|stop|refrain from|should not|shouldn'?t)\b/i.test(trimmed);
+    if (!isAvoidShaped)
+        return undefined;
+    // Already prefixed with an avoid verb — keep as-is; otherwise normalize.
+    return /^(avoid|don'?t|do not|never)\b/i.test(trimmed) ? trimmed : `Avoid: ${trimmed}`;
+}
+/**
+ * Deserialize a trajectory from a dream_queue row's JSON. `TrajectorySchema`
+ * uses `z.date()` (no string coercion), so the top-level `timestamp` — turned
+ * into an ISO string by JSON.stringify — is revived to a Date. The dream's
+ * consumers (analyzer, extractors, frontier seeding) read fields/strings, not
+ * nested dates, so a structural cast is sufficient. Returns undefined on a
+ * parse failure so the dream can skip a corrupt row rather than abort.
+ */
+function parseQueuedTrajectory(json) {
+    try {
+        const obj = JSON.parse(json);
+        if (typeof obj.timestamp === 'string') {
+            obj.timestamp = new Date(obj.timestamp);
+        }
+        return obj;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Combine the per-internal-batch results of a dream into one summary. Counts
+ * sum; `experiencesClustered` takes the last (it reflects the final store
+ * size); `successRate` is trajectory-weighted across batches.
+ */
+function aggregateBatchResults(batches) {
+    const agg = {
+        trajectoriesProcessed: 0,
+        playbooksExtracted: 0,
+        experiencesPruned: 0,
+        experiencesCompressed: { promoted: 0, demoted: 0, evicted: 0 },
+        experiencesClustered: 0,
+        knowledgeExtracted: 0,
+        successRate: 0,
+        triggerReasons: ['manual_override'],
+    };
+    let weightedSuccess = 0;
+    for (const b of batches) {
+        agg.trajectoriesProcessed += b.trajectoriesProcessed;
+        agg.playbooksExtracted += b.playbooksExtracted;
+        agg.experiencesPruned += b.experiencesPruned;
+        agg.experiencesCompressed.promoted += b.experiencesCompressed.promoted;
+        agg.experiencesCompressed.demoted += b.experiencesCompressed.demoted;
+        agg.experiencesCompressed.evicted += b.experiencesCompressed.evicted;
+        agg.experiencesClustered = b.experiencesClustered;
+        agg.knowledgeExtracted += b.knowledgeExtracted;
+        weightedSuccess += b.successRate * b.trajectoriesProcessed;
+    }
+    agg.successRate = agg.trajectoriesProcessed > 0 ? weightedSuccess / agg.trajectoriesProcessed : 0;
+    return agg;
+}
 /**
  * Create a UnifiedLearningPipeline.
  */
-export function createUnifiedPipeline(memory, config, persistence) {
-    return new UnifiedLearningPipeline(memory, config, persistence);
+export function createUnifiedPipeline(memory, config, persistence, judge, llm) {
+    return new UnifiedLearningPipeline(memory, config, persistence, judge, llm);
 }
 //# sourceMappingURL=unified-pipeline.js.map