@timmeck/brain-core 2.36.64 → 2.36.66

package/dist/prediction/prediction-engine.js

@@ -73,7 +73,7 @@ export class PredictionEngine {
             ewmaAlpha: config.ewmaAlpha ?? 0.3,
             trendBeta: config.trendBeta ?? 0.1,
             minDataPoints: config.minDataPoints ?? 5,
-            minConfidence: config.minConfidence ?? 0.5,
+            minConfidence: config.minConfidence ?? 0.3,
             maxPredictionsPerCycle: config.maxPredictionsPerCycle ?? 5,
             resolveIntervalMs: config.resolveIntervalMs ?? 60_000,
         };

package/dist/research/research-orchestrator.d.ts

@@ -136,6 +136,10 @@ export declare class ResearchOrchestrator {
     private contentForge;
     private codeForge;
     private strategyForge;
+    private engineRegistry;
+    private runtimeInfluenceTracker;
+    private loopDetector;
+    private governanceLayer;
     private lastAutoMissionTime;
     private lastGoalMissionTime;
     private roadmapBootstrapped;
@@ -276,6 +280,14 @@ export declare class ResearchOrchestrator {
     setCodeForge(forge: import('../codegen/code-forge.js').CodeForge): void;
     /** Set the StrategyForge — autonomous strategy execution. */
     setStrategyForge(forge: import('../strategy/strategy-forge.js').StrategyForge): void;
+    /** Set the EngineRegistry — formal engine profiles for governance. */
+    setEngineRegistry(registry: import('../governance/engine-registry.js').EngineRegistry): void;
+    /** Set the RuntimeInfluenceTracker — before/after snapshots for influence tracking. */
+    setRuntimeInfluenceTracker(tracker: import('../governance/runtime-influence-tracker.js').RuntimeInfluenceTracker): void;
+    /** Set the LoopDetector — anti-pattern detection. */
+    setLoopDetector(detector: import('../governance/loop-detector.js').LoopDetector): void;
+    /** Set the GovernanceLayer — active engine control. */
+    setGovernanceLayer(layer: import('../governance/governance-layer.js').GovernanceLayer): void;
     /** Set the LLMService — propagates to all engines that can use LLM. */
     setLLMService(llm: LLMService): void;
     /** Get the LLMService instance. */

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;
@@ -876,6 +888,21 @@ export class ResearchOrchestrator {
                 this.predictionEngine.recordMetric('knowledge_confidence', kSummary.avgConfidence, 'metric');
             }
             catch { /* skip */ }
+            // 11a. Error-domain metrics (only brain has errors table — try/catch)
+            try {
+                const errorTotal = this.db.prepare(`SELECT COUNT(*) as cnt FROM errors`).get().cnt;
+                const errorUnresolved = this.db.prepare(`SELECT COUNT(*) as cnt FROM errors WHERE resolved = 0`).get().cnt;
+                const oneHourAgo = Date.now() - 3_600_000;
+                const errorRate1h = this.db.prepare(`SELECT COUNT(*) as cnt FROM errors WHERE timestamp > ?`).get(oneHourAgo).cnt;
+                const solutionTotal = this.db.prepare(`SELECT COUNT(*) as cnt FROM solutions`).get().cnt;
+                const resolutionRate = errorTotal > 0 ? (errorTotal - errorUnresolved) / errorTotal : 0;
+                this.predictionEngine.recordMetric('error_total', errorTotal, 'error');
+                this.predictionEngine.recordMetric('error_unresolved', errorUnresolved, 'error');
+                this.predictionEngine.recordMetric('error_rate_1h', errorRate1h, 'error');
+                this.predictionEngine.recordMetric('solution_total', solutionTotal, 'error');
+                this.predictionEngine.recordMetric('error_resolution_rate', resolutionRate, 'error');
+            }
+            catch { /* errors/solutions tables don't exist in this brain — skip */ }
             ts?.emit('orchestrator', 'perceiving', `Self-metrics recorded: ${anomalies.length} anomalies, ${insights.length} insights, ${cycleDuration}ms`);
             // 11b. Re-resolve predictions now that fresh metrics are available
             // (Step 9 resolves before metrics are recorded, so we re-check here)
@@ -974,6 +1001,9 @@ export class ResearchOrchestrator {
                         this.predictionEngine.recordMetric('scanner_total_repos', status.total_repos, 'scanner');
                         this.predictionEngine.recordMetric('scanner_breakouts', status.by_level.breakout, 'scanner');
                         this.predictionEngine.recordMetric('scanner_signals', status.by_level.signal, 'scanner');
+                        this.predictionEngine.recordMetric('scanner_avg_score', status.avg_score ?? 0, 'scanner');
+                        this.predictionEngine.recordMetric('scanner_new_breakouts', scan.new_breakouts, 'scanner');
+                        this.predictionEngine.recordMetric('scanner_new_signals', scan.new_signals, 'scanner');
                     }
                     // Journal new breakouts
                     if (scan.new_breakouts > 0) {
@@ -1163,6 +1193,23 @@ export class ResearchOrchestrator {
                 const gaps = this.curiosityEngine.detectGaps();
                 if (gaps.length > 0) {
                     ts?.emit('curiosity', 'discovering', `Found ${gaps.length} knowledge gap(s): ${gaps.slice(0, 3).map(g => `"${g.topic}" (${(g.gapScore * 100).toFixed(0)}%)`).join(', ')}`, gaps.some(g => g.gapType === 'dark_zone') ? 'notable' : 'routine');
+                    // Bridge: feed top-3 gaps as observations into HypothesisEngine → targeted hypotheses
+                    for (const gap of gaps.slice(0, 3)) {
+                        this.hypothesisEngine.observe({
+                            source: this.brainName,
+                            type: `knowledge_gap:${gap.topic}`,
+                            value: gap.gapScore,
+                            timestamp: now,
+                            metadata: { gapType: gap.gapType, attentionScore: gap.attentionScore, knowledgeScore: gap.knowledgeScore },
+                        });
+                    }
+                    // Bridge: feed gap metrics into PredictionEngine
+                    if (this.predictionEngine) {
+                        this.predictionEngine.recordMetric('knowledge_gap_count', gaps.length, 'metric');
+                        for (const gap of gaps.slice(0, 3)) {
+                            this.predictionEngine.recordMetric(`gap_score:${gap.topic}`, gap.gapScore, 'metric');
+                        }
+                    }
                     // Journal dark zones (truly unknown territory)
                     for (const gap of gaps.filter(g => g.gapType === 'dark_zone').slice(0, 2)) {
                         this.journal.write({
@@ -1402,6 +1449,25 @@ export class ResearchOrchestrator {
                 });
             }
         }
+        // 22c. Sync DreamEngine params from ParameterRegistry
+        if (this.parameterRegistry && this.dreamEngine) {
+            const clusterSim = this.parameterRegistry.get('dream', 'cluster_similarity');
+            const replayBatch = this.parameterRegistry.get('dream', 'replay_batch_size');
+            const maxConsol = this.parameterRegistry.get('dream', 'max_consolidations');
+            const pruneThreshold = this.parameterRegistry.get('dream', 'prune_threshold');
+            const learningRate = this.parameterRegistry.get('dream', 'learning_rate');
+            const decayRate = this.parameterRegistry.get('dream', 'importance_decay_rate');
+            if (clusterSim !== undefined || replayBatch !== undefined || maxConsol !== undefined || pruneThreshold !== undefined || learningRate !== undefined || decayRate !== undefined) {
+                this.dreamEngine.updateConfig({
+                    ...(clusterSim !== undefined ? { clusterSimilarityThreshold: clusterSim } : {}),
+                    ...(replayBatch !== undefined ? { replayBatchSize: replayBatch } : {}),
+                    ...(maxConsol !== undefined ? { maxConsolidationsPerCycle: maxConsol } : {}),
+                    ...(pruneThreshold !== undefined ? { dreamPruneThreshold: pruneThreshold } : {}),
+                    ...(learningRate !== undefined ? { dreamLearningRate: learningRate } : {}),
+                    ...(decayRate !== undefined ? { importanceDecayRate: decayRate } : {}),
+                });
+            }
+        }
         // Step 23: Blind Spot Detection (every 5 cycles)
         if (this.curiosityEngine && this.cycleCount % 5 === 0) {
             try {
@@ -2741,6 +2807,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) ───`);