@timmeck/brain-core 2.36.63 → 2.36.65

package/dist/research/research-orchestrator.js

@@ -85,6 +85,10 @@ export class ResearchOrchestrator {
     contentForge = null;
     codeForge = null;
     strategyForge = null;
+    engineRegistry = null;
+    runtimeInfluenceTracker = null;
+    loopDetector = null;
+    governanceLayer = null;
     lastAutoMissionTime = 0;
     lastGoalMissionTime = 0;
     roadmapBootstrapped = false;
@@ -294,6 +298,14 @@ export class ResearchOrchestrator {
     setCodeForge(forge) { this.codeForge = forge; }
     /** Set the StrategyForge — autonomous strategy execution. */
     setStrategyForge(forge) { this.strategyForge = forge; }
+    /** Set the EngineRegistry — formal engine profiles for governance. */
+    setEngineRegistry(registry) { this.engineRegistry = registry; }
+    /** Set the RuntimeInfluenceTracker — before/after snapshots for influence tracking. */
+    setRuntimeInfluenceTracker(tracker) { this.runtimeInfluenceTracker = tracker; }
+    /** Set the LoopDetector — anti-pattern detection. */
+    setLoopDetector(detector) { this.loopDetector = detector; }
+    /** Set the GovernanceLayer — active engine control. */
+    setGovernanceLayer(layer) { this.governanceLayer = layer; }
     /** Set the LLMService — propagates to all engines that can use LLM. */
     setLLMService(llm) {
         this.llmService = llm;
@@ -637,6 +649,16 @@ export class ResearchOrchestrator {
             }
             ts?.emit('hypothesis', 'analyzing', 'Testing pending hypotheses...');
             const testResults = this.hypothesisEngine.testAll();
+            // Quality filter: auto-reject weak hypotheses (confidence < 0.3 after testing)
+            const weak = testResults.filter(r => r.newStatus === 'testing' && r.confidence < 0.3 && (r.evidenceFor + r.evidenceAgainst) >= 3);
+            for (const w of weak) {
+                try {
+                    this.db.prepare("UPDATE hypotheses SET status = 'rejected' WHERE id = ?").run(w.hypothesisId);
+                }
+                catch { /* best effort */ }
+            }
+            if (weak.length > 0)
+                this.log.debug(`[orchestrator] Rejected ${weak.length} weak hypotheses (confidence < 0.3)`);
             const confirmed = testResults.filter(r => r.newStatus === 'confirmed');
             const rejected = testResults.filter(r => r.newStatus === 'rejected');
             if (confirmed.length > 0 || rejected.length > 0) {
@@ -821,6 +843,12 @@ export class ResearchOrchestrator {
                     catch { /* goal recording non-critical */ }
                 }
             }
+            // Diagnostics: log prediction stats for debugging stale accuracy
+            try {
+                const summary = this.predictionEngine.getSummary();
+                this.log.debug(`[orchestrator] Prediction stats: total=${summary.total_predictions}, resolved=${summary.resolved ?? 'N/A'}, pending=${summary.pending ?? 'N/A'}, accuracy=${(summary.accuracy_rate * 100).toFixed(1)}%`);
+            }
+            catch { /* non-critical */ }
             ts?.emit('prediction', 'predicting', 'Generating new predictions...');
             const newPredictions = this.predictionEngine.autoPredictAll();
             if (newPredictions.length > 0) {
@@ -1244,6 +1272,26 @@ export class ResearchOrchestrator {
                 this.log.debug(`[orchestrator] Auto-mission check error: ${err.message}`);
             }
         }
+        // 18c. Curiosity Auto-Answer: periodically answer unanswered questions via NarrativeEngine
+        if (this.curiosityEngine && this.narrativeEngine && this.cycleCount % (this.reflectEvery * 5) === 0) {
+            try {
+                const questions = this.curiosityEngine.getQuestions(10);
+                const unanswered = questions.filter(q => !q.answered).slice(0, 2);
+                for (const q of unanswered) {
+                    const answer = this.narrativeEngine.ask(q.question);
+                    if (answer.sources.length > 0 && q.id) {
+                        this.curiosityEngine.answerQuestion(q.id, answer.answer);
+                        this.log.debug(`[orchestrator] Auto-answered curiosity question #${q.id}: "${q.question.substring(0, 60)}"`);
+                    }
+                }
+                if (unanswered.length > 0) {
+                    ts?.emit('curiosity', 'exploring', `Auto-answered ${unanswered.length} curiosity question(s)`, 'routine');
+                }
+            }
+            catch (err) {
+                this.log.debug(`[orchestrator] Curiosity auto-answer error: ${err.message}`);
+            }
+        }
         // 19. Emergence Tracking: detect emergent patterns + record complexity metrics
         if (this.emergenceEngine && this.cycleCount % this.reflectEvery === 0) {
             ts?.emit('emergence', 'exploring', 'Scanning for emergent behaviors...');
@@ -2442,8 +2490,8 @@ export class ResearchOrchestrator {
                 this.log.warn(`[orchestrator] Step 57 (roadmap) error: ${err.message}`);
             }
         }
-        // Step 58: CreativeEngine — cross-pollination (every 20 cycles)
-        if (this.creativeEngine && this.cycleCount % 20 === 0) {
+        // Step 58: CreativeEngine — cross-pollination (every reflectEvery cycles)
+        if (this.creativeEngine && this.cycleCount % this.reflectEvery === 0) {
             try {
                 const debugInfo = this.creativeEngine.getDebugInfo();
                 this.log.debug(`[orchestrator] Step 58: ${debugInfo.principlesCount} principles, domains: ${JSON.stringify(debugInfo.domains)}`);
@@ -2463,8 +2511,12 @@ export class ResearchOrchestrator {
                     });
                 }
                 else {
-                    ts?.emit('creative', 'reflecting', `Step 58: 0 insights (${debugInfo.principlesCount} principles, ${Object.keys(debugInfo.domains).length} domains)`, 'notable');
+                    const domainCount = Object.keys(debugInfo.domains).length;
+                    this.log.debug(`[orchestrator] Step 58: 0 insights — ${domainCount} domain(s) (need 2+), ${debugInfo.principlesCount} principles`);
+                    ts?.emit('creative', 'reflecting', `Step 58: 0 insights (${debugInfo.principlesCount} principles, ${domainCount} domains)`, 'notable');
                 }
+                if (this.metaCognitionLayer)
+                    this.metaCognitionLayer.recordStep('creative_engine', this.cycleCount, { insights: insights.length });
             }
             catch (err) {
                 this.log.warn(`[orchestrator] Step 58 (creative) error: ${err.message}`);
@@ -2701,6 +2753,62 @@ export class ResearchOrchestrator {
                 this.log.warn(`[orchestrator] Step 65 (outcome review) error: ${err.message}`);
             }
         }
+        // Step 66: RuntimeInfluenceTracker — feed into CausalGraph (every 10 cycles)
+        if (this.runtimeInfluenceTracker && this.causalGraph && this.cycleCount % 10 === 0) {
+            try {
+                ts?.emit('governance', 'analyzing', 'Step 66: Feeding engine influences into CausalGraph...', 'routine');
+                this.runtimeInfluenceTracker.feedIntoCausalGraph(this.causalGraph);
+                if (this.metaCognitionLayer)
+                    this.metaCognitionLayer.recordStep('influence_tracker', this.cycleCount, { insights: 0 });
+            }
+            catch (err) {
+                this.log.warn(`[orchestrator] Step 66 (influence tracker) error: ${err.message}`);
+            }
+        }
+        // Step 67: LoopDetector — detect anti-patterns (every 10 cycles)
+        if (this.loopDetector && this.cycleCount % 10 === 0) {
+            try {
+                ts?.emit('governance', 'analyzing', 'Step 67: Scanning for anti-patterns...', 'routine');
+                const loopDetections = this.loopDetector.detect(this.cycleCount);
+                if (loopDetections.length > 0) {
+                    ts?.emit('governance', 'discovering', `Step 67: ${loopDetections.length} anti-pattern(s) detected`, 'notable');
+                    this.journal.write({
+                        type: 'insight', title: `Loop Detector: ${loopDetections.length} anti-pattern(s)`,
+                        content: loopDetections.map(d => `${d.loopType}: ${d.description}`).join('\n'),
+                        tags: [this.brainName, 'governance', 'loop-detector'],
+                        references: [], significance: 'notable',
+                        data: { detections: loopDetections.length },
+                    });
+                }
+                if (this.metaCognitionLayer)
+                    this.metaCognitionLayer.recordStep('loop_detector', this.cycleCount, { insights: loopDetections.length });
+            }
+            catch (err) {
+                this.log.warn(`[orchestrator] Step 67 (loop detector) error: ${err.message}`);
+            }
+        }
+        // Step 68: GovernanceLayer — auto-governance review (every 10 cycles)
+        if (this.governanceLayer && this.cycleCount % 10 === 0) {
+            try {
+                ts?.emit('governance', 'analyzing', 'Step 68: Governance review...', 'routine');
+                const decisions = this.governanceLayer.review(this.cycleCount);
+                if (decisions.length > 0) {
+                    ts?.emit('governance', 'responding', `Step 68: ${decisions.length} governance decision(s)`, 'notable');
+                    this.journal.write({
+                        type: 'insight', title: `Governance: ${decisions.length} decision(s)`,
+                        content: decisions.map(d => `${d.action} → ${d.engine}: ${d.reason}`).join('\n'),
+                        tags: [this.brainName, 'governance', 'decisions'],
+                        references: [], significance: 'notable',
+                        data: { decisions: decisions.length },
+                    });
+                }
+                if (this.metaCognitionLayer)
+                    this.metaCognitionLayer.recordStep('governance_layer', this.cycleCount, { insights: decisions.length });
+            }
+            catch (err) {
+                this.log.warn(`[orchestrator] Step 68 (governance) 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) ───`);
@@ -3548,6 +3656,7 @@ export class ResearchOrchestrator {
         if (this.featureRecommender) {
             try {
                 const wishes = this.featureRecommender.getWishlist('matched');
+                this.log.debug(`[selfmod] Source A: ${wishes.length} matched wishes`);
                 const actionable = wishes.find(w => w.priority >= 0.5 && w.matchScore >= 0.3);
                 if (actionable) {
                     // Try to get reference code from matched feature
@@ -3569,6 +3678,9 @@ export class ResearchOrchestrator {
             }
             catch { /* featureRecommender not ready */ }
         }
+        else {
+            this.log.debug('[selfmod] Source A skipped: no featureRecommender');
+        }
         // ── Source B: CodeHealth issues → SelfMod suggestions ──
         if (this.codeHealthMonitor) {
             try {
@@ -3593,12 +3705,19 @@ export class ResearchOrchestrator {
             }
             catch { /* code health not ready */ }
         }
+        else {
+            this.log.debug('[selfmod] Source B skipped: no codeHealthMonitor');
+        }
         // ── Source C: Existing suggestions (filtered — skip AutoResponder noise) ──
-        if (!this.selfScanner)
+        if (!this.selfScanner) {
+            this.log.debug('[selfmod] Source C skipped: no selfScanner');
             return null;
+        }
         const suggestions = this.generateSelfImprovementSuggestions();
-        if (suggestions.length === 0)
+        if (suggestions.length === 0) {
+            this.log.debug('[selfmod] Source C: 0 suggestions from generateSelfImprovementSuggestions()');
             return null;
+        }
         // Engine name → module file mapping heuristics
         const engineMap = {
             SelfObserver: ['research/self-observer'],