@timmeck/brain-core 2.36.64 → 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;
@@ -2741,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) ───`);