cognitive-core 0.1.2 → 0.2.1

package/dist/learning/unified-pipeline.js

@@ -0,0 +1,844 @@
+/**
+ * UnifiedLearningPipeline — Three-speed learning orchestrator.
+ *
+ * Consolidates InstantLoop, LearningPipeline (batch), LoopCoordinator,
+ * MetaLearner, EffectivenessTracker, and KnowledgeExtractor into a single
+ * owner that manages the full learning lifecycle.
+ *
+ * Three processing speeds (inspired by ruvector SONA):
+ *
+ *   1. **Immediate** (InstantLoop, <200ms): Fires on every trajectory.
+ *      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
+ *      compression, and experience clustering.
+ *
+ *   3. **Maintenance** (circadian-gated): Runs periodically or after N batches.
+ *      Knowledge defrag, healing orchestrator, meta-strategy generation,
+ *      effectiveness reporting.
+ *
+ * The pipeline owns all components and coordinates them. Atlas delegates
+ * learning to this pipeline rather than managing components directly.
+ */
+// Immediate-phase components
+import { InstantLoop } from './instant-loop.js';
+// Batch-phase components
+import { createAnalyzer, } from './analyzer.js';
+import { createPlaybookExtractor, } from './playbook-extractor.js';
+import { KnowledgeExtractor } from './knowledge-extractor.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 { 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_EFFICACY_CONFIG = {
+    lifecycleReviewFrequency: 3,
+    minPlaybooks: 1,
+    minAnnotations: 3,
+};
+const DEFAULT_UNIFIED_CONFIG = {
+    instant: {},
+    batch: {
+        learning: {},
+        energy: {},
+    },
+    maintenance: {},
+    metaLearner: {},
+    features: {},
+    efficacy: DEFAULT_EFFICACY_CONFIG,
+    maxInstantLatencyMs: 200,
+};
+// =========================================================================
+// Unified Pipeline
+// =========================================================================
+/**
+ * UnifiedLearningPipeline — owns all learning components and orchestrates
+ * the three-speed processing loop.
+ */
+export class UnifiedLearningPipeline {
+    // Configuration
+    config;
+    learningConfig;
+    // Immediate-phase components
+    instantLoop;
+    // Batch-phase components
+    analyzer;
+    playbookExtractor;
+    knowledgeExtractor;
+    temporalCompressor;
+    reasoningBank;
+    // Meta-learning and effectiveness
+    metaLearner = null;
+    effectivenessTracker = null;
+    // Orchestration
+    energyEvaluator;
+    maintenanceScheduler;
+    healingOrchestrator;
+    // State
+    memory;
+    taskRunner = null;
+    accumulated = [];
+    accumulatedAnalyses = [];
+    totalProcessed = 0;
+    batchCyclesRun = 0;
+    maintenanceCyclesRun = 0;
+    _onLatencyWarning = null;
+    lastDecayResult = null;
+    constructor(memory, config, persistence) {
+        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 },
+        };
+        this.memory = memory;
+        // Resolve learning config with defaults
+        const lc = this.config.batch.learning;
+        this.learningConfig = {
+            creditStrategy: lc.creditStrategy ?? 'simple',
+            patternExtractor: lc.patternExtractor ?? 'llm',
+            minTrajectories: lc.minTrajectories ?? 10,
+            minHoursSinceLast: lc.minHoursSinceLast,
+            minSuccessRate: lc.minSuccessRate,
+            deduplicationThreshold: lc.deduplicationThreshold ?? 0.9,
+            maxExperiences: lc.maxExperiences ?? 1000,
+        };
+        // Immediate phase
+        this.instantLoop = new InstantLoop(memory, {
+            ...this.config.instant,
+            enableReflexion: this.config.features.reflexion ?? true,
+            enableCausalExtraction: this.config.features.causalExtraction ?? true,
+        });
+        // Batch phase
+        this.analyzer = createAnalyzer(this.learningConfig.creditStrategy);
+        this.playbookExtractor = createPlaybookExtractor({
+            minTrajectories: this.learningConfig.minTrajectories,
+            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;
+        // 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();
+    }
+    /**
+     * Load persisted state for internal components.
+     * Call after persistence is initialized.
+     */
+    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');
+            this.metaLearner = createML(this.memory.meta, this.config.metaLearner);
+        }
+        // Initialize effectiveness tracker if enabled
+        if (this.config.features.effectivenessTracking ?? true) {
+            // Effectiveness tracker is available through memory system
+            this.effectivenessTracker = this.memory.effectiveness;
+            await this.effectivenessTracker.init();
+        }
+    }
+    /**
+     * Set the agentic task runner for workspace-based analysis.
+     */
+    setTaskRunner(runner) {
+        this.taskRunner = runner;
+    }
+    // =========================================================================
+    // IMMEDIATE PHASE
+    // =========================================================================
+    /**
+     * Process a single trajectory through the full pipeline.
+     *
+     * 1. Runs the instant loop (immediate phase)
+     * 2. Evaluates energy to decide on batch trigger
+     * 3. If batch triggered, runs batch + checks maintenance
+     *
+     * This is the primary entry point for trajectory processing.
+     */
+    async processTrajectory(trajectory, signals) {
+        // 1. Immediate phase — InstantLoop
+        const instantResult = await this.instantLoop.process(trajectory);
+        this.totalProcessed++;
+        // Warn if instant loop exceeded latency budget
+        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);
+        }
+        this.accumulated.push(trajectory);
+        this.accumulatedAnalyses.push(analysis);
+        // 3. Energy evaluation
+        const energyEval = this.energyEvaluator.evaluate(trajectory, instantResult, signals);
+        const result = {
+            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.
+     */
+    async runBatch(triggerReasons) {
+        if (this.accumulated.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);
+                        await this.memory.playbooks.add(playbook);
+                    }
+                }
+                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);
+                    }
+                }
+            }
+            // Knowledge extraction (batch-level, richer than instant-loop)
+            let knowledgeExtracted = 0;
+            if (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 (const obs of extracted.observations) {
+                        try {
+                            await this.memory.knowledgeBank.addObservation(obs);
+                            knowledgeExtracted++;
+                        }
+                        catch {
+                            // Non-critical
+                        }
+                    }
+                }
+            }
+            // Temporal compression
+            let compressionEvicted = 0;
+            let compressionPromoted = 0;
+            let compressionDemoted = 0;
+            if (this.temporalCompressor) {
+                const allExperiences = await this.memory.experiences.getAll();
+                const compressionResult = await this.temporalCompressor.compress(allExperiences);
+                for (const [id, updates] of compressionResult.updates) {
+                    await this.memory.experiences.update(id, updates);
+                }
+                for (const id of compressionResult.evicted) {
+                    await this.memory.experiences.delete(id);
+                }
+                compressionEvicted = compressionResult.evicted.length;
+                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,
+            });
+            // Calculate success rate
+            const successCount = this.accumulatedAnalyses.filter(a => a.success).length;
+            const successRate = successCount / this.accumulated.length;
+            // Meta-learning: generate strategies periodically
+            if (this.metaLearner) {
+                try {
+                    await this.metaLearner.learn();
+                }
+                catch {
+                    // Non-critical
+                }
+            }
+            const trajectoriesProcessed = this.accumulated.length;
+            // Clear accumulated and reset energy evaluator
+            this.accumulated = [];
+            this.accumulatedAnalyses = [];
+            this.energyEvaluator.resetAfterBatch();
+            this.batchCyclesRun++;
+            return {
+                trajectoriesProcessed,
+                playbooksExtracted: playbooksAdded,
+                experiencesPruned: pruned.totalPruned + compressionEvicted,
+                experiencesCompressed: {
+                    promoted: compressionPromoted,
+                    demoted: compressionDemoted,
+                    evicted: compressionEvicted,
+                },
+                experiencesClustered: currentExperiences.length,
+                knowledgeExtracted,
+                successRate,
+                triggerReasons: triggerReasons ?? ['manual_override'],
+            };
+        }
+        finally {
+            this.maintenanceScheduler.onBatchEnd();
+        }
+    }
+    // =========================================================================
+    // MAINTENANCE PHASE
+    // =========================================================================
+    /**
+     * Run a maintenance cycle.
+     * Executes registered maintenance tasks (defrag, healing, etc.).
+     * Can be called manually regardless of mode.
+     */
+    async runMaintenance(options) {
+        const result = await this.maintenanceScheduler.runMaintenance(options);
+        if (result.ran) {
+            this.maintenanceCyclesRun++;
+        }
+        return result;
+    }
+    /**
+     * Register a custom maintenance task.
+     */
+    registerMaintenanceTask(task) {
+        this.maintenanceScheduler.registerTask(task);
+    }
+    /**
+     * Register a custom anomaly detector for the healing orchestrator.
+     */
+    addAnomalyDetector(detector) {
+        this.healingOrchestrator.addDetector(detector);
+    }
+    /**
+     * Register a custom repair strategy for the healing orchestrator.
+     */
+    addRepairStrategy(strategy) {
+        this.healingOrchestrator.addRepairStrategy(strategy);
+    }
+    // =========================================================================
+    // ACCESSORS
+    // =========================================================================
+    /**
+     * Get the meta-learner instance.
+     */
+    getMetaLearner() {
+        return this.metaLearner;
+    }
+    /**
+     * Get the effectiveness tracker.
+     */
+    getEffectivenessTracker() {
+        return this.effectivenessTracker;
+    }
+    /**
+     * Get the energy evaluator.
+     */
+    getEnergyEvaluator() {
+        return this.energyEvaluator;
+    }
+    /**
+     * Get the maintenance scheduler.
+     */
+    getMaintenanceScheduler() {
+        return this.maintenanceScheduler;
+    }
+    /**
+     * Get the healing orchestrator.
+     */
+    getHealingOrchestrator() {
+        return this.healingOrchestrator;
+    }
+    /**
+     * Get accumulated trajectory count.
+     */
+    getAccumulatedCount() {
+        return this.accumulated.length;
+    }
+    /**
+     * Get accumulated trajectories with analyses (read-only).
+     */
+    getAccumulated() {
+        return this.accumulated.map((trajectory, i) => ({
+            trajectory,
+            analysis: this.accumulatedAnalyses[i],
+        }));
+    }
+    /**
+     * Get pipeline statistics.
+     */
+    getStats() {
+        return {
+            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),
+        };
+    }
+    /**
+     * Register a callback for instant-loop latency warnings.
+     */
+    onLatencyWarning(callback) {
+        this._onLatencyWarning = callback;
+    }
+    /**
+     * Update batch learning configuration.
+     */
+    updateConfig(config) {
+        this.learningConfig = { ...this.learningConfig, ...config };
+        if (config.creditStrategy) {
+            this.analyzer.setStrategy(config.creditStrategy);
+        }
+    }
+    // =========================================================================
+    // PRIVATE
+    // =========================================================================
+    /**
+     * 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({
+                name: 'knowledge-defrag',
+                priority: 80,
+                execute: async () => {
+                    const start = Date.now();
+                    const kb = this.memory.knowledgeBank;
+                    const shouldDefrag = await kb.shouldDefragment();
+                    if (!shouldDefrag) {
+                        return {
+                            taskName: 'knowledge-defrag',
+                            success: true,
+                            durationMs: Date.now() - start,
+                            details: { skipped: true, reason: 'not needed' },
+                        };
+                    }
+                    const result = await kb.defragment();
+                    return {
+                        taskName: 'knowledge-defrag',
+                        success: true,
+                        durationMs: Date.now() - start,
+                        details: result,
+                    };
+                },
+            });
+        }
+        // Meta-strategy generation
+        if (this.config.features.metaLearning ?? true) {
+            this.maintenanceScheduler.registerTask({
+                name: 'meta-strategy-generation',
+                priority: 60,
+                execute: async () => {
+                    const start = Date.now();
+                    if (!this.metaLearner) {
+                        return {
+                            taskName: 'meta-strategy-generation',
+                            success: true,
+                            durationMs: Date.now() - start,
+                            details: { skipped: true, reason: 'meta-learner not initialized' },
+                        };
+                    }
+                    const strategies = await this.metaLearner.learn();
+                    return {
+                        taskName: 'meta-strategy-generation',
+                        success: true,
+                        durationMs: Date.now() - start,
+                        details: { strategiesGenerated: strategies.length },
+                    };
+                },
+            });
+        }
+        // Efficacy maintenance tasks
+        this.registerEfficacyMaintenanceTasks();
+    }
+    /**
+     * Register efficacy maintenance tasks (decay detection, audit, lifecycle review).
+     * All tasks are log-only — results are returned in details but no automatic mutations.
+     */
+    registerEfficacyMaintenanceTasks() {
+        if (!(this.config.features.efficacy ?? true))
+            return;
+        const efficacyCfg = this.config.efficacy;
+        // 1. Playbook Decay Detection (priority 70) — runs every maintenance cycle
+        this.maintenanceScheduler.registerTask({
+            name: 'playbook-decay-detection',
+            priority: 70,
+            execute: async () => {
+                const start = Date.now();
+                this.lastDecayResult = null;
+                const { annotations, playbooks, playbookEffectiveness, unguidedSuccessRate } = await this.getEfficacyData();
+                if (playbooks.length < efficacyCfg.minPlaybooks || annotations.length < efficacyCfg.minAnnotations) {
+                    return {
+                        taskName: 'playbook-decay-detection',
+                        success: true,
+                        durationMs: Date.now() - start,
+                        details: { skipped: true, reason: 'insufficient data' },
+                    };
+                }
+                const result = await playbookDecayDetectionTemplate.heuristicFallback({
+                    playbooks,
+                    annotations,
+                    playbookEffectiveness,
+                    unguidedSuccessRate,
+                });
+                this.lastDecayResult = result;
+                return {
+                    taskName: 'playbook-decay-detection',
+                    success: true,
+                    durationMs: Date.now() - start,
+                    details: {
+                        decayingCount: result.decaying.length,
+                        atRiskCount: result.atRisk.length,
+                        healthyCount: result.healthy.length,
+                        decaying: result.decaying,
+                        atRisk: result.atRisk,
+                        portfolioAssessment: result.portfolioAssessment,
+                    },
+                };
+            },
+        });
+        // 2. Playbook Efficacy Audit (priority 65) — audits flagged playbooks from decay detection
+        this.maintenanceScheduler.registerTask({
+            name: 'playbook-efficacy-audit',
+            priority: 65,
+            execute: async () => {
+                const start = Date.now();
+                if (!this.lastDecayResult) {
+                    return {
+                        taskName: 'playbook-efficacy-audit',
+                        success: true,
+                        durationMs: Date.now() - start,
+                        details: { skipped: true, reason: 'no decay detection results' },
+                    };
+                }
+                const flagged = [
+                    ...this.lastDecayResult.decaying,
+                    ...this.lastDecayResult.atRisk,
+                ];
+                if (flagged.length === 0) {
+                    return {
+                        taskName: 'playbook-efficacy-audit',
+                        success: true,
+                        durationMs: Date.now() - start,
+                        details: { skipped: true, reason: 'no flagged playbooks' },
+                    };
+                }
+                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 trajectoryDomainMap = this.buildTrajectoryDomainMap(annotations);
+                const audits = [];
+                for (const signal of flagged) {
+                    const playbook = playbookMap.get(signal.playbookId);
+                    if (!playbook)
+                        continue;
+                    const auditResult = await playbookEfficacyAuditTemplate.heuristicFallback({
+                        playbook,
+                        annotations,
+                        playbookEffectiveness: effectivenessMap.get(signal.playbookId),
+                        unguidedSuccessRate,
+                        trajectoryDomainMap,
+                    });
+                    audits.push({
+                        playbookId: signal.playbookId,
+                        health: auditResult.assessment.health,
+                        recommendations: auditResult.assessment.recommendations,
+                        summary: auditResult.assessment.summary,
+                    });
+                }
+                return {
+                    taskName: 'playbook-efficacy-audit',
+                    success: true,
+                    durationMs: Date.now() - start,
+                    details: {
+                        auditsPerformed: audits.length,
+                        audits,
+                    },
+                };
+            },
+        });
+        // 3. Playbook Lifecycle Review (priority 50) — runs every Nth maintenance cycle
+        this.maintenanceScheduler.registerTask({
+            name: 'playbook-lifecycle-review',
+            priority: 50,
+            execute: async () => {
+                const start = Date.now();
+                // Only run every Nth maintenance cycle
+                if (this.maintenanceCyclesRun % efficacyCfg.lifecycleReviewFrequency !== 0) {
+                    return {
+                        taskName: 'playbook-lifecycle-review',
+                        success: true,
+                        durationMs: Date.now() - start,
+                        details: {
+                            skipped: true,
+                            reason: `runs every ${efficacyCfg.lifecycleReviewFrequency} maintenance cycles`,
+                        },
+                    };
+                }
+                const { annotations, playbooks, playbookEffectiveness, unguidedSuccessRate } = await this.getEfficacyData();
+                if (playbooks.length < efficacyCfg.minPlaybooks || annotations.length < efficacyCfg.minAnnotations) {
+                    return {
+                        taskName: 'playbook-lifecycle-review',
+                        success: true,
+                        durationMs: Date.now() - start,
+                        details: { skipped: true, reason: 'insufficient data' },
+                    };
+                }
+                const trajectoryDomainMap = this.buildTrajectoryDomainMap(annotations);
+                const result = await playbookLifecycleReviewTemplate.heuristicFallback({
+                    playbooks,
+                    annotations,
+                    playbookEffectiveness,
+                    unguidedSuccessRate,
+                    trajectoryDomainMap,
+                });
+                return {
+                    taskName: 'playbook-lifecycle-review',
+                    success: true,
+                    durationMs: Date.now() - start,
+                    details: {
+                        totalPlaybooks: result.snapshot.totalPlaybooks,
+                        recommendationsCount: result.recommendations.length,
+                        recommendations: result.recommendations,
+                        insights: result.insights,
+                        actionPlan: result.actionPlan,
+                        snapshot: {
+                            avgConfidence: result.snapshot.avgConfidence,
+                            avgSuccessRate: result.snapshot.avgSuccessRate,
+                            confidenceBands: result.snapshot.confidenceBands,
+                            decayingCount: result.snapshot.decaying.length,
+                            staleCount: result.snapshot.stale.length,
+                        },
+                    },
+                };
+            },
+        });
+    }
+    /**
+     * Fetch shared efficacy data used by all three efficacy maintenance tasks.
+     */
+    async getEfficacyData() {
+        const playbooks = await this.memory.playbooks.getAll();
+        let annotations = [];
+        let playbookEffectiveness = [];
+        let unguidedSuccessRate = 0;
+        if (this.effectivenessTracker) {
+            annotations = await this.effectivenessTracker.getAll();
+            const metrics = await this.effectivenessTracker.computeMetrics();
+            playbookEffectiveness = metrics.playbookEffectiveness;
+            unguidedSuccessRate = metrics.unguidedSuccessRate;
+        }
+        return { annotations, playbooks, playbookEffectiveness, unguidedSuccessRate };
+    }
+    /**
+     * Build a trajectoryId→domain map from annotations.
+     * Uses accumulated trajectories when available, otherwise infers from task annotations.
+     */
+    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: {},
+        };
+    }
+    /**
+     * Analyze a trajectory via workspace template or heuristic fallback.
+     */
+    async analyzeWithTemplate(trajectory) {
+        try {
+            const result = await this.taskRunner.run(trajectoryAnalysisTemplate, {
+                trajectory,
+                creditStrategy: this.learningConfig.creditStrategy,
+            });
+            return result.output;
+        }
+        catch {
+            return this.analyzer.analyze(trajectory);
+        }
+    }
+    /**
+     * Extract playbooks via workspace template or heuristic fallback.
+     */
+    async extractPlaybooks(existingPlaybooks) {
+        if (this.taskRunner) {
+            try {
+                const result = await this.taskRunner.run(playbookExtractionTemplate, {
+                    trajectories: this.accumulated,
+                    analyses: this.accumulatedAnalyses,
+                    existingPlaybooks,
+                });
+                return result.output;
+            }
+            catch {
+                // Fall through to heuristic
+            }
+        }
+        return this.playbookExtractor.extract(this.accumulated, this.accumulatedAnalyses, existingPlaybooks);
+    }
+    /**
+     * Empty batch result for when there's nothing to process.
+     */
+    emptyBatchResult(triggerReasons) {
+        return {
+            trajectoriesProcessed: 0,
+            playbooksExtracted: 0,
+            experiencesPruned: 0,
+            experiencesCompressed: { promoted: 0, demoted: 0, evicted: 0 },
+            experiencesClustered: 0,
+            knowledgeExtracted: 0,
+            successRate: 0,
+            triggerReasons,
+        };
+    }
+}
+/**
+ * Create a UnifiedLearningPipeline.
+ */
+export function createUnifiedPipeline(memory, config, persistence) {
+    return new UnifiedLearningPipeline(memory, config, persistence);
+}
+//# sourceMappingURL=unified-pipeline.js.map