@timmeck/brain-core 2.34.1 → 2.35.1

package/dist/research/research-orchestrator.js

@@ -55,6 +55,8 @@ export class ResearchOrchestrator {
     selfScanner = null;
     selfModificationEngine = null;
     bootstrapService = null;
+    conceptAbstraction = null;
+    db;
     brainName;
     feedbackTimer = null;
     cycleCount = 0;
@@ -69,6 +71,7 @@ export class ResearchOrchestrator {
     /** Hash of last written suggestions to prevent duplicate file writes. */
     lastSuggestionsHash = '';
     constructor(db, config, causalGraph) {
+        this.db = db;
         this.brainName = config.brainName;
         this.distillEvery = config.distillEvery ?? 5;
         this.agendaEvery = config.agendaEvery ?? 3;
@@ -86,7 +89,7 @@ export class ResearchOrchestrator {
         this.autoResponder = new AutoResponder(db, { brainName: config.brainName });
         this.autoResponder.setAdaptiveStrategy(this.adaptiveStrategy);
         this.autoResponder.setJournal(this.journal);
-        this.hypothesisEngine = new HypothesisEngine(db, { minEvidence: 5, confirmThreshold: 0.05, rejectThreshold: 0.5 });
+        this.hypothesisEngine = new HypothesisEngine(db, { minEvidence: 3, confirmThreshold: 0.05, rejectThreshold: 0.5 });
     }
     /** Set the DataMiner instance for DB-driven engine feeding. */
     setDataMiner(miner) {
@@ -124,6 +127,8 @@ export class ResearchOrchestrator {
     /** Set the TransferEngine — cross-domain knowledge transfer. */
     setTransferEngine(engine) {
         this.transferEngine = engine;
+        // Register own distiller as peer for self-analysis and transfer proposals
+        engine.registerPeerDistiller(this.brainName + '_self', this.knowledgeDistiller);
     }
     /** Set the NarrativeEngine — brain explains itself in natural language. */
     setNarrativeEngine(engine) {
@@ -175,6 +180,8 @@ export class ResearchOrchestrator {
     setSelfModificationEngine(engine) { this.selfModificationEngine = engine; }
     /** Set the BootstrapService — seeds initial data on first cycle. */
     setBootstrapService(service) { this.bootstrapService = service; }
+    /** Set the ConceptAbstraction — clusters knowledge into abstract concepts. */
+    setConceptAbstraction(engine) { this.conceptAbstraction = engine; }
     /** Set the PredictionEngine — wires journal into it. */
     setPredictionEngine(engine) {
         this.predictionEngine = engine;
@@ -350,6 +357,73 @@ export class ResearchOrchestrator {
                 this.hypothesisEngine.observe({ source: this.brainName, type: `anomaly:${a.metric}`, value: a.deviation, timestamp: now, metadata: { severity: a.severity } });
             }
         }
+        // 2e. Accumulate evidence for hypotheses based on cycle observations
+        {
+            const pendingHypotheses = this.hypothesisEngine.list('proposed', 50)
+                .concat(this.hypothesisEngine.list('testing', 50));
+            for (const hyp of pendingHypotheses) {
+                if (!hyp.id)
+                    continue;
+                const vars = hyp.variables ?? [];
+                const statement = hyp.statement.toLowerCase();
+                let evidenceType = null;
+                let reason = '';
+                // Check if cycle metrics match hypothesis variables
+                if (vars.includes('journal_entries') || statement.includes('journal')) {
+                    const journalStats = this.journal.getSummary();
+                    const entries = journalStats.total_entries ?? 0;
+                    if (entries > this.cycleCount) {
+                        evidenceType = 'for';
+                        reason = `journal_entries=${entries} growing (cycle ${this.cycleCount})`;
+                    }
+                    else if (this.cycleCount > 5 && entries < 3) {
+                        evidenceType = 'against';
+                        reason = `journal_entries=${entries} stagnant after ${this.cycleCount} cycles`;
+                    }
+                }
+                else if (vars.includes('anomaly_count') || statement.includes('anomal')) {
+                    if (anomalies.length > 0) {
+                        evidenceType = 'for';
+                        reason = `${anomalies.length} anomalies detected this cycle`;
+                    }
+                }
+                else if (vars.includes('insight_count') || vars.includes('observation_type_count') || statement.includes('observation')) {
+                    if (insights.length > 0) {
+                        evidenceType = 'for';
+                        reason = `${insights.length} insights from observations this cycle`;
+                    }
+                }
+                else if (statement.includes('dream') || statement.includes('memor')) {
+                    // Dream-related: check if dream engine produced output
+                    if (this.dreamEngine) {
+                        const dStatus = this.dreamEngine.getStatus();
+                        const totals = dStatus.totals;
+                        if ((totals?.memoriesConsolidated ?? 0) > 0) {
+                            evidenceType = 'for';
+                            reason = `dream consolidated ${totals?.memoriesConsolidated} memories`;
+                        }
+                    }
+                }
+                else if (statement.includes('attention') || statement.includes('focus')) {
+                    if (this.attentionEngine) {
+                        const topTopics = this.attentionEngine.getTopTopics(1);
+                        if (topTopics.length > 0) {
+                            evidenceType = 'for';
+                            reason = `attention active: top topic "${topTopics[0].topic}" (score=${topTopics[0].score.toFixed(1)})`;
+                        }
+                    }
+                }
+                if (evidenceType && hyp.id) {
+                    try {
+                        const col = evidenceType === 'for' ? 'evidence_for' : 'evidence_against';
+                        this.db.prepare(`UPDATE hypotheses SET ${col} = ${col} + 1 WHERE id = ?`).run(hyp.id);
+                    }
+                    catch {
+                        // Hypothesis table might not have these columns yet — skip
+                    }
+                }
+            }
+        }
         // 2d. Attention Engine: decay scores, compute engine weights, persist focus
         if (this.attentionEngine) {
             ts?.emit('attention', 'focusing', 'Updating attention scores and engine weights...');
@@ -497,18 +571,45 @@ export class ResearchOrchestrator {
             this.journal.reflect();
             ts?.emit('journal', 'reflecting', 'Reflection complete', 'notable');
         }
-        // 8b. Cycle-end journal entry — guarantees journal grows every cycle
+        // 8b. Cycle-end journal entry — guarantees journal grows every cycle (enriched with engine state)
         {
             const cycleDuration = Date.now() - start;
             const journalStats = this.journal.getSummary();
+            const hypSummary = this.hypothesisEngine.getSummary();
+            const predAccuracy = (() => {
+                try {
+                    const predSummary = this.predictionEngine?.getSummary();
+                    const domains = (predSummary?.by_domain ?? []);
+                    if (domains.length > 0)
+                        return Math.round((domains[0]?.accuracy_rate ?? 0) * 100);
+                }
+                catch { /* */ }
+                return 0;
+            })();
+            const attTopics = (() => {
+                try {
+                    return this.attentionEngine?.getTopTopics?.(3) ?? [];
+                }
+                catch {
+                    return [];
+                }
+            })();
+            const focusStr = attTopics.length > 0
+                ? attTopics.map((t) => t.topic).join(', ')
+                : 'none';
             this.journal.write({
                 type: 'insight',
                 title: `Cycle #${this.cycleCount} summary`,
-                content: `Completed feedback cycle #${this.cycleCount} in ${cycleDuration}ms. ${insights.length} insights, ${anomalies.length} anomalies detected. Journal now has ${journalStats.total_entries ?? 0} entries.`,
+                content: `Completed feedback cycle #${this.cycleCount} in ${cycleDuration}ms. ${insights.length} insights, ${anomalies.length} anomalies detected. Hypotheses: ${hypSummary.proposed} pending, ${hypSummary.confirmed} confirmed. Predictions: accuracy ${predAccuracy}%. Focus: ${focusStr}. Journal: ${journalStats.total_entries ?? 0} entries.`,
                 tags: [this.brainName, 'cycle-summary'],
                 references: [],
                 significance: 'routine',
-                data: { cycle: this.cycleCount, duration_ms: cycleDuration, insights: insights.length, anomalies: anomalies.length },
+                data: {
+                    cycle: this.cycleCount, duration_ms: cycleDuration,
+                    insights: insights.length, anomalies: anomalies.length,
+                    hypotheses_confirmed: hypSummary.confirmed, hypotheses_total: hypSummary.total,
+                    prediction_accuracy: predAccuracy, focus: focusStr,
+                },
             });
         }
         // 9. Prediction Engine: resolve pending + auto-predict
@@ -551,6 +652,15 @@ export class ResearchOrchestrator {
         if (this.autoExperimentEngine && this.cycleCount > 3 && this.cycleCount % 5 === 0) {
             ts?.emit('auto_experiment', 'experimenting', 'Processing auto-experiments...');
             try {
+                // Ensure MetaCognition has fresh report cards before AutoExperiment discovers candidates
+                if (this.metaCognitionLayer) {
+                    try {
+                        this.metaCognitionLayer.evaluate();
+                    }
+                    catch (mcErr) {
+                        this.log.warn(`[orchestrator] MetaCog pre-eval for AutoExp: ${mcErr.message}`);
+                    }
+                }
                 // Feed measurements
                 this.autoExperimentEngine.feedMeasurement('insight_count', insights.length);
                 this.autoExperimentEngine.feedMeasurement('anomaly_count', anomalies.length);
@@ -584,6 +694,28 @@ export class ResearchOrchestrator {
         }
         // 13. Periodic Dream Consolidation: don't wait for idle, consolidate every 10 cycles
         if (this.dreamEngine && this.cycleCount % 10 === 0) {
+            ts?.emit('dream', 'dreaming', 'Feeding knowledge into memories for consolidation...');
+            try {
+                // Feed current knowledge into memories table so consolidation has material
+                const principles = this.knowledgeDistiller.getPrinciples(undefined, 50);
+                const journalEntries = this.journal.search('', 30);
+                const insertMemory = this.db.prepare(`
+          INSERT OR IGNORE INTO memories (category, key, content, importance, source, tags, active)
+          VALUES (?, ?, ?, ?, 'orchestrator_feed', ?, 1)
+        `);
+                for (const p of principles) {
+                    insertMemory.run('principle', `principle:${p.id ?? p.statement.substring(0, 50)}`, p.statement, Math.min(1, (p.confidence ?? 0.5) + 0.3), JSON.stringify(['principle', this.brainName]));
+                }
+                for (const j of journalEntries) {
+                    if (j.significance === 'breakthrough' || j.significance === 'notable') {
+                        insertMemory.run('journal', `journal:${j.id ?? j.title.substring(0, 50)}`, `${j.title}: ${j.content?.substring(0, 200) ?? ''}`, j.significance === 'breakthrough' ? 0.9 : 0.6, JSON.stringify(['journal', j.type, this.brainName]));
+                    }
+                }
+                ts?.emit('dream', 'dreaming', `Fed ${principles.length} principles + ${journalEntries.filter(j => j.significance === 'breakthrough' || j.significance === 'notable').length} journal entries into memories`);
+            }
+            catch (feedErr) {
+                this.log.warn(`[orchestrator] Dream memory feed error: ${feedErr.message}`);
+            }
             ts?.emit('dream', 'dreaming', 'Scheduled consolidation starting (every 10 cycles)...');
             try {
                 this.dreamEngine.consolidate('auto');
@@ -867,6 +999,29 @@ export class ResearchOrchestrator {
                 this.log.error(`[orchestrator] MetaCognition error: ${err.message}`);
             }
         }
+        // 21b. Adaptive Strategy: adjust parameters for poorly performing engines
+        if (this.metaCognitionLayer && this.cycleCount % this.reflectEvery === 0) {
+            try {
+                const cards = this.metaCognitionLayer.getLatestReportCards();
+                const poorCards = cards.filter(c => c.grade === 'D' || c.grade === 'F');
+                for (const card of poorCards.slice(0, 3)) {
+                    // Try adapting the engine's research strategy parameters
+                    const strategyDomains = ['research', 'learning'];
+                    for (const domain of strategyDomains) {
+                        const currentVal = this.adaptiveStrategy.getParam(domain, card.engine);
+                        if (currentVal !== null) {
+                            const direction = card.grade === 'F' ? 0.2 : 0.1;
+                            this.adaptiveStrategy.adapt(domain, card.engine, currentVal * (1 + direction), `MetaCog grade ${card.grade} — boosting ${card.engine}`, { reportCard: card });
+                            ts?.emit('adaptive_strategy', 'discovering', `Adapted ${domain}.${card.engine}: grade ${card.grade} → boost ${(direction * 100).toFixed(0)}%`, 'routine');
+                            break; // Only adapt one domain per engine
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                this.log.warn(`[orchestrator] Step 21b AdaptiveStrategy error: ${err.message}`);
+            }
+        }
         // 22. Parameter Registry: refresh orchestrator params from registry
         if (this.parameterRegistry) {
             const distill = this.parameterRegistry.get('orchestrator', 'distillEvery');
@@ -1328,6 +1483,48 @@ export class ResearchOrchestrator {
                 this.log.warn(`[orchestrator] Step 40 error: ${err.message}`);
             }
         }
+        // Step 41: ConceptAbstraction — cluster knowledge into abstract concepts (every 10 cycles)
+        if (this.conceptAbstraction && this.cycleCount % 10 === 0) {
+            try {
+                ts?.emit('concept_abstraction', 'analyzing', 'Step 41: Forming abstract concepts...', 'routine');
+                const result = this.conceptAbstraction.formConcepts();
+                if (result.totalConcepts > 0) {
+                    this.journal.write({
+                        title: `Concept Formation: ${result.totalConcepts} concepts across ${Object.keys(result.levels).length} levels`,
+                        type: 'discovery',
+                        content: `Formed ${result.totalConcepts} concepts (L0: ${result.levels[0] ?? 0}, L1: ${result.levels[1] ?? 0}, L2: ${result.levels[2] ?? 0})`,
+                        tags: [this.brainName, 'concept-abstraction', 'knowledge-organization'],
+                        references: [],
+                        significance: result.newConcepts > 0 ? 'notable' : 'routine',
+                        data: result,
+                    });
+                }
+                // Register concepts in MemoryPalace
+                if (this.memoryPalace && result.totalConcepts > 0) {
+                    try {
+                        this.conceptAbstraction.registerInPalace(this.memoryPalace);
+                    }
+                    catch (palaceErr) {
+                        this.log.warn(`[orchestrator] Step 41 palace registration error: ${palaceErr.message}`);
+                    }
+                }
+                // Feed transferable concepts into TransferEngine
+                if (this.transferEngine && result.totalConcepts > 0) {
+                    try {
+                        const transferable = this.conceptAbstraction.getTransferableConcepts(0.3);
+                        if (transferable.length > 0) {
+                            ts?.emit('concept_abstraction', 'discovering', `${transferable.length} cross-domain concepts available for transfer`, 'notable');
+                        }
+                    }
+                    catch { /* not critical */ }
+                }
+                if (this.metaCognitionLayer)
+                    this.metaCognitionLayer.recordStep('concept_abstraction', this.cycleCount, { insights: result.newConcepts });
+            }
+            catch (err) {
+                this.log.warn(`[orchestrator] Step 41 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) ───`);