@timmeck/brain-core 2.36.56 → 2.36.58

package/dist/research/research-orchestrator.js

@@ -80,6 +80,10 @@ export class ResearchOrchestrator {
     causalPlanner = null;
     researchRoadmap = null;
     creativeEngine = null;
+    actionBridge = null;
+    contentForge = null;
+    codeForge = null;
+    strategyForge = null;
     lastAutoMissionTime = 0;
     lastGoalMissionTime = 0;
     onSuggestionCallback = null;
@@ -269,6 +273,14 @@ export class ResearchOrchestrator {
     setResearchRoadmap(roadmap) { this.researchRoadmap = roadmap; }
     /** Set the CreativeEngine — cross-domain idea generation. */
     setCreativeEngine(engine) { this.creativeEngine = engine; }
+    /** Set the ActionBridgeEngine — risk-assessed action execution. */
+    setActionBridge(bridge) { this.actionBridge = bridge; }
+    /** Set the ContentForge — autonomous content pipeline. */
+    setContentForge(forge) { this.contentForge = forge; }
+    /** Set the CodeForge — pattern extraction + auto-apply. */
+    setCodeForge(forge) { this.codeForge = forge; }
+    /** Set the StrategyForge — autonomous strategy execution. */
+    setStrategyForge(forge) { this.strategyForge = forge; }
     /** Set the LLMService — propagates to all engines that can use LLM. */
     setLLMService(llm) {
         this.llmService = llm;
@@ -2403,6 +2415,103 @@ export class ResearchOrchestrator {
                 this.log.warn(`[orchestrator] Step 58 (creative) error: ${err.message}`);
             }
         }
+        // Step 59: ActionBridge — process pending action queue (every 5 cycles)
+        if (this.actionBridge && this.cycleCount % 5 === 0) {
+            try {
+                ts?.emit('action_bridge', 'responding', 'Step 59: Processing action queue...', 'routine');
+                const executed = await this.actionBridge.processQueue();
+                if (executed > 0) {
+                    this.journal.write({
+                        type: 'discovery',
+                        title: `ActionBridge: auto-executed ${executed} action(s)`,
+                        content: `Queue processed: ${executed} actions executed automatically`,
+                        tags: [this.brainName, 'action-bridge', 'auto-execute'],
+                        references: [],
+                        significance: executed > 3 ? 'notable' : 'routine',
+                        data: { executed },
+                    });
+                }
+                if (this.metaCognitionLayer)
+                    this.metaCognitionLayer.recordStep('action_bridge', this.cycleCount, { insights: executed });
+            }
+            catch (err) {
+                this.log.warn(`[orchestrator] Step 59 error: ${err.message}`);
+            }
+        }
+        // Step 60: ContentForge — generate content from top creative insights (every 10 cycles)
+        if (this.contentForge && this.creativeEngine && this.cycleCount % 10 === 0) {
+            try {
+                ts?.emit('content_forge', 'discovering', 'Step 60: Generating content from insights...', 'routine');
+                const topInsights = this.creativeEngine.getInsights(3, 'raw');
+                let generated = 0;
+                for (const insight of topInsights) {
+                    if (insight.noveltyScore > 0.6) {
+                        const piece = this.contentForge.generateFromInsight(insight);
+                        this.contentForge.autoScheduleAndPublish(piece.id);
+                        generated++;
+                    }
+                }
+                if (generated > 0) {
+                    this.journal.write({
+                        type: 'discovery',
+                        title: `ContentForge: ${generated} content piece(s) generated`,
+                        content: `Generated ${generated} content pieces from creative insights`,
+                        tags: [this.brainName, 'content-forge', 'auto-generate'],
+                        references: [],
+                        significance: 'routine',
+                        data: { generated },
+                    });
+                }
+                if (this.metaCognitionLayer)
+                    this.metaCognitionLayer.recordStep('content_forge', this.cycleCount, { insights: generated });
+            }
+            catch (err) {
+                this.log.warn(`[orchestrator] Step 60 error: ${err.message}`);
+            }
+        }
+        // Step 61: CodeForge — extract patterns from code health scans (every 15 cycles)
+        if (this.codeForge && this.cycleCount % 15 === 0) {
+            try {
+                ts?.emit('code_forge', 'analyzing', 'Step 61: Extracting code patterns...', 'routine');
+                const patterns = this.codeForge.extractPatterns();
+                if (this.metaCognitionLayer)
+                    this.metaCognitionLayer.recordStep('code_forge', this.cycleCount, { insights: patterns.length });
+            }
+            catch (err) {
+                this.log.warn(`[orchestrator] Step 61 error: ${err.message}`);
+            }
+        }
+        // Step 62: StrategyForge — execute active strategies (every 20 cycles)
+        if (this.strategyForge && this.cycleCount % 20 === 0) {
+            try {
+                ts?.emit('strategy_forge', 'experimenting', 'Step 62: Executing active strategies...', 'routine');
+                const active = this.strategyForge.getActive();
+                let totalFired = 0;
+                for (const strategy of active) {
+                    try {
+                        const result = this.strategyForge.executeStep(strategy.id);
+                        totalFired += result.fired;
+                    }
+                    catch { /* individual strategy execution non-critical */ }
+                }
+                if (totalFired > 0) {
+                    this.journal.write({
+                        type: 'experiment',
+                        title: `StrategyForge: ${totalFired} rule(s) fired across ${active.length} strategies`,
+                        content: `Active strategies: ${active.map(s => s.name).join(', ')}`,
+                        tags: [this.brainName, 'strategy-forge', 'execution'],
+                        references: [],
+                        significance: totalFired > 5 ? 'notable' : 'routine',
+                        data: { totalFired, activeCount: active.length },
+                    });
+                }
+                if (this.metaCognitionLayer)
+                    this.metaCognitionLayer.recordStep('strategy_forge', this.cycleCount, { insights: totalFired });
+            }
+            catch (err) {
+                this.log.warn(`[orchestrator] Step 62 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) ───`);