cognitive-core 0.2.5 → 0.3.1

package/dist/learning/unified-pipeline.d.ts

@@ -11,51 +11,116 @@
  *      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 type { Trajectory, LearningConfig } from '../types/index.js';
+import type { Trajectory, LearningConfig, Playbook, ValidationConfig } from '../types/index.js';
 import type { TrajectoryWithAnalysis } from '../types/trajectory-source.js';
 import type { MemorySystem } from '../memory/system.js';
+import type { RoutingDecision } from '../search/router.js';
 import type { SqlitePersistence } from '../persistence/index.js';
 import type { AgenticTaskRunner } from '../workspace/runner.js';
 import { type InstantLoopResult, type InstantLoopConfig } from './instant-loop.js';
+import { type AnalysisResult } from './analyzer.js';
+import type { ReplayJudge } from './replay.js';
+import { type GateReason } from './mutation-gate.js';
+import { type MechanismTraceCollector } from './mechanism-trace.js';
+import type { LLMProvider } from '../agents/types.js';
 import { MetaLearner, type MetaLearnerConfig } from './meta-learner.js';
 import { LearningEffectivenessTracker } from './effectiveness.js';
-import { EnergyEvaluator, type EnergyEvaluatorConfig, type EnergyEvaluation, type EnergySignal, type EscalationReason } from './energy-evaluator.js';
 import { MaintenanceScheduler, type MaintenanceSchedulerConfig, type MaintenanceCycleResult, type MaintenanceTask } from './maintenance-scheduler.js';
-import { HealingOrchestrator, type HealthContext, type HealingCycleResult, type AnomalyDetector, type RepairStrategy } from './healing-orchestrator.js';
-export type { EnergyEvaluation, EnergySignal, EscalationReason, MaintenanceCycleResult, MaintenanceTask, HealingCycleResult, HealthContext, AnomalyDetector, RepairStrategy, };
+/**
+ * Named reasons a batch/dream consolidation was triggered — kept for audit on
+ * batch results (`triggerReasons`).
+ */
+export type EscalationReason = 'count_threshold' | 'contradiction_detected' | 'novel_domain' | 'high_error_rate' | 'pattern_shift' | 'manual_override';
+export type { MaintenanceCycleResult, MaintenanceTask };
 /**
  * Feature flags for optional subsystems.
  */
 export interface UnifiedPipelineFeatures {
     /** Enable temporal compression in batch pipeline (default: true) */
     temporalCompression?: boolean;
-    /** Enable experience clustering via ReasoningBank (default: true) */
-    reasoningBank?: boolean;
     /** Enable reflexion episode generation (default: true) */
     reflexion?: boolean;
-    /** Enable causal edge extraction (default: true) */
-    causalExtraction?: boolean;
     /** Enable knowledge extraction in batch pipeline (default: true) */
     knowledgeExtraction?: boolean;
     /** Enable meta-learning (default: true) */
     metaLearning?: boolean;
     /** Enable effectiveness tracking (default: true) */
     effectivenessTracking?: boolean;
-    /** Enable healing orchestrator with built-in detectors (default: true) */
-    healing?: boolean;
+    /**
+     * Dual-write every processed trajectory to the durable `dream_queue` table
+     * (Phase A of the dreaming refactor). Write-only: nothing drains it yet, so
+     * this does not change learning behavior. Default on. Requires a persistence
+     * handle; a no-op when persistence is absent.
+     */
+    dreamQueue?: boolean;
     /** Enable efficacy maintenance tasks (decay detection, audit, lifecycle review) (default: true) */
     efficacy?: boolean;
+    /**
+     * Enable Pareto-frontier merge proposing in the maintenance loop.
+     * Off by default — requires a ReplayJudge to be passed to the
+     * UnifiedLearningPipeline constructor. When enabled, the maintenance
+     * task scans active task signatures, proposes merges between Pareto
+     * dominator pairs with a common ancestor, and gates each proposal
+     * via MutationGate before committing.
+     */
+    mergeProposing?: boolean;
+    /**
+     * Enable single-parent reflective playbook mutation in the maintenance
+     * loop. Off by default — requires BOTH a ReplayJudge and an LLMProvider
+     * to be passed to the UnifiedLearningPipeline constructor. When enabled,
+     * the maintenance task scans active task signatures, asks the
+     * ReflectiveMutationProposer to revise a Pareto-frontier playbook from
+     * its failure traces, and gates the candidate via MutationGate before
+     * committing. This is the generative counterpart to `mergeProposing`
+     * (which only recombines existing playbooks).
+     */
+    reflectiveMutation?: boolean;
+    /**
+     * Enable write-time curation (PR-D2): near-dup merge, helpful/harmful
+     * counters, prune pass, and helpfulness-weighted injection re-rank.
+     * Mirrors `features.curation` in AtlasConfig. Default true.
+     */
+    curation?: boolean;
+    /**
+     * Roll each dream-time effectiveness annotation into a per-(scope, family,
+     * solver) lift cell in the instance DB (`lift_cells` — scope 'production').
+     * Write-only: no core consumer yet; read by `cogcore eval lift-report`.
+     * Cheap (one upsert per annotated trajectory) and dream-only, never on the
+     * hot path. Default true. Requires persistence; no-op without it.
+     */
+    liftTracking?: boolean;
+    /**
+     * ADDITIVE LEARNING (default OFF). When ON, the dream distill path refines
+     * an existing similar playbook (this-batch OR library) instead of minting a
+     * new `distilled-<uuid>` per trajectory. Mirrors `features.additiveConsolidation`
+     * in AtlasConfig. See `LearningConfig.additiveMergeThreshold` for the merge
+     * similarity floor. OFF preserves the current 1:1 proliferating behavior.
+     */
+    additiveConsolidation?: boolean;
+}
+/**
+ * Dream (consolidation consumer) config for the pipeline. Controls how `dream()`
+ * drains the durable queue.
+ */
+export interface PipelineDreamConfig {
+    /** Max rows claimed per internal batch within a single dream. */
+    maxRowsPerDream: number;
+    /** Max internal batches a single dream drains before stopping. */
+    maxBatchesPerDream: number;
+    /** Row lease TTL while a dream holds claimed rows (ms). */
+    leaseTtlMs: number;
+    /** Attempts before a repeatedly-failing row is parked as `failed`. */
+    maxAttempts: number;
 }
 /**
  * Full configuration for the UnifiedLearningPipeline.
@@ -66,7 +131,6 @@ export interface UnifiedPipelineConfig {
     /** Batch-phase config */
     batch: {
         learning: Partial<LearningConfig>;
-        energy: Partial<EnergyEvaluatorConfig>;
     };
     /** Maintenance-phase config */
     maintenance: Partial<MaintenanceSchedulerConfig>;
@@ -76,8 +140,12 @@ export interface UnifiedPipelineConfig {
     features: UnifiedPipelineFeatures;
     /** Efficacy maintenance config */
     efficacy: EfficacyMaintenanceConfig;
+    /** Dream (consolidation consumer) config */
+    dream: Partial<PipelineDreamConfig>;
     /** Max latency warning threshold for instant loop in ms (default: 200) */
     maxInstantLatencyMs: number;
+    /** Validation-only mutation policy. Disabled validation preserves legacy behavior. */
+    validation?: ValidationConfig;
 }
 /**
  * Configuration for efficacy maintenance tasks.
@@ -96,8 +164,6 @@ export interface EfficacyMaintenanceConfig {
 export interface ImmediateResult {
     /** InstantLoop result */
     instantLoop: InstantLoopResult;
-    /** Energy evaluation (did this trajectory push us toward batch?) */
-    energyEval: EnergyEvaluation;
     /** Whether a batch was triggered by this trajectory */
     batchTriggered: boolean;
     /** Batch result if one was triggered */
@@ -132,6 +198,167 @@ export interface UnifiedBatchResult {
     /** Escalation reasons that triggered this batch */
     triggerReasons: EscalationReason[];
 }
+/**
+ * Phase 0 Tier-0 extraction-quality signal (cheap, no LLM) — the decisive cheap
+ * read for the meta-playbook feedback loop: if meta-guidance helps, emitted
+ * playbooks should be better-conditioned (lower unconditionedRate, higher
+ * trigger/situation coverage). See DESIGN-meta-playbook-feedback-loop.md §3.2.
+ */
+export interface ExtractionTier0 {
+    /** Emitted playbooks per input trajectory. */
+    yieldPerTrajectory: number;
+    /** Fraction of emitted playbooks with NO anti-patterns (lower = better-conditioned). */
+    unconditionedRate: number;
+    /** Fraction with >=1 trigger. */
+    triggerCoverage: number;
+    /** Fraction with >=1 situation. */
+    situationCoverage: number;
+    /** Mean birth confidence. */
+    meanConfidence: number;
+}
+/** Compute the Tier-0 quality signal from a batch of emitted playbooks. Pure. */
+export declare function computeExtractionTier0(playbooks: Playbook[], trajectoryCount: number): ExtractionTier0;
+export interface PlaybookExtractionDiagnostics {
+    event: 'playbook-extraction';
+    batchSize: number;
+    existingPlaybookCount: number;
+    trajectoryIds: string[];
+    taskIds: string[];
+    domains: string[];
+    abstractableCount: number;
+    attemptedMethods: Array<'workspace-agent' | 'trajectory-distiller' | 'heuristic'>;
+    selectedMethod: 'workspace-agent' | 'trajectory-distiller' | 'heuristic';
+    durationMs: number;
+    newCount: number;
+    updateCount: number;
+    newPlaybooks: Array<{
+        id: string;
+        name: string;
+        extractionMethod?: string;
+        confidence: number;
+        triggers: string[];
+        domains: string[];
+    }>;
+    fallbackReason?: string;
+    workspace?: {
+        id?: string;
+        path?: string;
+        complexity?: string;
+        elapsedMs?: number;
+        error?: string;
+        agentState?: string;
+        agentResultPreview?: string;
+        agentMessageCount?: number;
+    };
+    agent?: {
+        trajectoryId?: string;
+        totalTimeMs?: number;
+        tokensUsed?: number;
+        toolCalls?: number;
+    };
+    storage?: {
+        added: number;
+        skippedDedup: number;
+        updatesApplied: number;
+    };
+    /** Phase 0 join key: meta-playbooks injected to guide this extraction (empty when none / not an agentic run). */
+    injectedMetaPlaybookIds?: string[];
+    /** Phase 0 Tier-0 quality signal computed from the emitted playbooks (no LLM). */
+    tier0?: ExtractionTier0;
+}
+export type LearningDiagnosticsCollector = (event: PlaybookExtractionDiagnostics) => void;
+/**
+ * Routing context captured at solve time so the dream can replay the deferred
+ * Phase-2 processing (meta-reflection + effectiveness annotation) offline.
+ * Playbooks are referenced by id and rehydrated from memory at dream time
+ * (keeps the queue row small and the data current).
+ */
+export interface DeferredRoutingSnapshot {
+    routingInfo: {
+        strategy: RoutingDecision['strategy'];
+        confidence: number;
+        estimatedBudget: number;
+        reasoning: string;
+        /**
+         * MetaMemory strategy IDs applied at routing time. The dream's
+         * meta-reflection feeds the task outcome back into each strategy's EMA
+         * (`recordStrategyApplication`) — the routing-prior co-evolution channel.
+         */
+        appliedStrategyIds?: string[];
+    };
+    /** memoryContext.playbooks as (id, score, matchType) — rehydrated at dream time. */
+    playbookMatchRefs: Array<{
+        id: string;
+        score: number;
+        matchType: string;
+    }>;
+    /** Experience ids surfaced by routing (effectiveness annotation). */
+    surfacedExperienceIds: string[];
+    /** Playbook ids inferred as actually applied (effectiveness annotation). */
+    appliedPlaybookIds: string[];
+    /** Knowledge-note ids surfaced by routing (effectiveness annotation). */
+    surfacedKnowledgeNoteIds?: string[];
+}
+/**
+ * Result of a single `dream()` consolidation pass.
+ */
+export interface DreamResult {
+    /** When the dream finished. */
+    dreamedAt: Date;
+    /** Rows claimed from the queue across all internal batches. */
+    rowsClaimed: number;
+    /** Rows successfully consolidated and removed. */
+    rowsCompleted: number;
+    /** Rows returned to pending after a recoverable error. */
+    rowsFailed: number;
+    /** Orphaned rows recovered from a crashed prior dream. */
+    reclaimed: number;
+    /** Aggregate batch result across all internal batches in this dream. */
+    batch: UnifiedBatchResult;
+    /** Maintenance result if a maintenance cycle ran after draining. */
+    maintenance?: MaintenanceCycleResult;
+    /** Wall-clock duration of the dream in ms. */
+    durationMs: number;
+}
+/**
+ * Accumulated activity of one mutation-proposing maintenance task
+ * (reflective-mutation or pareto-merge-proposing) across all maintenance
+ * cycles this pipeline has run. Answers "did the mutation path execute at
+ * all, and why not?" — the observability eval arms need to prove the
+ * GEPA-style optimization loop was actually exercised.
+ */
+export interface MutationTaskStats {
+    /** Maintenance-cycle executions that reached the task (incl. self-gated skips). */
+    runs: number;
+    /** Executions that no-opped at a self-gate (no judge / no provider / feature off / …). */
+    skipped: number;
+    /** Skip reason from the most recent skipped execution. */
+    lastSkipReason?: string;
+    /** Proposals generated and submitted to the MutationGate. */
+    proposalsConsidered: number;
+    /** Proposals the gate accepted and committed. */
+    proposalsAccepted: number;
+    /** Proposals not accepted (gate regressions, policy rejects, or errors). */
+    proposalsRejected: number;
+    /**
+     * Per-`GateReason` decision breakdown across every considered proposal.
+     * Lets reports distinguish genuine `improved` accepts from
+     * `sparse-minibatch` / `empty-minibatch` auto-accepts (and the various
+     * reject reasons) instead of collapsing them into accepted/rejected.
+     */
+    reasonCounts: Partial<Record<GateReason, number>>;
+}
+/**
+ * Mutation/merge activity accumulated across maintenance cycles.
+ */
+export interface MutationActivityStats {
+    /** Total maintenance cycles that actually ran. */
+    maintenanceCyclesRun: number;
+    /** Single-parent reflective mutation task activity. */
+    reflective: MutationTaskStats;
+    /** Two-parent Pareto merge-proposing task activity. */
+    merge: MutationTaskStats;
+}
 /**
  * Pipeline statistics.
  */
@@ -142,16 +369,12 @@ export interface UnifiedPipelineStats {
     batchCyclesRun: number;
     /** Total maintenance cycles run */
     maintenanceCyclesRun: number;
-    /** Current pending count for batch */
-    pendingForBatch: number;
     /** Batches since last maintenance */
     batchesSinceLastMaintenance: number;
     /** Registered maintenance tasks */
     maintenanceTasks: string[];
-    /** Registered anomaly detectors */
-    anomalyDetectors: string[];
-    /** Registered repair strategies */
-    repairStrategies: string[];
+    /** Mutation/merge proposing activity across maintenance cycles. */
+    mutation: MutationActivityStats;
 }
 /**
  * UnifiedLearningPipeline — owns all learning components and orchestrates
@@ -163,24 +386,55 @@ export declare class UnifiedLearningPipeline {
     private instantLoop;
     private analyzer;
     private playbookExtractor;
+    /** PR-D1: LLM-backed distiller; null when no LLM provider is wired. */
+    private distiller;
     private knowledgeExtractor;
     private temporalCompressor;
-    private reasoningBank;
     private metaLearner;
     private effectivenessTracker;
-    private energyEvaluator;
     private maintenanceScheduler;
-    private healingOrchestrator;
     private memory;
+    private persistence;
+    private judge;
+    private llm;
     private taskRunner;
-    private accumulated;
-    private 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.
+     */
+    private warnedHeuristicFallback;
     private totalProcessed;
     private batchCyclesRun;
     private maintenanceCyclesRun;
+    private mutationActivity;
     private _onLatencyWarning;
+    private diagnosticsCollector;
+    /**
+     * 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).
+     */
+    private mechanismTraceCollector;
+    private lastPlaybookExtractionDiagnostics;
     private lastDecayResult;
-    constructor(memory: MemorySystem, config?: Partial<UnifiedPipelineConfig>, persistence?: SqlitePersistence);
+    private dreamConfig;
+    /** In-process guard so two dreams can't run concurrently in one process. */
+    private dreaming;
+    constructor(memory: MemorySystem, config?: Partial<UnifiedPipelineConfig>, persistence?: SqlitePersistence, 
+    /**
+     * Optional replay judge. Required only when `features.mergeProposing`
+     * is enabled — otherwise the merge maintenance task no-ops with a
+     * `skipped` result.
+     */
+    judge?: ReplayJudge, 
+    /**
+     * 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?: LLMProvider);
     /**
      * Load persisted state for internal components.
      * Call after persistence is initialized.
@@ -193,42 +447,153 @@ export declare class UnifiedLearningPipeline {
     /**
      * Set the agentic task runner for workspace-based analysis.
      */
-    setTaskRunner(runner: AgenticTaskRunner): void;
+    setTaskRunner(runner: AgenticTaskRunner | null): void;
+    setDiagnosticsCollector(collector: LearningDiagnosticsCollector | null): void;
+    /**
+     * 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: MechanismTraceCollector | null): void;
     /**
-     * Process a single trajectory through the full pipeline.
+     * Late-bind the LLM provider used by LLM-backed maintenance tasks
+     * (reflective mutation) and, optionally, the ReplayJudge used to gate
+     * mutations and merges.
      *
-     * 1. Runs the instant loop (immediate phase)
-     * 2. Evaluates energy to decide on batch trigger
-     * 3. If batch triggered, runs batch + checks maintenance
+     * 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: LLMProvider, judge?: ReplayJudge): void;
+    /**
+     * 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: ReplayJudge): void;
+    /**
+     * 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: ReplayJudge): void;
+    private validationAllowsStableMutation;
+    private validationCanWrite;
+    private validationAllowsExtraction;
+    private validationAllowsScheduling;
+    private noopInstantLoopResult;
+    /**
+     * Process a single trajectory through the immediate phase and durably enqueue
+     * it for offline consolidation.
+     *
+     * 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.
      */
-    processTrajectory(trajectory: Trajectory, signals?: Partial<EnergySignal>): Promise<ImmediateResult>;
+    processTrajectory(trajectory: 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?: string | null): Promise<ImmediateResult>;
     /**
-     * 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.
      */
-    runBatch(triggerReasons?: EscalationReason[]): Promise<UnifiedBatchResult>;
+    runBatchOver(trajectories: Trajectory[], analyses: AnalysisResult[], triggerReasons?: EscalationReason[]): Promise<UnifiedBatchResult>;
     /**
      * 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.
      */
     runMaintenance(options?: {
         force?: boolean;
     }): Promise<MaintenanceCycleResult>;
     /**
-     * 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: MaintenanceTask): void;
+    private recordMutationActivity;
     /**
-     * Register a custom anomaly detector for the healing orchestrator.
+     * Accumulated mutation/merge proposing activity across all maintenance
+     * cycles this pipeline has run.
+     */
+    getMutationActivity(): MutationActivityStats;
+    /**
+     * 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.
+     */
+    private recordMutationDecision;
+    /**
+     * 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.
+     */
+    dream(opts?: {
+        drainAll?: boolean;
+    }): Promise<DreamResult>;
+    private emptyDreamResult;
+    /**
+     * 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.)
+     */
+    private runDeferredPhase2;
+    /**
+     * 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.
+     */
+    private recordLiftCell;
+    /**
+     * 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.
      */
-    addAnomalyDetector(detector: AnomalyDetector): void;
+    private annotateExternalTrajectory;
     /**
-     * Register a custom repair strategy for the healing orchestrator.
+     * Register a custom maintenance task.
      */
-    addRepairStrategy(strategy: RepairStrategy): void;
+    registerMaintenanceTask(task: MaintenanceTask): void;
     /**
      * Get the meta-learner instance.
      */
@@ -237,24 +602,18 @@ export declare class UnifiedLearningPipeline {
      * Get the effectiveness tracker.
      */
     getEffectivenessTracker(): LearningEffectivenessTracker | null;
-    /**
-     * Get the energy evaluator.
-     */
-    getEnergyEvaluator(): EnergyEvaluator;
     /**
      * Get the maintenance scheduler.
      */
     getMaintenanceScheduler(): MaintenanceScheduler;
     /**
-     * Get the healing orchestrator.
-     */
-    getHealingOrchestrator(): 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(): number;
     /**
-     * Get accumulated trajectories with analyses (read-only).
+     * Get accumulated trajectories with analyses (read-only). Always empty —
+     * learning is decoupled (see {@link getAccumulatedCount}).
      */
     getAccumulated(): TrajectoryWithAnalysis[];
     /**
@@ -273,6 +632,38 @@ export declare class UnifiedLearningPipeline {
      * Register built-in maintenance tasks.
      */
     private registerBuiltInMaintenanceTasks;
+    /**
+     * 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).
+     */
+    private registerCurationPruneTask;
+    /**
+     * 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.
+     */
+    private registerMergeProposingTask;
+    /**
+     * 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.
+     */
+    private registerReflectiveMutationTask;
     /**
      * Register efficacy maintenance tasks (decay detection, audit, lifecycle review).
      * All tasks are log-only — results are returned in details but no automatic mutations.
@@ -284,21 +675,55 @@ export declare class UnifiedLearningPipeline {
     private getEfficacyData;
     /**
      * 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.
      */
     private buildTrajectoryDomainMap;
-    /**
-     * Build health context for the healing orchestrator.
-     */
-    private buildHealthContext;
     /**
      * Analyze a trajectory via workspace template or heuristic fallback.
      */
     private analyzeWithTemplate;
+    /**
+     * 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.
+     */
+    private applyReflexionAntiPatterns;
+    private seedFrontierForNewPlaybook;
     /**
      * Extract playbooks via workspace template or heuristic fallback.
      */
     private extractPlaybooks;
+    private recordPlaybookExtractionDiagnostics;
+    private emitDiagnostics;
+    private stampExtractionProvenance;
+    /**
+     * 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.
+     */
+    private warnHeuristicFallback;
     /**
      * Empty batch result for when there's nothing to process.
      */
@@ -307,5 +732,5 @@ export declare class UnifiedLearningPipeline {
 /**
  * Create a UnifiedLearningPipeline.
  */
-export declare function createUnifiedPipeline(memory: MemorySystem, config?: Partial<UnifiedPipelineConfig>, persistence?: SqlitePersistence): UnifiedLearningPipeline;
+export declare function createUnifiedPipeline(memory: MemorySystem, config?: Partial<UnifiedPipelineConfig>, persistence?: SqlitePersistence, judge?: ReplayJudge, llm?: LLMProvider): UnifiedLearningPipeline;
 //# sourceMappingURL=unified-pipeline.d.ts.map