@timmeck/brain-core 2.36.66 → 2.36.68

package/dist/research/research-orchestrator.js

@@ -89,6 +89,7 @@ export class ResearchOrchestrator {
     runtimeInfluenceTracker = null;
     loopDetector = null;
     governanceLayer = null;
+    adaptiveScheduler = null;
     lastAutoMissionTime = 0;
     lastGoalMissionTime = 0;
     roadmapBootstrapped = false;
@@ -139,6 +140,14 @@ export class ResearchOrchestrator {
     setOnSuggestion(callback) {
         this.onSuggestionCallback = callback;
     }
+    /** Set the AdaptiveScheduler for dynamic cycle intervals. */
+    setAdaptiveScheduler(scheduler) {
+        this.adaptiveScheduler = scheduler;
+    }
+    /** Get the AdaptiveScheduler instance. */
+    getAdaptiveScheduler() {
+        return this.adaptiveScheduler;
+    }
     /** Set the DataMiner instance for DB-driven engine feeding. */
     setDataMiner(miner) {
         this.dataMiner = miner;
@@ -326,20 +335,31 @@ export class ResearchOrchestrator {
     start(intervalMs = 300_000) {
         if (this.feedbackTimer)
             return;
-        this.feedbackTimer = setInterval(() => {
+        this.startIntervalMs = intervalMs;
+        this.scheduleNextCycle(intervalMs);
+        this.log.info(`[orchestrator] Research orchestrator started (feedback every ${intervalMs}ms)`);
+    }
+    /** Schedule the next feedback cycle (supports adaptive intervals). */
+    scheduleNextCycle(intervalMs) {
+        if (this.feedbackTimer)
+            clearTimeout(this.feedbackTimer);
+        this.feedbackTimer = setTimeout(async () => {
             try {
-                void this.runFeedbackCycle();
+                await this.runFeedbackCycle();
             }
             catch (err) {
                 this.log.error('[orchestrator] Feedback cycle error', { error: err.message });
             }
+            // Re-schedule with adaptive or base interval
+            const nextInterval = this.adaptiveScheduler?.getNextInterval() ?? this.startIntervalMs;
+            this.scheduleNextCycle(nextInterval);
         }, intervalMs);
-        this.log.info(`[orchestrator] Research orchestrator started (feedback every ${intervalMs}ms)`);
     }
+    startIntervalMs = 300_000;
     /** Stop the feedback loop. */
     stop() {
         if (this.feedbackTimer) {
-            clearInterval(this.feedbackTimer);
+            clearTimeout(this.feedbackTimer);
             this.feedbackTimer = null;
         }
         this.dreamEngine?.stop();
@@ -514,6 +534,22 @@ export class ResearchOrchestrator {
                 this.hypothesisEngine.observe({ source: this.brainName, type: `anomaly:${a.metric}`, value: a.deviation, timestamp: now, metadata: { severity: a.severity } });
             }
         }
+        // 2d. Prediction accuracy as standard observation — feeds HypothesisEngine + PredictionEngine self-accuracy
+        if (this.predictionEngine) {
+            try {
+                const accByDomain = this.predictionEngine.getAccuracy();
+                const overall = accByDomain.length > 0
+                    ? accByDomain.reduce((s, a) => s + a.accuracy_rate, 0) / accByDomain.length
+                    : 0;
+                this.hypothesisEngine.observe({ source: this.brainName, type: 'prediction_accuracy_rate', value: overall, timestamp: now });
+                for (const acc of accByDomain) {
+                    this.hypothesisEngine.observe({ source: this.brainName, type: `prediction_accuracy:${acc.domain}`, value: acc.accuracy_rate, timestamp: now, metadata: { total: acc.total, correct: acc.correct } });
+                }
+                // Brain predicts its own accuracy
+                this.predictionEngine.recordMetric('self_accuracy_rate', overall, 'metric');
+            }
+            catch { /* prediction accuracy non-critical */ }
+        }
         // 2e. Accumulate evidence for hypotheses based on cycle observations
         {
             const pendingHypotheses = this.hypothesisEngine.list('proposed', 50)
@@ -1210,6 +1246,33 @@ export class ResearchOrchestrator {
                             this.predictionEngine.recordMetric(`gap_score:${gap.topic}`, gap.gapScore, 'metric');
                         }
                     }
+                    // Internal domain observations: feed concrete metrics for gap topics
+                    for (const gap of gaps.slice(0, 5)) {
+                        const topic = gap.topic.toLowerCase();
+                        try {
+                            if (topic.includes('prediction')) {
+                                // Feed per-domain prediction accuracy into HypothesisEngine
+                                const accByDomain = this.predictionEngine?.getAccuracy() ?? [];
+                                for (const acc of accByDomain) {
+                                    this.hypothesisEngine.observe({ source: this.brainName, type: `internal:prediction_accuracy:${acc.domain}`, value: acc.accuracy_rate, timestamp: now, metadata: { total: acc.total, correct: acc.correct } });
+                                }
+                            }
+                            else if (topic.includes('anomaly')) {
+                                const anomalyCount = this.anomalyDetective.getAnomalies(undefined, 100).length;
+                                this.hypothesisEngine.observe({ source: this.brainName, type: 'internal:anomaly_detection_count', value: anomalyCount, timestamp: now });
+                            }
+                            else if (topic.includes('distill') || topic.includes('knowledge')) {
+                                const kSummary = this.knowledgeDistiller.getSummary();
+                                this.hypothesisEngine.observe({ source: this.brainName, type: 'internal:distillation_throughput', value: kSummary.principles + kSummary.antiPatterns + kSummary.strategies, timestamp: now, metadata: { principles: kSummary.principles, avgConfidence: kSummary.avgConfidence } });
+                            }
+                            else if (topic.includes('dream') || topic.includes('consolidat')) {
+                                const dStatus = this.dreamEngine?.getStatus();
+                                const totals = dStatus?.totals;
+                                this.hypothesisEngine.observe({ source: this.brainName, type: 'internal:dream_consolidation_count', value: (totals?.memoriesConsolidated ?? 0), timestamp: now });
+                            }
+                        }
+                        catch { /* internal observation non-critical */ }
+                    }
                     // Journal dark zones (truly unknown territory)
                     for (const gap of gaps.filter(g => g.gapType === 'dark_zone').slice(0, 2)) {
                         this.journal.write({
@@ -1442,10 +1505,18 @@ export class ResearchOrchestrator {
         if (this.parameterRegistry && this.predictionEngine) {
             const alpha = this.parameterRegistry.get('prediction', 'ewmaAlpha');
             const beta = this.parameterRegistry.get('prediction', 'trendBeta');
-            if (alpha !== undefined || beta !== undefined) {
+            const minConf = this.parameterRegistry.get('prediction', 'minConfidence');
+            const minDP = this.parameterRegistry.get('prediction', 'minDataPoints');
+            const maxPred = this.parameterRegistry.get('prediction', 'maxPredictionsPerCycle');
+            const horizon = this.parameterRegistry.get('prediction', 'defaultHorizonMs');
+            if (alpha !== undefined || beta !== undefined || minConf !== undefined || minDP !== undefined || maxPred !== undefined || horizon !== undefined) {
                 this.predictionEngine.updateConfig({
                     ...(alpha !== undefined ? { ewmaAlpha: alpha } : {}),
                     ...(beta !== undefined ? { trendBeta: beta } : {}),
+                    ...(minConf !== undefined ? { minConfidence: minConf } : {}),
+                    ...(minDP !== undefined ? { minDataPoints: minDP } : {}),
+                    ...(maxPred !== undefined ? { maxPredictionsPerCycle: maxPred } : {}),
+                    ...(horizon !== undefined ? { defaultHorizonMs: horizon } : {}),
                 });
             }
         }
@@ -2888,6 +2959,15 @@ export class ResearchOrchestrator {
             }
             catch { /* checkpoint save should never break the cycle */ }
         }
+        // Adaptive Scheduling: record cycle outcome for interval optimization
+        if (this.adaptiveScheduler) {
+            this.adaptiveScheduler.recordOutcome({
+                insightsFound: insights.length,
+                rulesLearned: 0, // rules come from external learning engines
+                anomaliesDetected: anomalies.length,
+                durationMs: duration,
+            });
+        }
         // Step-profiling summary: log slow steps if any
         if (stepTimings.length > 0) {
             this.log.warn(`[orchestrator] Cycle #${this.cycleCount} slow steps: ${stepTimings.map(s => `${s.step}(${s.ms}ms)`).join(', ')}`);