magi-ai 0.1.0

package/dist/src/engine/angel-detector.js

@@ -0,0 +1,334 @@
+/**
+ * AngelDetector -- 使徒検知システム (A-04)
+ *
+ * Monitors git diffs for 6 types of suspicious patterns (Angels):
+ *
+ * SACHIEL  - Security-sensitive file changes
+ * SHAMSHEL - High-coupling hub node changes (co-change graph)
+ * RAMIEL   - High-entropy (scattered) changes
+ * GAGHIEL  - Ancient code modification
+ * ISRAFEL  - Multi-developer conflict zones
+ * IRUEL    - Boil-frog micro changes (death by a thousand cuts)
+ *
+ * Each detection returns a ThreatLevel (YELLOW / ORANGE / RED)
+ * and emits 'angel:detected' events via the MagiEventBus.
+ */
+import { getCommitFiles, computeEntropy, getFileAge, getFileDevCount, getCochangeGraph, computeKameiMetrics, } from './change-metrics.js';
+import { execGit } from './change-metrics.js';
+import { logger } from '../utils/logger.js';
+// ── Default configuration ──────────────────────────────────────
+const DEFAULT_CONFIG = {
+    securityPatterns: [
+        /\.env/,
+        /secret/i,
+        /password/i,
+        /auth/i,
+        /token/i,
+        /key/i,
+        /\.pem$/,
+        /\.key$/,
+    ],
+    entropyThreshold: 0.8,
+    ancientThresholdDays: 365,
+    hubDegreeThreshold: 5,
+    microChangeThreshold: 10,
+    pollIntervalMs: 30_000,
+};
+// ── AngelDetector class ────────────────────────────────────────
+export class AngelDetector {
+    config;
+    eventBus;
+    cochangeGraph = [];
+    microChangeHistory = new Map();
+    watchTimer;
+    lastWatchedCommit;
+    constructor(config, eventBus) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.eventBus = eventBus;
+    }
+    // ── Public API ──────────────────────────────────────────────
+    /**
+     * Run all 6 angel detectors against a single commit.
+     * Returns all detected angels (may be empty).
+     */
+    async detectFromCommit(commitHash, cwd) {
+        const files = await getCommitFiles(commitHash, cwd);
+        const metrics = await computeKameiMetrics(commitHash, cwd);
+        const entropy = computeEntropy(files);
+        const detections = [];
+        const sachiel = await this.detectSachiel(commitHash, files, metrics);
+        if (sachiel)
+            detections.push(sachiel);
+        const shamshel = this.detectShamshel(commitHash, files, metrics);
+        if (shamshel)
+            detections.push(shamshel);
+        const ramiel = this.detectRamiel(commitHash, files, metrics, entropy);
+        if (ramiel)
+            detections.push(ramiel);
+        const gaghiel = await this.detectGaghiel(commitHash, files, metrics, cwd);
+        if (gaghiel)
+            detections.push(gaghiel);
+        const israfel = await this.detectIsrafel(commitHash, files, metrics, cwd);
+        if (israfel)
+            detections.push(israfel);
+        this.detectIruel(commitHash, files, metrics, detections);
+        // Emit events for all detections
+        for (const detection of detections) {
+            this.eventBus?.emit('angel:detected', {
+                commitHash: detection.commitHash,
+                angel: detection.angel,
+                threatLevel: detection.threatLevel,
+                affectedFiles: detection.affectedFiles,
+                emittedAt: new Date(),
+            });
+        }
+        return detections;
+    }
+    /**
+     * Start polling for new commits and running detection.
+     */
+    startWatch(cwd) {
+        if (this.watchTimer)
+            return; // Already watching
+        this.watchTimer = setInterval(async () => {
+            try {
+                const head = await execGit(['rev-parse', 'HEAD'], cwd);
+                if (head && head !== this.lastWatchedCommit) {
+                    this.lastWatchedCommit = head;
+                    await this.detectFromCommit(head, cwd);
+                }
+            }
+            catch (err) {
+                logger.debug('AngelDetector: git error during watch poll', { error: String(err) });
+            }
+        }, this.config.pollIntervalMs);
+    }
+    /**
+     * Stop the watch polling.
+     */
+    stopWatch() {
+        if (this.watchTimer) {
+            clearInterval(this.watchTimer);
+            this.watchTimer = undefined;
+        }
+    }
+    /**
+     * Get the current co-change graph.
+     */
+    getCochangeGraph() {
+        return [...this.cochangeGraph];
+    }
+    /**
+     * Rebuild the internal co-change graph from a set of commits.
+     */
+    async updateCochangeGraph(commitHashes, cwd) {
+        this.cochangeGraph = await getCochangeGraph(commitHashes, cwd);
+    }
+    // ── Private detectors ───────────────────────────────────────
+    /**
+     * SACHIEL: Detect security-sensitive file changes.
+     * Checks if any changed file matches securityPatterns.
+     * ThreatLevel based on LA + LD: >100 RED, >30 ORANGE, else YELLOW.
+     */
+    async detectSachiel(commitHash, files, metrics) {
+        const matchedFiles = files.filter(f => this.config.securityPatterns.some(p => p.test(f.filePath)));
+        if (matchedFiles.length === 0)
+            return null;
+        const totalLA = matchedFiles.reduce((sum, f) => sum + f.linesAdded, 0);
+        const totalLD = matchedFiles.reduce((sum, f) => sum + f.linesDeleted, 0);
+        const totalChanges = totalLA + totalLD;
+        let threatLevel;
+        if (totalChanges > 100) {
+            threatLevel = 'RED';
+        }
+        else if (totalChanges > 30) {
+            threatLevel = 'ORANGE';
+        }
+        else {
+            threatLevel = 'YELLOW';
+        }
+        return {
+            angel: 'SACHIEL',
+            threatLevel,
+            commitHash,
+            description: `Security-sensitive files modified: ${matchedFiles.map(f => f.filePath).join(', ')}`,
+            affectedFiles: matchedFiles.map(f => f.filePath),
+            metrics,
+            detectedAt: new Date().toISOString(),
+        };
+    }
+    /**
+     * SHAMSHEL: Detect high-coupling hub node changes.
+     * If any changed file has degree >= hubDegreeThreshold in the co-change graph.
+     * RED if degree > 2x threshold, ORANGE if > 1.5x.
+     */
+    detectShamshel(commitHash, files, metrics) {
+        if (this.cochangeGraph.length === 0)
+            return null;
+        // Compute degree for each file in the graph
+        const degreeMap = new Map();
+        for (const edge of this.cochangeGraph) {
+            degreeMap.set(edge.fileA, (degreeMap.get(edge.fileA) ?? 0) + 1);
+            degreeMap.set(edge.fileB, (degreeMap.get(edge.fileB) ?? 0) + 1);
+        }
+        const hubFiles = [];
+        let maxDegree = 0;
+        for (const f of files) {
+            const degree = degreeMap.get(f.filePath) ?? 0;
+            if (degree >= this.config.hubDegreeThreshold) {
+                hubFiles.push({ filePath: f.filePath, degree });
+                if (degree > maxDegree)
+                    maxDegree = degree;
+            }
+        }
+        if (hubFiles.length === 0)
+            return null;
+        let threatLevel;
+        if (maxDegree > 2 * this.config.hubDegreeThreshold) {
+            threatLevel = 'RED';
+        }
+        else if (maxDegree > 1.5 * this.config.hubDegreeThreshold) {
+            threatLevel = 'ORANGE';
+        }
+        else {
+            threatLevel = 'YELLOW';
+        }
+        return {
+            angel: 'SHAMSHEL',
+            threatLevel,
+            commitHash,
+            description: `Hub node(s) modified (max degree ${maxDegree}): ${hubFiles.map(h => h.filePath).join(', ')}`,
+            affectedFiles: hubFiles.map(h => h.filePath),
+            metrics,
+            detectedAt: new Date().toISOString(),
+        };
+    }
+    /**
+     * RAMIEL: Detect high-entropy (scattered) changes.
+     * If computeEntropy(changes) > entropyThreshold.
+     * RED if > 0.95, ORANGE if > threshold.
+     */
+    detectRamiel(commitHash, files, metrics, entropy) {
+        if (entropy <= this.config.entropyThreshold)
+            return null;
+        let threatLevel;
+        if (entropy > 0.95) {
+            threatLevel = 'RED';
+        }
+        else {
+            threatLevel = 'ORANGE';
+        }
+        return {
+            angel: 'RAMIEL',
+            threatLevel,
+            commitHash,
+            description: `High entropy change detected (${entropy.toFixed(3)}), changes are widely scattered`,
+            affectedFiles: files.map(f => f.filePath),
+            metrics,
+            detectedAt: new Date().toISOString(),
+        };
+    }
+    /**
+     * GAGHIEL: Detect ancient code modification.
+     * If any file age > ancientThresholdDays.
+     * RED if > 3x threshold, ORANGE if > 2x, else YELLOW.
+     */
+    async detectGaghiel(commitHash, files, metrics, cwd) {
+        const ancientFiles = [];
+        let maxAge = 0;
+        for (const f of files) {
+            const age = await getFileAge(f.filePath, cwd);
+            if (age > this.config.ancientThresholdDays) {
+                ancientFiles.push({ filePath: f.filePath, ageDays: age });
+                if (age > maxAge)
+                    maxAge = age;
+            }
+        }
+        if (ancientFiles.length === 0)
+            return null;
+        let threatLevel;
+        if (maxAge > 3 * this.config.ancientThresholdDays) {
+            threatLevel = 'RED';
+        }
+        else if (maxAge > 2 * this.config.ancientThresholdDays) {
+            threatLevel = 'ORANGE';
+        }
+        else {
+            threatLevel = 'YELLOW';
+        }
+        return {
+            angel: 'GAGHIEL',
+            threatLevel,
+            commitHash,
+            description: `Ancient code modified (max age ${maxAge} days): ${ancientFiles.map(a => a.filePath).join(', ')}`,
+            affectedFiles: ancientFiles.map(a => a.filePath),
+            metrics,
+            detectedAt: new Date().toISOString(),
+        };
+    }
+    /**
+     * ISRAFEL: Detect multi-developer conflict zones.
+     * If any file has NDEV >= 3 and changes from multiple devs.
+     * RED if NDEV >= 5, ORANGE if NDEV >= 3.
+     */
+    async detectIsrafel(commitHash, files, metrics, cwd) {
+        const conflictFiles = [];
+        let maxNdev = 0;
+        for (const f of files) {
+            const ndev = await getFileDevCount(f.filePath, cwd);
+            if (ndev >= 3) {
+                conflictFiles.push({ filePath: f.filePath, ndev });
+                if (ndev > maxNdev)
+                    maxNdev = ndev;
+            }
+        }
+        if (conflictFiles.length === 0)
+            return null;
+        let threatLevel;
+        if (maxNdev >= 5) {
+            threatLevel = 'RED';
+        }
+        else {
+            threatLevel = 'ORANGE';
+        }
+        return {
+            angel: 'ISRAFEL',
+            threatLevel,
+            commitHash,
+            description: `Multi-developer conflict zone (max NDEV ${maxNdev}): ${conflictFiles.map(c => c.filePath).join(', ')}`,
+            affectedFiles: conflictFiles.map(c => c.filePath),
+            metrics,
+            detectedAt: new Date().toISOString(),
+        };
+    }
+    /**
+     * IRUEL: Detect boil-frog micro changes.
+     * Track commits with < 5 total lines changed.
+     * If accumulated micro-change count exceeds threshold, alert.
+     */
+    detectIruel(commitHash, files, metrics, detections) {
+        const totalLines = files.reduce((sum, f) => sum + f.linesAdded + f.linesDeleted, 0);
+        // Track all micro-changes (< 5 lines total)
+        if (totalLines < 5) {
+            this.microChangeHistory.set(commitHash, totalLines);
+        }
+        if (this.microChangeHistory.size <= this.config.microChangeThreshold)
+            return;
+        let threatLevel;
+        if (this.microChangeHistory.size > 2 * this.config.microChangeThreshold) {
+            threatLevel = 'RED';
+        }
+        else {
+            threatLevel = 'ORANGE';
+        }
+        detections.push({
+            angel: 'IRUEL',
+            threatLevel,
+            commitHash,
+            description: `Micro-change accumulation detected: ${this.microChangeHistory.size} micro-commits tracked (threshold: ${this.config.microChangeThreshold})`,
+            affectedFiles: files.map(f => f.filePath),
+            metrics,
+            detectedAt: new Date().toISOString(),
+        });
+    }
+}

package/dist/src/engine/at-field.d.ts

@@ -0,0 +1,40 @@
+/**
+ * A-02 A.T.フィールド (ATField)
+ *
+ * バイアス検出モジュール。全会一致の連続回数、投票エントロピー、
+ * keyPointsのJaccard距離、confidence分散を監視し、
+ * 集団思考のリスクをA.T.フィールドレベルとして表現する。
+ */
+import type { MagiOpinion } from '../types/core.js';
+import type { MagiEventBus } from './events.js';
+import type { BiasDetectionResult } from '../types/phase-h.js';
+export declare class ATField {
+    private unanimousStreak;
+    /**
+     * Analyze a set of opinions for bias indicators.
+     * Returns a BiasDetectionResult with level, metrics, and optional catfish advocate.
+     */
+    analyze(opinions: MagiOpinion[], eventBus: MagiEventBus | undefined, deliberationId: string): BiasDetectionResult;
+    /** Reset unanimous streak (e.g., between deliberations) */
+    reset(): void;
+    /** Get current unanimous streak count */
+    getUnanimousStreak(): number;
+    /**
+     * Shannon entropy of vote distribution.
+     * H = -Σ(p_i × log₂(p_i))
+     * Max entropy for 3 choices = log₂(3) ≈ 1.585
+     */
+    voteEntropy(opinions: MagiOpinion[]): number;
+    /** Variance of confidence values */
+    confidenceVariance(opinions: MagiOpinion[]): number;
+    /**
+     * Average pairwise Jaccard distance of keyPoints.
+     * Jaccard distance = 1 - |A∩B| / |A∪B|
+     * Higher distance = more diverse perspectives.
+     */
+    averageJaccardDistance(opinions: MagiOpinion[]): number;
+    /** Generate devil's advocate text based on current opinions */
+    private generateCatfishAdvocate;
+    private getMajorityVote;
+    private buildResult;
+}

package/dist/src/engine/at-field.js

@@ -0,0 +1,195 @@
+/**
+ * A-02 A.T.フィールド (ATField)
+ *
+ * バイアス検出モジュール。全会一致の連続回数、投票エントロピー、
+ * keyPointsのJaccard距離、confidence分散を監視し、
+ * 集団思考のリスクをA.T.フィールドレベルとして表現する。
+ */
+/** 5 consecutive unanimous rounds trigger bias warning */
+const UNANIMOUS_STREAK_THRESHOLD = 5;
+/** Confidence discount applied when bias is detected */
+const BIAS_CONFIDENCE_DISCOUNT = 0.3;
+/** Entropy threshold for low diversity */
+const LOW_ENTROPY_THRESHOLD = 0.5;
+/** Jaccard distance threshold for echo-chamber detection */
+const LOW_JACCARD_THRESHOLD = 0.2;
+export class ATField {
+    unanimousStreak = 0;
+    /**
+     * Analyze a set of opinions for bias indicators.
+     * Returns a BiasDetectionResult with level, metrics, and optional catfish advocate.
+     */
+    analyze(opinions, eventBus, deliberationId) {
+        if (opinions.length === 0) {
+            return this.buildResult(1, 0, 0, 0, deliberationId);
+        }
+        // Check if all non-abstain votes are the same
+        const nonAbstain = opinions.filter(o => o.vote !== 'ABSTAIN');
+        const allSame = nonAbstain.length > 1 &&
+            nonAbstain.every(o => o.vote === nonAbstain[0].vote);
+        if (allSame) {
+            this.unanimousStreak++;
+        }
+        else {
+            this.unanimousStreak = 0;
+        }
+        const entropy = this.voteEntropy(opinions);
+        const confVar = this.confidenceVariance(opinions);
+        const jaccard = this.averageJaccardDistance(opinions);
+        // Determine level
+        const biasWarning = this.unanimousStreak >= UNANIMOUS_STREAK_THRESHOLD;
+        const lowEntropy = entropy < LOW_ENTROPY_THRESHOLD && opinions.length > 1;
+        const lowJaccard = jaccard < LOW_JACCARD_THRESHOLD && opinions.length > 1;
+        let level;
+        if (biasWarning && lowEntropy && lowJaccard) {
+            level = 'MAX';
+        }
+        else if ((biasWarning && lowEntropy) || (biasWarning && lowJaccard)) {
+            level = 3;
+        }
+        else if (biasWarning || lowEntropy) {
+            level = 2;
+        }
+        else {
+            level = 1;
+        }
+        const confidenceDiscount = biasWarning ? BIAS_CONFIDENCE_DISCOUNT : 0;
+        const result = this.buildResult(level, entropy, confVar, jaccard, deliberationId);
+        result.biasWarning = biasWarning;
+        result.confidenceDiscount = confidenceDiscount;
+        if (level !== 1) {
+            result.catfishAdvocate = this.generateCatfishAdvocate(opinions, level);
+        }
+        if (eventBus) {
+            eventBus.emit('bias:detected', {
+                deliberationId,
+                level,
+                biasWarning,
+                confidenceDiscount,
+                voteEntropy: entropy,
+                emittedAt: new Date(),
+            });
+        }
+        return result;
+    }
+    /** Reset unanimous streak (e.g., between deliberations) */
+    reset() {
+        this.unanimousStreak = 0;
+    }
+    /** Get current unanimous streak count */
+    getUnanimousStreak() {
+        return this.unanimousStreak;
+    }
+    /**
+     * Shannon entropy of vote distribution.
+     * H = -Σ(p_i × log₂(p_i))
+     * Max entropy for 3 choices = log₂(3) ≈ 1.585
+     */
+    voteEntropy(opinions) {
+        if (opinions.length === 0)
+            return 0;
+        const counts = {};
+        for (const o of opinions) {
+            counts[o.vote] = (counts[o.vote] ?? 0) + 1;
+        }
+        let entropy = 0;
+        const total = opinions.length;
+        for (const count of Object.values(counts)) {
+            if (count === 0)
+                continue;
+            const p = count / total;
+            entropy -= p * Math.log2(p);
+        }
+        return entropy;
+    }
+    /** Variance of confidence values */
+    confidenceVariance(opinions) {
+        if (opinions.length <= 1)
+            return 0;
+        const confs = opinions.map(o => o.confidence);
+        const mean = confs.reduce((a, b) => a + b, 0) / confs.length;
+        const variance = confs.reduce((sum, c) => sum + (c - mean) ** 2, 0) / confs.length;
+        return variance;
+    }
+    /**
+     * Average pairwise Jaccard distance of keyPoints.
+     * Jaccard distance = 1 - |A∩B| / |A∪B|
+     * Higher distance = more diverse perspectives.
+     */
+    averageJaccardDistance(opinions) {
+        if (opinions.length <= 1)
+            return 1; // single opinion → max diversity (no comparison)
+        const tokenSets = opinions.map(o => {
+            const tokens = new Set();
+            for (const kp of o.keyPoints) {
+                for (const word of kp.toLowerCase().split(/\s+/)) {
+                    if (word.length > 2)
+                        tokens.add(word);
+                }
+            }
+            return tokens;
+        });
+        let totalDistance = 0;
+        let pairs = 0;
+        for (let i = 0; i < tokenSets.length; i++) {
+            for (let j = i + 1; j < tokenSets.length; j++) {
+                const a = tokenSets[i];
+                const b = tokenSets[j];
+                const intersection = new Set([...a].filter(x => b.has(x)));
+                const union = new Set([...a, ...b]);
+                if (union.size === 0) {
+                    totalDistance += 1; // both empty → treat as maximally different
+                }
+                else {
+                    totalDistance += 1 - intersection.size / union.size;
+                }
+                pairs++;
+            }
+        }
+        return pairs > 0 ? totalDistance / pairs : 1;
+    }
+    /** Generate devil's advocate text based on current opinions */
+    generateCatfishAdvocate(opinions, level) {
+        const majorityVote = this.getMajorityVote(opinions);
+        const levelLabel = level === 'MAX' ? 'MAX' : `Level ${level}`;
+        const lines = [
+            `[A.T. FIELD ${levelLabel}] 悪魔の代弁者 — バイアス検出`,
+            `現在の全会一致ストリーク: ${this.unanimousStreak}回連続`,
+            ``,
+        ];
+        if (majorityVote === 'APPROVE') {
+            lines.push(`全ユニットがAPPROVEに傾いています。以下の観点を再検討してください:`, `- この決定のリスクやデメリットは十分に検討されていますか？`, `- 反対意見が出にくい構造的要因はありませんか？`, `- 最悪のケースシナリオは何ですか？`);
+        }
+        else {
+            lines.push(`全ユニットがREJECTに傾いています。以下の観点を再検討してください:`, `- この提案のメリットは十分に評価されていますか？`, `- 修正や条件付き承認の可能性はありませんか？`, `- 却下による機会損失は何ですか？`);
+        }
+        return lines.join('\n');
+    }
+    getMajorityVote(opinions) {
+        const counts = {};
+        for (const o of opinions) {
+            counts[o.vote] = (counts[o.vote] ?? 0) + 1;
+        }
+        let maxVote = 'ABSTAIN';
+        let maxCount = 0;
+        for (const [vote, count] of Object.entries(counts)) {
+            if (count > maxCount) {
+                maxVote = vote;
+                maxCount = count;
+            }
+        }
+        return maxVote;
+    }
+    buildResult(level, entropy, confVar, jaccard, deliberationId) {
+        return {
+            level,
+            voteEntropy: entropy,
+            confidenceVariance: confVar,
+            jaccardDistance: jaccard,
+            unanimousStreak: this.unanimousStreak,
+            biasWarning: false,
+            confidenceDiscount: 0,
+            deliberationId,
+        };
+    }
+}

package/dist/src/engine/berserk-orchestrator.d.ts

@@ -0,0 +1,66 @@
+/**
+ * A-03 暴走モード (BERSERK) — BerserkOrchestrator
+ *
+ * Evolutionary deliberation engine that generates 5 strategy variants
+ * per unit, scores candidates by fitness, and iterates until UNANIMOUS
+ * consensus is reached or maxRounds safety valve triggers.
+ *
+ * Flow:
+ * 1. Generate 5 BerserkStrategy prompts (alpha~epsilon)
+ * 2. Execute adapters x strategies in parallel (up to concurrencyLimit)
+ * 3. Score candidates by fitness (confidence, reasoning quality, key points)
+ * 4. Select top-N survivors
+ * 5. Present survivors to ConsensusEngine
+ * 6. If UNANIMOUS → done. Else → re-vote with next round.
+ *
+ * Cache is intentionally disabled — BERSERK demands fresh computation.
+ * Timeout overrides are not applied — each adapter uses its own defaults.
+ */
+import type { MagiTask, MagiDeliberation } from '../types/core.js';
+import type { BerserkConfig, BerserkCandidate, BerserkStrategy } from '../types/phase-i.js';
+import type { MagiEventBus } from './events.js';
+import type { Type666Firewall } from './type666-firewall.js';
+import type { AdapterRegistry } from '../adapters/registry.js';
+import type { PipelineRegistry } from '../pipelines/registry.js';
+import type { ContextManager } from '../context/manager.js';
+import type { IPipeline } from '../types/pipeline.js';
+/**
+ * Generate 5 distinct BerserkStrategy definitions.
+ * Each provides a unique analytical perspective to maximize opinion diversity.
+ */
+export declare function generateStrategyPrompts(): BerserkStrategy[];
+export declare class BerserkOrchestrator {
+    private readonly adapters;
+    private readonly pipelines;
+    private readonly contextManager;
+    private readonly eventBus?;
+    private readonly config;
+    private readonly semaphore;
+    private readonly consensusEngine;
+    private readonly strategies;
+    private readonly type666Firewall?;
+    private readonly unitExecutor;
+    private readonly fileAccessEnabled?;
+    constructor(adapters: AdapterRegistry, pipelines: PipelineRegistry, contextManager: ContextManager, eventBus?: MagiEventBus, config?: Partial<BerserkConfig>, type666Firewall?: Type666Firewall, fileAccessEnabled?: boolean);
+    /**
+     * Execute BERSERK deliberation.
+     *
+     * Generates strategy-varied opinions in parallel, selects by fitness,
+     * and iterates until UNANIMOUS or maxRounds.
+     */
+    deliberate(task: MagiTask, signal?: AbortSignal): Promise<MagiDeliberation>;
+    /**
+     * Execute all adapter x strategy combinations in parallel,
+     * bounded by the Semaphore concurrency limit.
+     */
+    executeParallel(task: MagiTask, strategies: BerserkStrategy[], pipeline: IPipeline, deliberationId: string): Promise<BerserkCandidate[]>;
+    /**
+     * Select top-N candidates by fitness score.
+     * Returns candidates sorted by fitness descending, capped at survivorCount.
+     */
+    fitnessSelection(candidates: BerserkCandidate[]): BerserkCandidate[];
+    /** Get the strategies used by this orchestrator. */
+    getStrategies(): BerserkStrategy[];
+    /** Get the current config. */
+    getConfig(): Readonly<BerserkConfig>;
+}