@timmeck/brain-core 2.25.1 → 2.27.0

package/dist/research/research-orchestrator.js

@@ -39,6 +39,13 @@ export class ResearchOrchestrator {
     curiosityEngine = null;
     emergenceEngine = null;
     debateEngine = null;
+    parameterRegistry = null;
+    metaCognitionLayer = null;
+    autoExperimentEngine = null;
+    selfTestEngine = null;
+    teachEngine = null;
+    dataScout = null;
+    simulationEngine = null;
     brainName;
     feedbackTimer = null;
     cycleCount = 0;
@@ -50,6 +57,8 @@ export class ResearchOrchestrator {
     suggestionHistory = new Map();
     /** Max repeats before trying an alternative. */
     stalledThreshold = 3;
+    /** Hash of last written suggestions to prevent duplicate file writes. */
+    lastSuggestionsHash = '';
     constructor(db, config, causalGraph) {
         this.brainName = config.brainName;
         this.distillEvery = config.distillEvery ?? 5;
@@ -121,6 +130,26 @@ export class ResearchOrchestrator {
     setDebateEngine(engine) {
         this.debateEngine = engine;
     }
+    /** Set the ParameterRegistry — central tunable parameter store. */
+    setParameterRegistry(registry) {
+        this.parameterRegistry = registry;
+    }
+    /** Set the MetaCognitionLayer — engine evaluation and frequency adjustment. */
+    setMetaCognitionLayer(layer) {
+        this.metaCognitionLayer = layer;
+    }
+    /** Set the AutoExperimentEngine — autonomous parameter tuning. */
+    setAutoExperimentEngine(engine) {
+        this.autoExperimentEngine = engine;
+    }
+    /** Set the SelfTestEngine — tests understanding depth of principles. */
+    setSelfTestEngine(engine) { this.selfTestEngine = engine; }
+    /** Set the TeachEngine — generates onboarding packages for new brains. */
+    setTeachEngine(engine) { this.teachEngine = engine; }
+    /** Set the DataScout — actively scouts external data sources. */
+    setDataScout(scout) { this.dataScout = scout; }
+    /** Set the SimulationEngine — runs what-if scenarios. */
+    setSimulationEngine(engine) { this.simulationEngine = engine; }
     /** Set the PredictionEngine — wires journal into it. */
     setPredictionEngine(engine) {
         this.predictionEngine = engine;
@@ -466,14 +495,39 @@ export class ResearchOrchestrator {
             this.predictionEngine.recordMetric('auto_response_count', responderStatus.total_responses, 'metric');
             ts?.emit('orchestrator', 'perceiving', `Self-metrics recorded: ${anomalies.length} anomalies, ${insights.length} insights, ${cycleDuration}ms`);
         }
-        // 12. Auto-Experiments: propose experiments on own parameters when none exist
-        if (this.cycleCount > 3) {
+        // 12. Auto-Experiments: use AutoExperimentEngine if available, otherwise hardcoded fallback
+        if (this.autoExperimentEngine && this.cycleCount > 3 && this.cycleCount % 5 === 0) {
+            ts?.emit('auto_experiment', 'experimenting', 'Processing auto-experiments...');
+            try {
+                // Feed measurements
+                this.autoExperimentEngine.feedMeasurement('insight_count', insights.length);
+                this.autoExperimentEngine.feedMeasurement('anomaly_count', anomalies.length);
+                // Process completed
+                const completed = this.autoExperimentEngine.processCompleted(this.cycleCount);
+                for (const c of completed) {
+                    ts?.emit('auto_experiment', 'discovering', `Auto-experiment #${c.autoExpId}: ${c.action}`, c.action === 'adopted' ? 'notable' : 'routine');
+                }
+                // Propose new
+                const candidates = this.autoExperimentEngine.discoverCandidates(this.cycleCount);
+                if (candidates.length > 0) {
+                    const best = candidates[0];
+                    const started = this.autoExperimentEngine.startExperiment(best);
+                    if (started) {
+                        ts?.emit('auto_experiment', 'experimenting', `Started: ${best.engine}.${best.name} ${best.currentValue.toFixed(3)} → ${best.proposedValue.toFixed(3)}`, 'notable');
+                    }
+                }
+            }
+            catch (err) {
+                this.log.error(`[orchestrator] AutoExperiment error: ${err.message}`);
+            }
+        }
+        else if (this.cycleCount > 3) {
+            // Fallback: hardcoded experiments when no AutoExperimentEngine
             const running = this.experimentEngine.list('running_control', 5).length
                 + this.experimentEngine.list('running_treatment', 5).length;
             if (running === 0 && this.cycleCount % 5 === 0) {
                 this.proposeAutoExperiment(ts);
             }
-            // Feed measurements into running experiments
             this.feedExperimentMeasurements(anomalies.length, insights.length);
         }
         // 13. Periodic Dream Consolidation: don't wait for idle, consolidate every 20 cycles
@@ -742,9 +796,282 @@ export class ResearchOrchestrator {
                 this.log.error(`[orchestrator] Debate step error: ${err.message}`);
             }
         }
+        // 21. MetaCognition: evaluate engine performance and adjust frequencies
+        if (this.metaCognitionLayer && this.cycleCount % this.reflectEvery === 0) {
+            ts?.emit('metacognition', 'analyzing', 'Evaluating engine performance...');
+            try {
+                const cards = this.metaCognitionLayer.evaluate();
+                if (cards.length > 0) {
+                    const topGrade = cards.sort((a, b) => b.combined_score - a.combined_score)[0];
+                    const worstGrade = cards.sort((a, b) => a.combined_score - b.combined_score)[0];
+                    ts?.emit('metacognition', 'discovering', `${cards.length} engines evaluated. Best: ${topGrade.engine} (${topGrade.grade}), Worst: ${worstGrade.engine} (${worstGrade.grade})`, cards.some(c => c.grade === 'F') ? 'notable' : 'routine');
+                    const adjustments = this.metaCognitionLayer.adjustFrequencies(cards);
+                    if (adjustments.length > 0) {
+                        ts?.emit('metacognition', 'discovering', `Frequency adjusted: ${adjustments.map(a => `${a.engine} ${a.old_frequency}→${a.new_frequency}`).join(', ')}`, 'notable');
+                    }
+                }
+            }
+            catch (err) {
+                this.log.error(`[orchestrator] MetaCognition error: ${err.message}`);
+            }
+        }
+        // 22. Parameter Registry: refresh orchestrator params from registry
+        if (this.parameterRegistry) {
+            const distill = this.parameterRegistry.get('orchestrator', 'distillEvery');
+            if (distill !== undefined && distill !== this.distillEvery) {
+                this.log.info(`[orchestrator] distillEvery refreshed: ${this.distillEvery} → ${distill}`);
+                this.distillEvery = distill;
+            }
+            const agenda = this.parameterRegistry.get('orchestrator', 'agendaEvery');
+            if (agenda !== undefined && agenda !== this.agendaEvery) {
+                this.log.info(`[orchestrator] agendaEvery refreshed: ${this.agendaEvery} → ${agenda}`);
+                this.agendaEvery = agenda;
+            }
+            const reflect = this.parameterRegistry.get('orchestrator', 'reflectEvery');
+            if (reflect !== undefined && reflect !== this.reflectEvery) {
+                this.log.info(`[orchestrator] reflectEvery refreshed: ${this.reflectEvery} → ${reflect}`);
+                this.reflectEvery = reflect;
+            }
+        }
+        // Step 23: Blind Spot Detection (every 5 cycles)
+        if (this.curiosityEngine && this.cycleCount % 5 === 0) {
+            try {
+                ts?.emit('orchestrator', 'analyzing', 'Step 23: Detecting blind spots...', 'routine');
+                const blindSpots = this.curiosityEngine.detectBlindSpots();
+                for (const bs of blindSpots) {
+                    this.journal.write({
+                        type: 'discovery',
+                        title: `Blind spot: "${bs.topic}" (severity=${(bs.severity * 100).toFixed(0)}%)`,
+                        content: `Knowledge blind spot detected. Hypotheses: ${bs.hypothesisCount}, Predictions: ${bs.predictionCount}, Journal: ${bs.journalCount}, Experiments: ${bs.experimentCount}`,
+                        tags: ['blind-spot', bs.topic],
+                        references: [],
+                        significance: bs.severity > 0.85 ? 'notable' : 'routine',
+                        data: { blindSpot: bs },
+                    });
+                    this.researchAgenda.ask(`Investigate blind spot: ${bs.topic} — severity ${(bs.severity * 100).toFixed(0)}%, needs more research`, 'knowledge_gap');
+                }
+                if (this.metaCognitionLayer)
+                    this.metaCognitionLayer.recordStep('blind_spot_detector', this.cycleCount, { insights: blindSpots.length });
+            }
+            catch (err) {
+                this.log.warn(`[orchestrator] Step 23 error: ${err.message}`);
+            }
+        }
+        // Step 24: Creative Hypotheses (every 10 cycles)
+        if (this.cycleCount % 10 === 0) {
+            try {
+                ts?.emit('orchestrator', 'hypothesizing', 'Step 24: Generating creative hypotheses...', 'routine');
+                const creative = this.hypothesisEngine.generateCreative(3);
+                for (const h of creative) {
+                    this.journal.write({
+                        type: 'insight',
+                        title: `Creative hypothesis: ${h.statement.substring(0, 80)}`,
+                        content: `Source: ${h.source}, Type: ${h.type}`,
+                        tags: ['creative-hypothesis', h.source],
+                        references: [],
+                        significance: 'routine',
+                        data: { hypothesis: h },
+                    });
+                }
+                if (this.metaCognitionLayer)
+                    this.metaCognitionLayer.recordStep('creative_hypotheses', this.cycleCount, { insights: creative.length });
+            }
+            catch (err) {
+                this.log.warn(`[orchestrator] Step 24 error: ${err.message}`);
+            }
+        }
+        // Step 25: Advocatus Diaboli — challenge a random confirmed principle (every 10 cycles)
+        if (this.debateEngine && this.cycleCount % 10 === 0) {
+            try {
+                ts?.emit('orchestrator', 'reflecting', 'Step 25: Challenging a principle...', 'routine');
+                const principles = this.knowledgeDistiller.getPrinciples(undefined, 20);
+                if (principles.length > 0) {
+                    const randomPrinciple = principles[Math.floor(Math.random() * principles.length)];
+                    const challenge = this.debateEngine.challenge(randomPrinciple.statement);
+                    this.journal.write({
+                        type: 'reflection',
+                        title: `Principle challenged: resilience=${(challenge.resilienceScore * 100).toFixed(0)}% → ${challenge.outcome}`,
+                        content: `"${challenge.principleStatement.substring(0, 100)}" — Supporting: ${challenge.supportingEvidence.length}, Contradicting: ${challenge.contradictingEvidence.length}`,
+                        tags: ['challenge', challenge.outcome],
+                        references: [],
+                        significance: challenge.outcome === 'disproved' ? 'notable' : 'routine',
+                        data: { challenge },
+                    });
+                }
+                if (this.metaCognitionLayer)
+                    this.metaCognitionLayer.recordStep('advocatus_diaboli', this.cycleCount, { insights: 1 });
+            }
+            catch (err) {
+                this.log.warn(`[orchestrator] Step 25 error: ${err.message}`);
+            }
+        }
+        // Step 26: Dream Retrospective — analyze pruning regret (every 20 cycles)
+        if (this.dreamEngine && this.cycleCount % 20 === 0) {
+            try {
+                ts?.emit('orchestrator', 'reflecting', 'Step 26: Analyzing dream retrospective...', 'routine');
+                const retrospectives = this.dreamEngine.analyzeRetrospective(5);
+                for (const r of retrospectives) {
+                    if (r.regretScore > 0.3) {
+                        this.journal.write({
+                            type: 'reflection',
+                            title: `Dream regret: ${(r.regretScore * 100).toFixed(0)}% of pruned items reappeared`,
+                            content: r.lesson,
+                            tags: ['dream', 'retrospective'],
+                            references: [],
+                            significance: r.regretScore > 0.5 ? 'notable' : 'routine',
+                            data: { retrospective: r },
+                        });
+                    }
+                }
+                if (this.metaCognitionLayer)
+                    this.metaCognitionLayer.recordStep('dream_retrospective', this.cycleCount, { insights: retrospectives.length });
+            }
+            catch (err) {
+                this.log.warn(`[orchestrator] Step 26 error: ${err.message}`);
+            }
+        }
+        // Step 27: Cross-Brain Dialogue — formulate and answer questions across domains (every 10 cycles)
+        if (this.transferEngine && this.cycleCount % 10 === 0) {
+            try {
+                ts?.emit('orchestrator', 'correlating', 'Step 27: Cross-brain dialogue...', 'routine');
+                let topic = 'general knowledge';
+                if (this.attentionEngine) {
+                    const topTopics = this.attentionEngine.getTopTopics(5);
+                    if (topTopics.length > 0)
+                        topic = topTopics[0].topic;
+                }
+                const question = this.transferEngine.formulateQuestion(topic);
+                const answer = this.transferEngine.answerQuestion(question);
+                this.transferEngine.recordDialogue(this.brainName, 'self', question, answer, `cycle:${this.cycleCount}`);
+                if (this.metaCognitionLayer)
+                    this.metaCognitionLayer.recordStep('cross_brain_dialogue', this.cycleCount, { insights: 1 });
+            }
+            catch (err) {
+                this.log.warn(`[orchestrator] Step 27 error: ${err.message}`);
+            }
+        }
+        // Step 28: Self-Test — test understanding depth of principles (every 10 cycles)
+        if (this.selfTestEngine && this.cycleCount % 10 === 0) {
+            try {
+                ts?.emit('orchestrator', 'analyzing', 'Step 28: Self-testing principles...', 'routine');
+                const results = this.selfTestEngine.testAll();
+                const shallow = results.filter(r => r.understandingDepth < 0.3);
+                for (const s of shallow) {
+                    this.researchAgenda.ask(`Deepen understanding: "${s.principleStatement.substring(0, 60)}" — shallow depth (${(s.understandingDepth * 100).toFixed(0)}%), need more predictions/experiments`, 'knowledge_gap');
+                }
+                if (this.metaCognitionLayer)
+                    this.metaCognitionLayer.recordStep('self_test', this.cycleCount, { insights: results.length, journal_entries: shallow.length });
+            }
+            catch (err) {
+                this.log.warn(`[orchestrator] Step 28 error: ${err.message}`);
+            }
+        }
+        // Step 29: DataScout — scout external data sources (every 20 cycles)
+        if (this.dataScout && this.cycleCount % 20 === 0) {
+            try {
+                ts?.emit('orchestrator', 'exploring', 'Step 29: Scouting external data...', 'routine');
+                const discoveries = await this.dataScout.scout();
+                for (const d of discoveries.slice(0, 3)) {
+                    this.journal.write({
+                        type: 'discovery',
+                        title: `Scout: ${d.title}`,
+                        content: `Source: ${d.source}, Relevance: ${(d.relevanceScore * 100).toFixed(0)}%. ${d.description.substring(0, 200)}`,
+                        tags: ['scout', d.source],
+                        references: [],
+                        significance: d.relevanceScore > 0.7 ? 'notable' : 'routine',
+                        data: { discovery: d },
+                    });
+                }
+                if (this.metaCognitionLayer)
+                    this.metaCognitionLayer.recordStep('data_scout', this.cycleCount, { insights: discoveries.length });
+            }
+            catch (err) {
+                this.log.warn(`[orchestrator] Step 29 error: ${err.message}`);
+            }
+        }
+        // Step 30: Emergence Explanation — explain unexplained emergence events (every 5 cycles)
+        if (this.emergenceEngine && this.cycleCount % 5 === 0) {
+            try {
+                ts?.emit('orchestrator', 'analyzing', 'Step 30: Explaining recent emergence events...', 'routine');
+                const events = this.emergenceEngine.getEvents(5);
+                let explained = 0;
+                for (const e of events) {
+                    if (!e.id)
+                        continue;
+                    const existing = this.emergenceEngine.getExplanation(e.id);
+                    if (!existing) {
+                        this.emergenceEngine.explain(e.id);
+                        explained++;
+                    }
+                }
+                if (this.metaCognitionLayer)
+                    this.metaCognitionLayer.recordStep('emergence_explain', this.cycleCount, { insights: explained });
+            }
+            catch (err) {
+                this.log.warn(`[orchestrator] Step 30 error: ${err.message}`);
+            }
+        }
+        // Step 31: Meta-Trends — record system-wide trend data every cycle
+        if (this.metaCognitionLayer) {
+            try {
+                const totalPrinciples = this.knowledgeDistiller.getPrinciples(undefined, 1000).length;
+                const hypothesisSummary = this.hypothesisEngine.getSummary();
+                const totalHypotheses = hypothesisSummary.total ?? 0;
+                const predictionAccuracy = 0; // Will be filled if prediction engine available
+                let closedGaps = 0;
+                if (this.curiosityEngine) {
+                    const status = this.curiosityEngine.getStatus();
+                    closedGaps = status.totalGaps - status.activeGaps;
+                }
+                const emergenceCount = this.emergenceEngine ? this.emergenceEngine.getStatus().totalEvents : 0;
+                this.metaCognitionLayer.recordTrend(this.cycleCount, {
+                    newPrinciples: totalPrinciples,
+                    newHypotheses: totalHypotheses,
+                    predictionAccuracy,
+                    closedGaps,
+                    totalPrinciples,
+                    totalHypotheses,
+                    emergenceCount,
+                });
+            }
+            catch (err) {
+                this.log.warn(`[orchestrator] Step 31 error: ${err.message}`);
+            }
+        }
+        // Step 32: Simulation — run what-if scenarios (every 20 cycles)
+        if (this.simulationEngine && this.cycleCount % 20 === 0) {
+            try {
+                ts?.emit('orchestrator', 'hypothesizing', 'Step 32: Running what-if simulations...', 'routine');
+                const scenarios = ['error_rate doubles', 'learning_rate halves', 'prediction_accuracy increases by 20%'];
+                const scenario = scenarios[this.cycleCount % scenarios.length];
+                const sim = this.simulationEngine.simulate(scenario);
+                this.journal.write({
+                    type: 'insight',
+                    title: `Simulation: "${scenario}"`,
+                    content: `Predicted ${sim.predictedOutcomes.length} outcomes. ${sim.predictedOutcomes.map(o => `${o.metric}: ${o.direction} (${(o.confidence * 100).toFixed(0)}%)`).join(', ')}`,
+                    tags: ['simulation', 'what-if'],
+                    references: [],
+                    significance: 'routine',
+                    data: { simulation: sim },
+                });
+                if (this.metaCognitionLayer)
+                    this.metaCognitionLayer.recordStep('simulation', this.cycleCount, { predictions: sim.predictedOutcomes.length });
+            }
+            catch (err) {
+                this.log.warn(`[orchestrator] Step 32 error: ${err.message}`);
+            }
+        }
         const duration = Date.now() - start;
         ts?.emit('orchestrator', 'reflecting', `Feedback Cycle #${this.cycleCount} complete (${duration}ms)`);
         this.log.info(`[orchestrator] ─── Feedback Cycle #${this.cycleCount} complete (${duration}ms) ───`);
+        // Record cycle metrics into MetaCognition for engine-level tracking
+        if (this.metaCognitionLayer) {
+            this.metaCognitionLayer.recordStep('orchestrator', this.cycleCount, {
+                insights: insights.length,
+                anomalies: anomalies.length,
+                duration_ms: duration,
+            });
+        }
     }
     /** Analyze Brain's own state and generate concrete improvement suggestions.
      *  Tracks suggestion history — if a suggestion repeats 3+ times without resolution,
@@ -1240,9 +1567,15 @@ export class ResearchOrchestrator {
             this.experimentEngine.recordMeasurement(exp.id, value);
         }
     }
-    /** Append improvement suggestions to ~/.brain/improvement-requests.md */
+    /** Append improvement suggestions to ~/.brain/improvement-requests.md.
+     *  Skips writing if suggestions are identical to the last write (dedup). */
     writeSuggestionsToFile(suggestions) {
         try {
+            // Dedup: hash current suggestions and skip if identical to last write
+            const contentHash = suggestions.join('\n').trim();
+            if (contentHash === this.lastSuggestionsHash)
+                return;
+            this.lastSuggestionsHash = contentHash;
             const brainDir = path.join(os.homedir(), '.brain');
             const filePath = path.join(brainDir, 'improvement-requests.md');
             const timestamp = new Date().toISOString().replace('T', ' ').substring(0, 19);
@@ -1284,6 +1617,13 @@ export class ResearchOrchestrator {
             attention: this.attentionEngine?.getStatus() ?? null,
             transfer: this.transferEngine?.getStatus() ?? null,
             narrative: this.narrativeEngine?.getStatus() ?? null,
+            metacognition: this.metaCognitionLayer?.getStatus() ?? null,
+            autoExperiment: this.autoExperimentEngine?.getStatus(this.cycleCount) ?? null,
+            parameterRegistry: this.parameterRegistry?.getStatus() ?? null,
+            selfTest: this.selfTestEngine?.getStatus() ?? null,
+            teach: this.teachEngine?.getStatus() ?? null,
+            dataScout: this.dataScout?.getStatus() ?? null,
+            simulation: this.simulationEngine?.getStatus() ?? null,
         };
     }
 }