@timmeck/brain-core 2.36.67 → 2.36.69

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;
@@ -113,6 +114,13 @@ export class ResearchOrchestrator {
     lastSuggestionsCycle = -1;
     /** Recent debate topic keys to prevent repeating the same debate. */
     recentDebateTopics = [];
+    // ── Desire Feedback Tracking ──────────────────────────────
+    /** Tracks outcomes per desire key: successes, failures, last result. */
+    desireOutcomes = new Map();
+    /** Category-level success rates for adaptive confidence. */
+    desireCategoryRates = new Map();
+    /** Desire keys currently being actuated by other brains (received via cross-brain). */
+    crossBrainActiveDesires = new Map();
     constructor(db, config, causalGraph) {
         this.db = db;
         this.brainName = config.brainName;
@@ -139,6 +147,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 +342,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();
@@ -365,6 +392,44 @@ export class ResearchOrchestrator {
     onCrossBrainEvent(sourceBrain, eventType, data = {}) {
         this.crossDomain.recordEvent(sourceBrain, eventType, data);
         this.anomalyDetective.recordMetric(`cross:${sourceBrain}:${eventType}`, 1);
+        // Handle cross-brain desire coordination signals
+        if (eventType === 'desire_active' && data.desireKey) {
+            this.onCrossBrainDesireSignal(sourceBrain, data.desireKey, data.priority ?? 0);
+        }
+        // Handle cross-brain debate perspective requests
+        if (eventType === 'debate_perspective_request' && data.question && this.debateEngine) {
+            try {
+                const perspective = this.debateEngine.generatePerspective(data.question);
+                // Send perspective back via signal
+                if (this.signalRouter) {
+                    this.signalRouter.emit({
+                        targetBrain: sourceBrain,
+                        signalType: 'debate_perspective_response',
+                        payload: {
+                            debateId: data.debateId,
+                            perspective: { brainName: perspective.brainName, position: perspective.position, confidence: perspective.confidence, relevance: perspective.relevance, arguments: perspective.arguments },
+                        },
+                        confidence: perspective.confidence,
+                    }).catch(() => { });
+                }
+            }
+            catch { /* debate engine not ready */ }
+        }
+        // Handle incoming debate perspective response — add to our debate
+        if (eventType === 'debate_perspective_response' && data.debateId && data.perspective && this.debateEngine) {
+            try {
+                const p = data.perspective;
+                this.debateEngine.addPerspective(data.debateId, {
+                    brainName: p.brainName ?? sourceBrain,
+                    position: p.position ?? '',
+                    confidence: p.confidence ?? 0,
+                    relevance: p.relevance ?? 0,
+                    arguments: p.arguments ?? [],
+                });
+                this.log.info(`[orchestrator] Added cross-brain perspective from ${sourceBrain} to debate #${data.debateId}`);
+            }
+            catch { /* debate may not exist */ }
+        }
     }
     /**
      * Hook into AutonomousResearchScheduler cycle completion.
@@ -1245,6 +1310,11 @@ export class ResearchOrchestrator {
                                 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 */ }
                     }
@@ -1389,25 +1459,57 @@ export class ResearchOrchestrator {
                 this.log.error(`[orchestrator] Emergence step error: ${err.message}`);
             }
         }
-        // 20. Internal Debate: periodically debate key findings to synthesize cross-engine wisdom
+        // 20. Internal + Cross-Brain Debate: debate key findings, solicit cross-brain perspectives
         if (this.debateEngine && this.cycleCount % this.reflectEvery === 0) {
-            ts?.emit('reflecting', 'reflecting', 'Initiating internal debate on recent findings...');
+            ts?.emit('reflecting', 'reflecting', 'Initiating debate on recent findings...');
             try {
-                // Pick a debate topic from recent attention or agenda
                 const topic = this.pickDebateTopic();
                 if (topic) {
                     const debate = this.debateEngine.startDebate(topic);
+                    // Solicit cross-brain perspectives via SignalRouter
+                    if (this.signalRouter) {
+                        const peers = ['brain', 'trading-brain', 'marketing-brain'].filter(b => b !== this.brainName);
+                        for (const peer of peers) {
+                            try {
+                                this.signalRouter.emit({
+                                    targetBrain: peer,
+                                    signalType: 'debate_perspective_request',
+                                    payload: { debateId: debate.id, question: topic },
+                                    confidence: 0.7,
+                                }).catch(() => { });
+                            }
+                            catch { /* peer offline */ }
+                        }
+                    }
                     const synthesis = this.debateEngine.synthesize(debate.id);
-                    if (synthesis && synthesis.conflicts.length > 0) {
-                        this.journal.write({
-                            type: 'discovery',
-                            title: `Debate: ${topic.substring(0, 80)}`,
-                            content: `Internal debate with ${synthesis.participantCount} perspective(s). ${synthesis.conflicts.length} conflict(s). Resolution: ${synthesis.resolution}`,
-                            tags: [this.brainName, 'debate', 'synthesis'],
-                            references: [],
-                            significance: synthesis.conflicts.length > 2 ? 'notable' : 'routine',
-                            data: { debate: { question: topic, synthesis } },
-                        });
+                    if (synthesis) {
+                        // Journal the debate
+                        if (synthesis.conflicts.length > 0) {
+                            this.journal.write({
+                                type: 'discovery',
+                                title: `Debate: ${topic.substring(0, 80)}`,
+                                content: `Debate with ${synthesis.participantCount} perspective(s). ${synthesis.conflicts.length} conflict(s). Resolution: ${synthesis.resolution}`,
+                                tags: [this.brainName, 'debate', 'synthesis'],
+                                references: [],
+                                significance: synthesis.conflicts.length > 2 ? 'notable' : 'routine',
+                                data: { debate: { question: topic, synthesis } },
+                            });
+                        }
+                        // Convert recommendations to ActionBridge proposals
+                        if (this.actionBridge && synthesis.recommendations.length > 0) {
+                            for (const rec of synthesis.recommendations.slice(0, 2)) {
+                                this.actionBridge.propose({
+                                    source: 'research',
+                                    type: 'create_goal',
+                                    title: `Debate recommendation: ${rec.substring(0, 70)}`,
+                                    description: `From debate "${topic.substring(0, 80)}": ${rec}`,
+                                    confidence: synthesis.confidence,
+                                    payload: { debateId: debate.id, recommendation: rec },
+                                });
+                            }
+                        }
+                        // Auto-close the debate after synthesis
+                        this.debateEngine.closeDebate(debate.id);
                     }
                     ts?.emit('reflecting', 'reflecting', `Debate on "${topic.substring(0, 40)}...": ${synthesis?.conflicts.length ?? 0} conflicts, confidence=${((synthesis?.confidence ?? 0) * 100).toFixed(0)}%`, synthesis && synthesis.conflicts.length > 0 ? 'notable' : 'routine');
                 }
@@ -1561,14 +1663,16 @@ export class ResearchOrchestrator {
                 this.log.warn(`[orchestrator] Step 24 error: ${err.message}`);
             }
         }
-        // Step 25: Advocatus Diaboli — challenge a random confirmed principle (every 10 cycles)
+        // Step 25: Advocatus Diaboli — challenge weakest principle + adjust confidence (every 10 cycles)
         if (this.debateEngine && this.cycleCount % 10 === 0) {
             try {
                 ts?.emit('orchestrator', 'reflecting', 'Step 25: Challenging a principle...', 'routine');
                 const principles = this.knowledgeDistiller.getPrinciples(undefined, 20);
                 if (principles.length > 0) {
-                    const randomPrinciple = principles[Math.floor(Math.random() * principles.length)];
-                    const challenge = this.debateEngine.challenge(randomPrinciple.statement);
+                    // Target weakest principles first (lowest confidence), not random
+                    const sorted = [...principles].sort((a, b) => a.confidence - b.confidence);
+                    const targetPrinciple = sorted[0];
+                    const challenge = this.debateEngine.challenge(targetPrinciple.statement);
                     this.journal.write({
                         type: 'reflection',
                         title: `Principle challenged: resilience=${(challenge.resilienceScore * 100).toFixed(0)}% → ${challenge.outcome}`,
@@ -1578,6 +1682,24 @@ export class ResearchOrchestrator {
                         significance: challenge.outcome === 'disproved' ? 'notable' : 'routine',
                         data: { challenge },
                     });
+                    // Actually adjust principle confidence based on challenge outcome
+                    if (challenge.principleId !== null) {
+                        const principleIdStr = String(challenge.principleId);
+                        if (challenge.outcome === 'disproved') {
+                            // Disproved → remove principle entirely
+                            this.knowledgeDistiller.removePrinciple(principleIdStr);
+                            this.log.info(`[orchestrator] Step 25: Principle "${targetPrinciple.statement.substring(0, 50)}" REMOVED (disproved)`);
+                        }
+                        else if (challenge.outcome === 'weakened') {
+                            // Weakened → reduce confidence by 30%
+                            this.knowledgeDistiller.adjustPrincipleConfidence(principleIdStr, 0.7);
+                            this.log.info(`[orchestrator] Step 25: Principle confidence reduced by 30% (weakened)`);
+                        }
+                        else if (challenge.outcome === 'survived') {
+                            // Survived → slight boost (+10%)
+                            this.knowledgeDistiller.adjustPrincipleConfidence(principleIdStr, 1.1);
+                        }
+                    }
                 }
                 if (this.metaCognitionLayer)
                     this.metaCognitionLayer.recordStep('advocatus_diaboli', this.cycleCount, { insights: 1 });
@@ -2768,12 +2890,42 @@ export class ResearchOrchestrator {
             }
         }
         // Step 64: DesireActuator — convert top desire to action (every 15 cycles)
+        //  Fix 1: Feedback-loop — deprioritize failed desires, boost successful ones
+        //  Fix 2: Cross-brain coordination — skip desires already active in other brains
+        //  Fix 3: Adaptive confidence — use category success rate instead of static priority/10
         if (this.actionBridge && this.cycleCount - this.lastDesireActuationCycle >= 15) {
             try {
                 const desires = this.getDesires();
-                const topDesire = desires.find(d => d.priority >= 5);
+                // Apply feedback adjustments to priorities
+                const adjusted = desires.map(d => {
+                    const outcome = this.desireOutcomes.get(d.key);
+                    let adjustedPriority = d.priority;
+                    if (outcome) {
+                        // Deprioritize desires that keep failing (−2 per failure, +1 per success, floor 0)
+                        adjustedPriority = Math.max(0, d.priority + outcome.successes - outcome.failures * 2);
+                        // If failed 3+ times consecutively, hard suppress below threshold
+                        if (outcome.failures >= 3 && outcome.lastResult === 'failure') {
+                            adjustedPriority = Math.min(adjustedPriority, 2);
+                            this.log.info(`[orchestrator] Step 64: Desire "${d.key}" suppressed (${outcome.failures} consecutive failures)`);
+                        }
+                    }
+                    return { ...d, adjustedPriority };
+                });
+                // Re-sort by adjusted priority
+                adjusted.sort((a, b) => b.adjustedPriority - a.adjustedPriority);
+                // Find top desire that passes threshold AND isn't already active in another brain
+                const topDesire = adjusted.find(d => {
+                    if (d.adjustedPriority < 5)
+                        return false;
+                    const crossActive = this.crossBrainActiveDesires.get(d.key);
+                    if (crossActive && this.cycleCount - crossActive.cycle < 30) {
+                        this.log.info(`[orchestrator] Step 64: Skipping "${d.key}" — active in ${crossActive.brain}`);
+                        return false;
+                    }
+                    return true;
+                });
                 if (topDesire) {
-                    ts?.emit('desire', 'analyzing', `Step 64: Actuating desire "${topDesire.key}" (P${topDesire.priority})...`, 'notable');
+                    ts?.emit('desire', 'analyzing', `Step 64: Actuating desire "${topDesire.key}" (P${topDesire.adjustedPriority})...`, 'notable');
                     // Map desire key → action type
                     let actionType = 'create_goal';
                     if (topDesire.key.startsWith('contradiction_')) {
@@ -2782,25 +2934,50 @@ export class ResearchOrchestrator {
                     else if (topDesire.key.startsWith('no_predictions') || topDesire.key.startsWith('low_accuracy')) {
                         actionType = 'adjust_parameter';
                     }
+                    // Adaptive confidence: use category success rate if available
+                    const category = this.desireKeyToCategory(topDesire.key);
+                    const categoryRate = this.desireCategoryRates.get(category);
+                    let confidence;
+                    if (categoryRate && categoryRate.total >= 3) {
+                        // Blend: 60% category success rate + 40% priority-based
+                        const rateComponent = categoryRate.successes / categoryRate.total;
+                        const priorityComponent = Math.min(topDesire.adjustedPriority / 10, 0.9);
+                        confidence = Math.min(rateComponent * 0.6 + priorityComponent * 0.4, 0.9);
+                    }
+                    else {
+                        confidence = Math.min(topDesire.adjustedPriority / 10, 0.9);
+                    }
                     const actionId = this.actionBridge.propose({
                         source: 'desire',
                         type: actionType,
                         title: `Desire: ${topDesire.suggestion.substring(0, 80)}`,
                         description: topDesire.suggestion,
-                        confidence: Math.min(topDesire.priority / 10, 0.9),
-                        payload: { desireKey: topDesire.key, priority: topDesire.priority, alternatives: topDesire.alternatives },
+                        confidence,
+                        payload: { desireKey: topDesire.key, priority: topDesire.adjustedPriority, category, alternatives: topDesire.alternatives },
                     });
                     if (actionId > 0) {
-                        this.log.info(`[orchestrator] Step 64: Desire "${topDesire.key}" → Action #${actionId} (${actionType})`);
+                        this.log.info(`[orchestrator] Step 64: Desire "${topDesire.key}" → Action #${actionId} (${actionType}, conf=${confidence.toFixed(2)})`);
                         this.journal.write({
                             title: `Desire Actuation: ${topDesire.key}`,
-                            content: `Converted desire (P${topDesire.priority}) to ${actionType} action #${actionId}: ${topDesire.suggestion}`,
+                            content: `Converted desire (P${topDesire.adjustedPriority}, conf=${confidence.toFixed(2)}) to ${actionType} action #${actionId}: ${topDesire.suggestion}`,
                             type: 'insight',
                             significance: 'notable',
                             tags: [this.brainName, 'desire', 'actuation'],
                             references: [],
-                            data: { desireKey: topDesire.key, actionId, actionType },
+                            data: { desireKey: topDesire.key, actionId, actionType, adjustedPriority: topDesire.adjustedPriority, confidence },
                         });
+                        // Broadcast to other brains that we're working on this desire
+                        if (this.signalRouter) {
+                            const peers = ['brain', 'trading-brain', 'marketing-brain'].filter(b => b !== this.brainName);
+                            for (const peer of peers) {
+                                this.signalRouter.emit({
+                                    targetBrain: peer,
+                                    signalType: 'desire_active',
+                                    payload: { desireKey: topDesire.key, priority: topDesire.adjustedPriority },
+                                    confidence,
+                                }).catch(() => { });
+                            }
+                        }
                     }
                     this.lastDesireActuationCycle = this.cycleCount;
                 }
@@ -2810,6 +2987,7 @@ export class ResearchOrchestrator {
             }
         }
         // Step 65: Action-Outcome Review (every 20 cycles)
+        //  Enhanced: Feed desire outcomes back into desireOutcomes + desireCategoryRates
         if (this.actionBridge && this.cycleCount % 20 === 0) {
             try {
                 const history = this.actionBridge.getHistory(10);
@@ -2817,7 +2995,7 @@ export class ResearchOrchestrator {
                 const recentFailed = history.filter(a => a.status === 'failed' || (a.outcome && !a.outcome.success));
                 if (recentCompleted.length > 0 || recentFailed.length > 0) {
                     ts?.emit('orchestrator', 'reflecting', `Step 65: Reviewing ${recentCompleted.length} successes, ${recentFailed.length} failures`, 'routine');
-                    // Success → journal lesson learned
+                    // Success → journal lesson learned + desire feedback
                     for (const action of recentCompleted.slice(0, 3)) {
                         const lesson = action.outcome?.learnedLesson ?? `Action "${action.title}" succeeded`;
                         this.journal.write({
@@ -2829,8 +3007,19 @@ export class ResearchOrchestrator {
                             references: [],
                             data: { actionId: action.id, type: action.type, source: action.source },
                         });
+                        // Feed success back into desire tracking
+                        if (action.source === 'desire') {
+                            const desireKey = action.payload.desireKey;
+                            const category = action.payload.category;
+                            if (desireKey) {
+                                this.recordDesireOutcome(desireKey, 'success');
+                            }
+                            if (category) {
+                                this.recordDesireCategoryOutcome(category, true);
+                            }
+                        }
                     }
-                    // Failure → journal + hypothesis rejection
+                    // Failure → journal + desire feedback
                     for (const action of recentFailed.slice(0, 3)) {
                         this.journal.write({
                             title: `Action Failed: ${action.title}`,
@@ -2841,6 +3030,17 @@ export class ResearchOrchestrator {
                             references: [],
                             data: { actionId: action.id, type: action.type, source: action.source },
                         });
+                        // Feed failure back into desire tracking
+                        if (action.source === 'desire') {
+                            const desireKey = action.payload.desireKey;
+                            const category = action.payload.category;
+                            if (desireKey) {
+                                this.recordDesireOutcome(desireKey, 'failure');
+                            }
+                            if (category) {
+                                this.recordDesireCategoryOutcome(category, false);
+                            }
+                        }
                     }
                     if (this.metaCognitionLayer) {
                         this.metaCognitionLayer.recordStep('action_outcome_review', this.cycleCount, {
@@ -2934,6 +3134,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(', ')}`);
@@ -3337,6 +3546,69 @@ export class ResearchOrchestrator {
         }
         return result;
     }
+    // ── Desire Feedback Helpers ──────────────────────────────
+    /** Record a desire outcome (success or failure) for feedback-loop. */
+    recordDesireOutcome(desireKey, result) {
+        const existing = this.desireOutcomes.get(desireKey) ?? { successes: 0, failures: 0, lastResult: result, lastCycle: 0 };
+        if (result === 'success') {
+            existing.successes++;
+        }
+        else {
+            existing.failures++;
+        }
+        existing.lastResult = result;
+        existing.lastCycle = this.cycleCount;
+        this.desireOutcomes.set(desireKey, existing);
+        this.log.info(`[orchestrator] Desire feedback: "${desireKey}" → ${result} (${existing.successes}S/${existing.failures}F)`);
+    }
+    /** Record category-level outcome for adaptive confidence. */
+    recordDesireCategoryOutcome(category, success) {
+        const existing = this.desireCategoryRates.get(category) ?? { successes: 0, total: 0 };
+        existing.total++;
+        if (success)
+            existing.successes++;
+        this.desireCategoryRates.set(category, existing);
+    }
+    /** Map a desire key to a broad category for confidence tracking. */
+    desireKeyToCategory(key) {
+        if (key.startsWith('no_predictions') || key.startsWith('low_accuracy'))
+            return 'prediction';
+        if (key.startsWith('contradiction_'))
+            return 'contradiction';
+        if (key.startsWith('curiosity_gap_'))
+            return 'curiosity';
+        if (key.startsWith('no_knowledge'))
+            return 'knowledge';
+        if (key.startsWith('pending_transfers') || key.startsWith('want_cross_brain'))
+            return 'cross_brain';
+        if (key.startsWith('deep_dive_'))
+            return 'deep_dive';
+        return 'general';
+    }
+    /** Handle incoming cross-brain desire signal. */
+    onCrossBrainDesireSignal(brain, desireKey, priority) {
+        this.crossBrainActiveDesires.set(desireKey, { brain, priority, cycle: this.cycleCount });
+        this.log.info(`[orchestrator] Cross-brain desire received: "${desireKey}" from ${brain} (P${priority})`);
+        // Clean up stale entries (older than 60 cycles)
+        for (const [key, entry] of this.crossBrainActiveDesires) {
+            if (this.cycleCount - entry.cycle > 60) {
+                this.crossBrainActiveDesires.delete(key);
+            }
+        }
+    }
+    /** Get desire feedback stats for monitoring. */
+    getDesireFeedbackStats() {
+        const outcomes = [...this.desireOutcomes.entries()].map(([key, v]) => ({
+            key, successes: v.successes, failures: v.failures, lastResult: v.lastResult,
+        }));
+        const categoryRates = [...this.desireCategoryRates.entries()].map(([category, v]) => ({
+            category, successRate: v.total > 0 ? v.successes / v.total : 0, total: v.total,
+        }));
+        const crossBrainActive = [...this.crossBrainActiveDesires.entries()].map(([key, v]) => ({
+            key, brain: v.brain, priority: v.priority,
+        }));
+        return { outcomes, categoryRates, crossBrainActive };
+    }
     /** Get structured self-improvement desires with priority and alternatives. */
     getDesires() {
         const raw = [];