@timmeck/brain-core 2.23.0 → 2.25.0

package/dist/debate/debate-engine.d.ts

@@ -0,0 +1,137 @@
+import type Database from 'better-sqlite3';
+import type { ThoughtStream } from '../consciousness/thought-stream.js';
+import type { KnowledgeDistiller } from '../research/knowledge-distiller.js';
+import type { HypothesisEngine } from '../hypothesis/engine.js';
+import type { ResearchJournal } from '../research/journal.js';
+import type { AnomalyDetective } from '../research/anomaly-detective.js';
+import type { PredictionEngine } from '../prediction/prediction-engine.js';
+import type { NarrativeEngine } from '../narrative/narrative-engine.js';
+export interface DebateEngineConfig {
+    brainName: string;
+    /** Domain description for this brain (e.g. "error tracking and code intelligence"). */
+    domainDescription?: string;
+}
+export interface DebateDataSources {
+    knowledgeDistiller?: KnowledgeDistiller;
+    hypothesisEngine?: HypothesisEngine;
+    journal?: ResearchJournal;
+    anomalyDetective?: AnomalyDetective;
+    predictionEngine?: PredictionEngine;
+    narrativeEngine?: NarrativeEngine;
+}
+export interface Debate {
+    id?: number;
+    question: string;
+    status: DebateStatus;
+    perspectives: DebatePerspective[];
+    synthesis: DebateSynthesis | null;
+    created_at?: string;
+    closed_at?: string;
+}
+export type DebateStatus = 'open' | 'deliberating' | 'synthesized' | 'closed';
+export interface DebatePerspective {
+    id?: number;
+    debateId?: number;
+    brainName: string;
+    position: string;
+    arguments: DebateArgument[];
+    confidence: number;
+    relevance: number;
+    created_at?: string;
+}
+export interface DebateArgument {
+    claim: string;
+    evidence: string[];
+    source: 'principle' | 'hypothesis' | 'journal' | 'prediction' | 'anomaly' | 'narrative';
+    strength: number;
+}
+export interface DebateSynthesis {
+    consensus: string | null;
+    conflicts: DebateConflict[];
+    resolution: string;
+    confidence: number;
+    recommendations: string[];
+    participantCount: number;
+}
+export interface DebateConflict {
+    perspectiveA: string;
+    perspectiveB: string;
+    claimA: string;
+    claimB: string;
+    resolution: 'a_wins' | 'b_wins' | 'compromise' | 'unresolved';
+    reason: string;
+}
+export interface DebateEngineStatus {
+    totalDebates: number;
+    openDebates: number;
+    synthesizedDebates: number;
+    avgConfidence: number;
+    avgParticipants: number;
+    recentDebates: Debate[];
+    uptime: number;
+}
+export declare function runDebateMigration(db: Database.Database): void;
+export declare class DebateEngine {
+    private readonly db;
+    private readonly config;
+    private readonly log;
+    private ts;
+    private sources;
+    private startTime;
+    private readonly stmtInsertDebate;
+    private readonly stmtUpdateDebateStatus;
+    private readonly stmtSetSynthesis;
+    private readonly stmtInsertPerspective;
+    private readonly stmtGetDebate;
+    private readonly stmtGetPerspectives;
+    private readonly stmtListDebates;
+    private readonly stmtTotalDebates;
+    private readonly stmtOpenDebates;
+    private readonly stmtSynthesizedDebates;
+    constructor(db: Database.Database, config: DebateEngineConfig);
+    setThoughtStream(stream: ThoughtStream): void;
+    setDataSources(sources: DebateDataSources): void;
+    /**
+     * Start a new debate on a question.
+     * Immediately generates this brain's perspective and adds it.
+     */
+    startDebate(question: string): Debate;
+    /**
+     * Generate this brain's perspective on a question based on local knowledge.
+     * Searches principles, hypotheses, journal, anomalies, predictions.
+     */
+    generatePerspective(question: string): DebatePerspective;
+    /**
+     * Add a perspective (from this or another brain) to an existing debate.
+     */
+    addPerspective(debateId: number, perspective: DebatePerspective): void;
+    /**
+     * Synthesize all perspectives in a debate: find conflicts, build consensus.
+     */
+    synthesize(debateId: number): DebateSynthesis | null;
+    getDebate(id: number): Debate | null;
+    listDebates(limit?: number): Debate[];
+    getStatus(): DebateEngineStatus;
+    /**
+     * Find conflicts between perspectives.
+     * Two arguments conflict if they're about the same topic but make opposite claims.
+     */
+    private findConflicts;
+    /**
+     * Detect if two arguments conflict.
+     * Heuristic: same topic keywords but one has "warning" / negation.
+     */
+    private argumentsConflict;
+    /**
+     * Build consensus from perspectives weighted by confidence × relevance.
+     */
+    private buildConsensus;
+    private generateRecommendations;
+    private extractKeywords;
+    private isRelevant;
+    private computeRelevance;
+    private generatePosition;
+    private loadPerspectives;
+    private toDebate;
+    private toPerspective;
+}

package/dist/debate/debate-engine.js

@@ -0,0 +1,540 @@
+import { getLogger } from '../utils/logger.js';
+// ── Migration ───────────────────────────────────────────
+export function runDebateMigration(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS debates (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      question TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'open',
+      synthesis_json TEXT,
+      created_at TEXT DEFAULT (datetime('now')),
+      closed_at TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_debates_status ON debates(status);
+
+    CREATE TABLE IF NOT EXISTS debate_perspectives (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      debate_id INTEGER NOT NULL,
+      brain_name TEXT NOT NULL,
+      position TEXT NOT NULL,
+      arguments_json TEXT NOT NULL DEFAULT '[]',
+      confidence REAL NOT NULL DEFAULT 0,
+      relevance REAL NOT NULL DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now')),
+      FOREIGN KEY (debate_id) REFERENCES debates(id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_debate_perspectives_debate ON debate_perspectives(debate_id);
+  `);
+}
+// ── Engine ──────────────────────────────────────────────
+export class DebateEngine {
+    db;
+    config;
+    log = getLogger();
+    ts = null;
+    sources = {};
+    startTime = Date.now();
+    // Prepared statements
+    stmtInsertDebate;
+    stmtUpdateDebateStatus;
+    stmtSetSynthesis;
+    stmtInsertPerspective;
+    stmtGetDebate;
+    stmtGetPerspectives;
+    stmtListDebates;
+    stmtTotalDebates;
+    stmtOpenDebates;
+    stmtSynthesizedDebates;
+    constructor(db, config) {
+        this.db = db;
+        this.config = {
+            brainName: config.brainName,
+            domainDescription: config.domainDescription ?? config.brainName,
+        };
+        runDebateMigration(db);
+        this.stmtInsertDebate = db.prepare('INSERT INTO debates (question, status) VALUES (?, ?)');
+        this.stmtUpdateDebateStatus = db.prepare('UPDATE debates SET status = ?, closed_at = CASE WHEN ? = \'closed\' THEN datetime(\'now\') ELSE closed_at END WHERE id = ?');
+        this.stmtSetSynthesis = db.prepare('UPDATE debates SET synthesis_json = ?, status = \'synthesized\' WHERE id = ?');
+        this.stmtInsertPerspective = db.prepare('INSERT INTO debate_perspectives (debate_id, brain_name, position, arguments_json, confidence, relevance) VALUES (?, ?, ?, ?, ?, ?)');
+        this.stmtGetDebate = db.prepare('SELECT * FROM debates WHERE id = ?');
+        this.stmtGetPerspectives = db.prepare('SELECT * FROM debate_perspectives WHERE debate_id = ? ORDER BY confidence DESC');
+        this.stmtListDebates = db.prepare('SELECT * FROM debates ORDER BY id DESC LIMIT ?');
+        this.stmtTotalDebates = db.prepare('SELECT COUNT(*) as cnt FROM debates');
+        this.stmtOpenDebates = db.prepare('SELECT COUNT(*) as cnt FROM debates WHERE status = \'open\' OR status = \'deliberating\'');
+        this.stmtSynthesizedDebates = db.prepare('SELECT COUNT(*) as cnt FROM debates WHERE status = \'synthesized\' OR status = \'closed\'');
+        this.log.debug(`[DebateEngine] Initialized for ${this.config.brainName}`);
+    }
+    // ── Setters ──────────────────────────────────────────
+    setThoughtStream(stream) { this.ts = stream; }
+    setDataSources(sources) {
+        this.sources = sources;
+    }
+    // ── Core: Start a Debate ─────────────────────────────
+    /**
+     * Start a new debate on a question.
+     * Immediately generates this brain's perspective and adds it.
+     */
+    startDebate(question) {
+        this.ts?.emit('debate', 'reflecting', `New debate: "${question.substring(0, 60)}..."`, 'notable');
+        const info = this.stmtInsertDebate.run(question, 'open');
+        const debateId = Number(info.lastInsertRowid);
+        // Generate and add this brain's perspective
+        const perspective = this.generatePerspective(question);
+        this.addPerspective(debateId, perspective);
+        this.stmtUpdateDebateStatus.run('deliberating', 'deliberating', debateId);
+        return this.getDebate(debateId);
+    }
+    // ── Core: Generate Perspective ────────────────────────
+    /**
+     * Generate this brain's perspective on a question based on local knowledge.
+     * Searches principles, hypotheses, journal, anomalies, predictions.
+     */
+    generatePerspective(question) {
+        this.ts?.emit('reflecting', 'analyzing', `Forming perspective on: "${question.substring(0, 50)}..."`, 'routine');
+        const args = [];
+        const keywords = this.extractKeywords(question);
+        // 1. Arguments from principles
+        if (this.sources.knowledgeDistiller) {
+            try {
+                const pkg = this.sources.knowledgeDistiller.getPackage(this.config.brainName);
+                for (const p of pkg.principles) {
+                    if (this.isRelevant(p.statement, keywords)) {
+                        args.push({
+                            claim: p.statement,
+                            evidence: [`principle:${p.id}`, `confidence:${p.confidence.toFixed(2)}`, `samples:${p.sample_size}`],
+                            source: 'principle',
+                            strength: p.confidence * Math.min(1, p.sample_size / 10),
+                        });
+                    }
+                }
+                // Also check anti-patterns
+                for (const ap of pkg.anti_patterns) {
+                    if (this.isRelevant(ap.statement, keywords)) {
+                        args.push({
+                            claim: `Warning: ${ap.statement}`,
+                            evidence: [`anti_pattern`, `confidence:${ap.confidence.toFixed(2)}`],
+                            source: 'principle',
+                            strength: ap.confidence * 0.8,
+                        });
+                    }
+                }
+            }
+            catch { /* not wired */ }
+        }
+        // 2. Arguments from hypotheses
+        if (this.sources.hypothesisEngine) {
+            try {
+                const confirmed = this.sources.hypothesisEngine.list('confirmed', 30);
+                const testing = this.sources.hypothesisEngine.list('testing', 20);
+                for (const h of [...confirmed, ...testing]) {
+                    if (this.isRelevant(h.statement, keywords)) {
+                        const statusWeight = h.status === 'confirmed' ? 1.0 : 0.6;
+                        args.push({
+                            claim: h.statement,
+                            evidence: [`hypothesis:${h.id}`, `status:${h.status}`, `p_value:${h.p_value.toFixed(4)}`],
+                            source: 'hypothesis',
+                            strength: h.confidence * statusWeight,
+                        });
+                    }
+                }
+            }
+            catch { /* not wired */ }
+        }
+        // 3. Arguments from journal
+        if (this.sources.journal) {
+            try {
+                const entries = this.sources.journal.search(question, 15);
+                for (const e of entries) {
+                    if (e.significance === 'breakthrough' || e.significance === 'notable') {
+                        args.push({
+                            claim: e.title,
+                            evidence: [`journal:${e.id}`, `type:${e.type}`, `significance:${e.significance}`],
+                            source: 'journal',
+                            strength: e.significance === 'breakthrough' ? 0.9 : 0.6,
+                        });
+                    }
+                }
+            }
+            catch { /* not wired */ }
+        }
+        // 4. Arguments from anomalies
+        if (this.sources.anomalyDetective) {
+            try {
+                const anomalies = this.sources.anomalyDetective.getAnomalies(undefined, 30);
+                for (const a of anomalies) {
+                    if (this.isRelevant(`${a.title} ${a.metric}`, keywords)) {
+                        args.push({
+                            claim: `Anomaly detected: ${a.title}`,
+                            evidence: [`anomaly:${a.id}`, `deviation:${a.deviation.toFixed(2)}`, `severity:${a.severity}`],
+                            source: 'anomaly',
+                            strength: Math.min(1, 0.3 + Math.abs(a.deviation) * 0.1),
+                        });
+                    }
+                }
+            }
+            catch { /* not wired */ }
+        }
+        // 5. Arguments from predictions
+        if (this.sources.predictionEngine) {
+            try {
+                const summary = this.sources.predictionEngine.getSummary();
+                if (summary.accuracy_rate > 0 && this.isRelevant(JSON.stringify(summary), keywords)) {
+                    args.push({
+                        claim: `Prediction track record: ${(summary.accuracy_rate * 100).toFixed(0)}% accuracy over ${summary.total_predictions} predictions`,
+                        evidence: [`predictions:${summary.total_predictions}`, `accuracy:${summary.accuracy_rate.toFixed(2)}`],
+                        source: 'prediction',
+                        strength: summary.accuracy_rate,
+                    });
+                }
+            }
+            catch { /* not wired */ }
+        }
+        // 6. Narrative explanation
+        if (this.sources.narrativeEngine) {
+            try {
+                const explanation = this.sources.narrativeEngine.explain(question);
+                if (explanation.details.length > 0) {
+                    args.push({
+                        claim: explanation.summary.substring(0, 200),
+                        evidence: [`narrative:${explanation.topic}`],
+                        source: 'narrative',
+                        strength: explanation.confidence,
+                    });
+                }
+            }
+            catch { /* not wired */ }
+        }
+        // Sort by strength
+        args.sort((a, b) => b.strength - a.strength);
+        // Compute overall confidence and relevance
+        const confidence = args.length > 0
+            ? args.reduce((sum, a) => sum + a.strength, 0) / args.length
+            : 0;
+        const relevance = this.computeRelevance(question, args);
+        // Generate position: summarize top arguments
+        const position = this.generatePosition(question, args);
+        this.ts?.emit('reflecting', 'analyzing', `Perspective formed: ${args.length} arguments, confidence=${(confidence * 100).toFixed(0)}%`, 'routine');
+        return {
+            brainName: this.config.brainName,
+            position,
+            arguments: args.slice(0, 10), // Top 10
+            confidence,
+            relevance,
+        };
+    }
+    // ── Core: Add External Perspective ────────────────────
+    /**
+     * Add a perspective (from this or another brain) to an existing debate.
+     */
+    addPerspective(debateId, perspective) {
+        this.stmtInsertPerspective.run(debateId, perspective.brainName, perspective.position, JSON.stringify(perspective.arguments), perspective.confidence, perspective.relevance);
+        this.ts?.emit('debate', 'reflecting', `${perspective.brainName} added perspective (confidence=${(perspective.confidence * 100).toFixed(0)}%)`, 'routine');
+    }
+    // ── Core: Synthesize ──────────────────────────────────
+    /**
+     * Synthesize all perspectives in a debate: find conflicts, build consensus.
+     */
+    synthesize(debateId) {
+        const debate = this.getDebate(debateId);
+        if (!debate)
+            return null;
+        if (debate.perspectives.length === 0)
+            return null;
+        this.ts?.emit('debate', 'analyzing', `Synthesizing debate: "${debate.question.substring(0, 40)}..." (${debate.perspectives.length} perspectives)`, 'notable');
+        // 1. Find conflicts between perspectives
+        const conflicts = this.findConflicts(debate.perspectives);
+        // 2. Build weighted consensus
+        const consensus = this.buildConsensus(debate.perspectives, conflicts);
+        // 3. Generate recommendations
+        const recommendations = this.generateRecommendations(debate.perspectives, conflicts);
+        // 4. Compute overall confidence
+        const totalWeight = debate.perspectives.reduce((s, p) => s + p.confidence * p.relevance, 0);
+        const totalRelevance = debate.perspectives.reduce((s, p) => s + p.relevance, 0);
+        const avgConfidence = totalRelevance > 0 ? totalWeight / totalRelevance : 0;
+        const synthesis = {
+            consensus,
+            conflicts,
+            resolution: conflicts.length === 0
+                ? 'All perspectives align — strong consensus.'
+                : `${conflicts.length} conflict(s) found. ${conflicts.filter(c => c.resolution !== 'unresolved').length} resolved.`,
+            confidence: avgConfidence,
+            recommendations,
+            participantCount: debate.perspectives.length,
+        };
+        // Persist
+        this.stmtSetSynthesis.run(JSON.stringify(synthesis), debateId);
+        this.ts?.emit('debate', 'discovering', `Debate synthesized: ${conflicts.length} conflicts, confidence=${(avgConfidence * 100).toFixed(0)}%`, conflicts.length > 0 ? 'notable' : 'routine');
+        return synthesis;
+    }
+    // ── Query Methods ────────────────────────────────────
+    getDebate(id) {
+        const row = this.stmtGetDebate.get(id);
+        if (!row)
+            return null;
+        const perspectives = this.loadPerspectives(id);
+        return this.toDebate(row, perspectives);
+    }
+    listDebates(limit = 20) {
+        const rows = this.stmtListDebates.all(limit);
+        return rows.map(r => {
+            const perspectives = this.loadPerspectives(r.id);
+            return this.toDebate(r, perspectives);
+        });
+    }
+    getStatus() {
+        const total = this.stmtTotalDebates.get().cnt;
+        const open = this.stmtOpenDebates.get().cnt;
+        const synthesized = this.stmtSynthesizedDebates.get().cnt;
+        const recent = this.listDebates(5);
+        const syntheses = recent
+            .filter(d => d.synthesis)
+            .map(d => d.synthesis);
+        const avgConfidence = syntheses.length > 0
+            ? syntheses.reduce((s, syn) => s + syn.confidence, 0) / syntheses.length
+            : 0;
+        const avgParticipants = syntheses.length > 0
+            ? syntheses.reduce((s, syn) => s + syn.participantCount, 0) / syntheses.length
+            : 0;
+        return {
+            totalDebates: total,
+            openDebates: open,
+            synthesizedDebates: synthesized,
+            avgConfidence,
+            avgParticipants,
+            recentDebates: recent,
+            uptime: Date.now() - this.startTime,
+        };
+    }
+    // ── Private: Conflict Detection ────────────────────────
+    /**
+     * Find conflicts between perspectives.
+     * Two arguments conflict if they're about the same topic but make opposite claims.
+     */
+    findConflicts(perspectives) {
+        const conflicts = [];
+        for (let i = 0; i < perspectives.length; i++) {
+            for (let j = i + 1; j < perspectives.length; j++) {
+                const pA = perspectives[i];
+                const pB = perspectives[j];
+                // Compare each argument pair
+                for (const argA of pA.arguments) {
+                    for (const argB of pB.arguments) {
+                        if (this.argumentsConflict(argA, argB)) {
+                            // Resolve: higher confidence × relevance wins
+                            const weightA = pA.confidence * pA.relevance * argA.strength;
+                            const weightB = pB.confidence * pB.relevance * argB.strength;
+                            let resolution;
+                            let reason;
+                            if (Math.abs(weightA - weightB) < 0.1) {
+                                resolution = 'compromise';
+                                reason = `Both sides have similar weight (${weightA.toFixed(2)} vs ${weightB.toFixed(2)}). Consider both perspectives.`;
+                            }
+                            else if (weightA > weightB) {
+                                resolution = 'a_wins';
+                                reason = `${pA.brainName}'s argument is stronger (weight: ${weightA.toFixed(2)} vs ${weightB.toFixed(2)}) based on confidence and evidence.`;
+                            }
+                            else {
+                                resolution = 'b_wins';
+                                reason = `${pB.brainName}'s argument is stronger (weight: ${weightB.toFixed(2)} vs ${weightA.toFixed(2)}) based on confidence and evidence.`;
+                            }
+                            conflicts.push({
+                                perspectiveA: pA.brainName,
+                                perspectiveB: pB.brainName,
+                                claimA: argA.claim.substring(0, 150),
+                                claimB: argB.claim.substring(0, 150),
+                                resolution,
+                                reason,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return conflicts;
+    }
+    /**
+     * Detect if two arguments conflict.
+     * Heuristic: same topic keywords but one has "warning" / negation.
+     */
+    argumentsConflict(a, b) {
+        const wordsA = new Set(a.claim.toLowerCase().split(/\s+/).filter(w => w.length > 3));
+        const wordsB = new Set(b.claim.toLowerCase().split(/\s+/).filter(w => w.length > 3));
+        // Must have some topic overlap
+        let overlap = 0;
+        for (const w of wordsA)
+            if (wordsB.has(w))
+                overlap++;
+        const overlapRatio = overlap / Math.max(wordsA.size, wordsB.size, 1);
+        if (overlapRatio < 0.2)
+            return false;
+        // Check for opposing signals
+        const negations = ['not', 'never', 'warning', 'avoid', 'decrease', 'reduce', 'lower', 'bad', 'risk', 'danger'];
+        const hasNegA = negations.some(n => a.claim.toLowerCase().includes(n));
+        const hasNegB = negations.some(n => b.claim.toLowerCase().includes(n));
+        // One positive, one negative about same topic = conflict
+        if (hasNegA !== hasNegB)
+            return true;
+        // Different sources about same topic with very different strengths
+        if (a.source !== b.source && overlapRatio > 0.3 && Math.abs(a.strength - b.strength) > 0.4) {
+            return true;
+        }
+        return false;
+    }
+    // ── Private: Consensus Building ────────────────────────
+    /**
+     * Build consensus from perspectives weighted by confidence × relevance.
+     */
+    buildConsensus(perspectives, conflicts) {
+        if (perspectives.length === 0)
+            return null;
+        if (perspectives.length === 1)
+            return perspectives[0].position;
+        // Collect all non-conflicting claims
+        const conflictingClaims = new Set();
+        for (const c of conflicts) {
+            conflictingClaims.add(c.claimA.substring(0, 50));
+            conflictingClaims.add(c.claimB.substring(0, 50));
+        }
+        // Aggregate non-conflicting arguments by weight
+        const weightedClaims = [];
+        for (const p of perspectives) {
+            for (const arg of p.arguments) {
+                const key = arg.claim.substring(0, 50);
+                if (!conflictingClaims.has(key)) {
+                    weightedClaims.push({
+                        claim: arg.claim,
+                        weight: p.confidence * p.relevance * arg.strength,
+                        brain: p.brainName,
+                    });
+                }
+            }
+        }
+        weightedClaims.sort((a, b) => b.weight - a.weight);
+        // Build consensus from top claims
+        const topClaims = weightedClaims.slice(0, 5);
+        if (topClaims.length === 0) {
+            // Only conflicts, no agreement
+            return `No consensus reached. ${conflicts.length} conflicting viewpoints from ${perspectives.map(p => p.brainName).join(', ')}.`;
+        }
+        const parts = topClaims.map(c => c.claim);
+        const participants = [...new Set(perspectives.map(p => p.brainName))].join(', ');
+        return `Consensus from ${participants}: ${parts.join('. ')}.`;
+    }
+    // ── Private: Recommendations ──────────────────────────
+    generateRecommendations(perspectives, conflicts) {
+        const recs = [];
+        // High-confidence unanimous arguments → strong recommendation
+        const allArgs = perspectives.flatMap(p => p.arguments.map(a => ({ ...a, brain: p.brainName, pConfidence: p.confidence })));
+        // Find arguments that appear in multiple perspectives
+        const claimCounts = new Map();
+        for (const a of allArgs) {
+            const key = a.claim.substring(0, 60).toLowerCase();
+            const existing = claimCounts.get(key) ?? { count: 0, totalStrength: 0, brains: [] };
+            existing.count++;
+            existing.totalStrength += a.strength * a.pConfidence;
+            existing.brains.push(a.brain);
+            claimCounts.set(key, existing);
+        }
+        // Multi-brain agreement = strong recommendation
+        for (const [, info] of claimCounts) {
+            const uniqueBrains = [...new Set(info.brains)];
+            if (uniqueBrains.length > 1) {
+                recs.push(`Strong: ${uniqueBrains.join(' + ')} agree on this point (combined strength: ${info.totalStrength.toFixed(2)}).`);
+            }
+        }
+        // Unresolved conflicts → investigate
+        const unresolved = conflicts.filter(c => c.resolution === 'unresolved');
+        if (unresolved.length > 0) {
+            recs.push(`Investigate: ${unresolved.length} unresolved conflict(s) need more data.`);
+        }
+        // Low confidence → gather more evidence
+        const lowConf = perspectives.filter(p => p.confidence < 0.3);
+        if (lowConf.length > 0) {
+            recs.push(`Low confidence from ${lowConf.map(p => p.brainName).join(', ')} — more data needed in these domains.`);
+        }
+        // If no recommendations, note it
+        if (recs.length === 0) {
+            recs.push('All perspectives considered. Act on the consensus with measured confidence.');
+        }
+        return recs;
+    }
+    // ── Private: Helpers ──────────────────────────────────
+    extractKeywords(text) {
+        const stopwords = new Set([
+            'the', 'is', 'at', 'which', 'on', 'a', 'an', 'and', 'or', 'but', 'in',
+            'with', 'to', 'for', 'of', 'not', 'no', 'can', 'will', 'do', 'does',
+            'was', 'were', 'has', 'have', 'had', 'this', 'that', 'from', 'are',
+            'der', 'die', 'das', 'und', 'oder', 'aber', 'ist', 'sind', 'ein', 'eine',
+            'für', 'mit', 'auf', 'bei', 'nach', 'von', 'wie', 'was', 'wir', 'ich',
+            'warum', 'wann', 'wenn', 'als', 'auch', 'noch', 'nur', 'mehr', 'sehr',
+            'should', 'would', 'could', 'how', 'why', 'what', 'when', 'where', 'who',
+        ]);
+        return text.toLowerCase()
+            .split(/\s+/)
+            .filter(w => w.length > 2 && !stopwords.has(w))
+            .map(w => w.replace(/[^a-z0-9äöüß-]/g, ''))
+            .filter(w => w.length > 2);
+    }
+    isRelevant(text, keywords) {
+        const lower = text.toLowerCase();
+        const matches = keywords.filter(k => lower.includes(k));
+        return matches.length >= 1;
+    }
+    computeRelevance(question, args) {
+        if (args.length === 0)
+            return 0.1; // Minimal relevance
+        // More arguments = more relevant domain
+        const argScore = Math.min(1, args.length / 5);
+        // Higher average strength = more relevant
+        const avgStrength = args.reduce((s, a) => s + a.strength, 0) / args.length;
+        return (argScore * 0.5 + avgStrength * 0.5);
+    }
+    generatePosition(question, args) {
+        if (args.length === 0) {
+            return `${this.config.brainName} has limited knowledge about this topic.`;
+        }
+        const topArgs = args.slice(0, 3);
+        const domain = this.config.domainDescription ?? this.config.brainName;
+        const claims = topArgs.map(a => a.claim).join('; ');
+        return `From ${domain} perspective: ${claims}`;
+    }
+    loadPerspectives(debateId) {
+        const rows = this.stmtGetPerspectives.all(debateId);
+        return rows.map(r => this.toPerspective(r));
+    }
+    toDebate(row, perspectives) {
+        let synthesis = null;
+        try {
+            if (row.synthesis_json)
+                synthesis = JSON.parse(row.synthesis_json);
+        }
+        catch { /* ignore */ }
+        return {
+            id: row.id,
+            question: row.question,
+            status: row.status,
+            perspectives,
+            synthesis,
+            created_at: row.created_at,
+            closed_at: row.closed_at,
+        };
+    }
+    toPerspective(row) {
+        let args = [];
+        try {
+            args = JSON.parse(row.arguments_json || '[]');
+        }
+        catch { /* ignore */ }
+        return {
+            id: row.id,
+            debateId: row.debate_id,
+            brainName: row.brain_name,
+            position: row.position,
+            arguments: args,
+            confidence: row.confidence,
+            relevance: row.relevance,
+            created_at: row.created_at,
+        };
+    }
+}
+//# sourceMappingURL=debate-engine.js.map