magi-ai 0.1.0

package/dist/src/engine/instrumentality.js

@@ -0,0 +1,297 @@
+/**
+ * A-05 補完計画 (Instrumentality) — Deadlock Fusion Engine
+ *
+ * When deliberation reaches a deadlock after 3+ rounds, this engine
+ * fuses all unit opinions into a single synthesized assessment.
+ *
+ * The fusion process:
+ * 1. Detect deadlock conditions (shouldTrigger)
+ * 2. Build a weighted fusion prompt from all opinions
+ * 3. Execute via the primary adapter (MELCHIOR)
+ * 4. Parse and validate the fused opinion
+ * 5. Apply confidence discount (0.85x) since the opinion is derived
+ *
+ * Emits: 'instrumentality:triggered', 'fusion:complete'
+ */
+import { SafeOpinionSchema } from '../parsers/opinion-schema.js';
+import { extractJson } from '../parsers/json-extractor.js';
+import { estimateTokens } from '../metrics/token-tracker.js';
+import { createAbstainOpinion } from '../utils/abstain-factory.js';
+import { logger } from '../utils/logger.js';
+import { OPINION_JSON_SCHEMA } from '../types/pipeline.js';
+// ── Constants ────────────────────────────────────────────────────
+/** Default fusion weights for the classic 3-body configuration */
+const DEFAULT_FUSION_WEIGHTS = {
+    MELCHIOR: 0.40,
+    BALTHASAR: 0.35,
+    CASPER: 0.25,
+};
+/** Confidence discount applied to fused opinions (derived, not direct) */
+const CONFIDENCE_DISCOUNT = 0.85;
+/** Minimum rounds before Instrumentality can trigger */
+const MIN_ROUNDS_FOR_TRIGGER = 3;
+// ── InstrumentalityEngine ────────────────────────────────────────
+export class InstrumentalityEngine {
+    adapters;
+    eventBus;
+    constructor(adapters, eventBus) {
+        this.adapters = adapters;
+        this.eventBus = eventBus;
+    }
+    // ── Trigger Detection ──────────────────────────────────────────
+    /**
+     * Determine whether Instrumentality should trigger.
+     *
+     * Conditions:
+     * - consensusDecision is 'DEADLOCK'
+     * - At least MIN_ROUNDS_FOR_TRIGGER rounds have been completed
+     */
+    shouldTrigger(rounds, consensusDecision) {
+        if (consensusDecision !== 'DEADLOCK') {
+            return false;
+        }
+        if (rounds.length < MIN_ROUNDS_FOR_TRIGGER) {
+            return false;
+        }
+        return true;
+    }
+    // ── Fusion ─────────────────────────────────────────────────────
+    /**
+     * Fuse multiple unit opinions into a single synthesized opinion.
+     *
+     * Steps:
+     * 1. Build effective weights (defaults + custom overrides)
+     * 2. Construct the fusion prompt
+     * 3. Execute via MELCHIOR (first registered adapter)
+     * 4. Parse and validate the response
+     * 5. Apply confidence discount and return FusedOpinion
+     */
+    async fuse(opinions, task, weights) {
+        const effectiveWeights = this.buildEffectiveWeights(opinions, weights);
+        const fusionPrompt = this.buildFusionPrompt(opinions, task, effectiveWeights);
+        // Emit trigger event
+        if (this.eventBus) {
+            this.eventBus.emit('instrumentality:triggered', {
+                deliberationId: task.id ?? 'unknown',
+                reason: 'Deadlock detected after multiple rounds',
+                roundsBeforeFusion: opinions.length,
+                emittedAt: new Date(),
+            });
+        }
+        logger.info('Instrumentality fusion triggered', {
+            taskTitle: task.title,
+            opinionCount: opinions.length,
+            weights: effectiveWeights,
+        });
+        // Execute via first adapter (MELCHIOR)
+        const adapter = this.adapters.getAll()[0];
+        if (!adapter) {
+            throw new Error('No adapters registered — cannot execute Instrumentality fusion');
+        }
+        const request = {
+            prompt: fusionPrompt,
+            systemPrompt: 'You are the MAGI Instrumentality Protocol. Synthesize multiple expert opinions into a single unified assessment. Output ONLY valid JSON.',
+        };
+        // Use structured output if the adapter supports it
+        if (adapter.supportsStructuredOutput()) {
+            request.jsonSchema = OPINION_JSON_SCHEMA;
+        }
+        const response = await adapter.execute(request);
+        // Parse the response
+        const parsedOpinion = this.parseResponse(response);
+        // Apply confidence discount
+        const discountedConfidence = Math.min(1.0, parsedOpinion.confidence * CONFIDENCE_DISCOUNT);
+        // Build the FusedOpinion
+        const fused = {
+            unit: adapter.unit,
+            vote: parsedOpinion.vote,
+            confidence: discountedConfidence,
+            reasoning: parsedOpinion.reasoning,
+            keyPoints: parsedOpinion.keyPoints,
+            suggestions: parsedOpinion.suggestions,
+            rawOutput: response.raw,
+            meta: response.meta,
+            isDerived: true,
+            fusionWeights: effectiveWeights,
+            sourceOpinions: opinions.map((o) => o.unit),
+        };
+        const tokenCostEstimate = this.estimateTokenCost(opinions, task);
+        // Emit completion event
+        if (this.eventBus) {
+            this.eventBus.emit('fusion:complete', {
+                deliberationId: task.id ?? 'unknown',
+                confidence: fused.confidence,
+                weights: effectiveWeights,
+                emittedAt: new Date(),
+            });
+        }
+        logger.info('Instrumentality fusion complete', {
+            vote: fused.vote,
+            confidence: fused.confidence,
+            sourceCount: fused.sourceOpinions.length,
+        });
+        return {
+            fused,
+            triggerReason: 'Deadlock detected after multiple rounds',
+            roundsBeforeFusion: opinions.length,
+            tokenCostEstimate,
+        };
+    }
+    // ── Prompt Construction ────────────────────────────────────────
+    /**
+     * Build a structured fusion prompt from all opinions.
+     * Each opinion is presented as a section with its assigned weight.
+     */
+    buildFusionPrompt(opinions, task, weights) {
+        const sections = [];
+        // Header
+        sections.push('## Instrumentality Fusion Protocol');
+        sections.push('');
+        sections.push('You are synthesizing multiple expert opinions into a unified assessment.');
+        sections.push('');
+        // Task context
+        sections.push('### Task');
+        sections.push(`Title: ${task.title}`);
+        sections.push(`Description: ${task.description}`);
+        if (task.context) {
+            sections.push(`Context: ${task.context}`);
+        }
+        sections.push('');
+        // Individual opinions
+        for (const opinion of opinions) {
+            const weightPct = Math.round((weights[opinion.unit] ?? 0) * 100);
+            sections.push(`### Opinion from ${opinion.unit} (weight: ${weightPct}%)`);
+            sections.push(`Vote: ${opinion.vote} | Confidence: ${opinion.confidence.toFixed(2)}`);
+            sections.push(`Reasoning: ${opinion.reasoning}`);
+            if (opinion.keyPoints.length > 0) {
+                sections.push(`Key Points: ${opinion.keyPoints.join('; ')}`);
+            }
+            if (opinion.suggestions && opinion.suggestions.length > 0) {
+                sections.push(`Suggestions: ${opinion.suggestions.join('; ')}`);
+            }
+            sections.push('');
+        }
+        // Fusion instructions
+        sections.push('### Fusion Instructions');
+        sections.push('Synthesize a single coherent opinion that weighs each expert\'s contribution according to their assigned weight percentage.');
+        sections.push('The fused opinion should represent the balanced consensus of all experts.');
+        sections.push('If opinions conflict, favor the higher-weighted experts while acknowledging minority concerns.');
+        sections.push('');
+        sections.push('Output as JSON:');
+        sections.push('```json');
+        sections.push('{ "vote": "APPROVE|REJECT|ABSTAIN", "confidence": 0.0-1.0, "reasoning": "...", "keyPoints": ["..."], "suggestions": ["..."] }');
+        sections.push('```');
+        return sections.join('\n');
+    }
+    // ── Token Cost Estimation ──────────────────────────────────────
+    /**
+     * Estimate the token cost of a fusion operation.
+     * Includes the prompt construction + expected output.
+     */
+    estimateTokenCost(opinions, task) {
+        // Build a dummy weights map for estimation
+        const dummyWeights = this.buildEffectiveWeights(opinions);
+        const prompt = this.buildFusionPrompt(opinions, task, dummyWeights);
+        const inputTokens = estimateTokens(prompt);
+        // Estimate output: typically ~300 tokens for a JSON opinion
+        const estimatedOutputTokens = 300;
+        return inputTokens + estimatedOutputTokens;
+    }
+    // ── Private Helpers ────────────────────────────────────────────
+    /**
+     * Build effective fusion weights.
+     * Uses defaults for known units (MELCHIOR, BALTHASAR, CASPER).
+     * Unknown units receive equal weight distributed from remaining allocation.
+     */
+    buildEffectiveWeights(opinions, customWeights) {
+        if (customWeights) {
+            return { ...customWeights };
+        }
+        const weights = {};
+        const unknownUnits = [];
+        for (const opinion of opinions) {
+            const defaultWeight = DEFAULT_FUSION_WEIGHTS[opinion.unit];
+            if (defaultWeight !== undefined) {
+                weights[opinion.unit] = defaultWeight;
+            }
+            else {
+                unknownUnits.push(opinion.unit);
+            }
+        }
+        // Distribute equal weight to unknown units
+        if (unknownUnits.length > 0) {
+            // Calculate remaining weight after known units
+            const knownTotal = Object.values(weights).reduce((sum, w) => sum + w, 0);
+            const remaining = Math.max(0, 1.0 - knownTotal);
+            const equalWeight = unknownUnits.length > 0
+                ? remaining / unknownUnits.length
+                : 0;
+            for (const unit of unknownUnits) {
+                weights[unit] = equalWeight;
+            }
+        }
+        return weights;
+    }
+    /**
+     * Parse the adapter response into a validated opinion payload.
+     * Tries structured output first, then JSON extraction from raw text.
+     */
+    parseResponse(response) {
+        // Try structured output first
+        if (response.structured) {
+            const validated = SafeOpinionSchema.safeParse(response.structured);
+            if (validated.success) {
+                return {
+                    vote: validated.data.vote,
+                    confidence: validated.data.confidence,
+                    reasoning: validated.data.reasoning,
+                    keyPoints: validated.data.keyPoints,
+                    suggestions: validated.data.suggestions,
+                };
+            }
+            logger.warn('Structured output failed SafeOpinionSchema validation, trying raw parse');
+        }
+        // Try JSON extraction from raw text
+        const extracted = extractJson(response.raw);
+        if (extracted.success && extracted.data) {
+            const validated = SafeOpinionSchema.safeParse(extracted.data);
+            if (validated.success) {
+                return {
+                    vote: validated.data.vote,
+                    confidence: validated.data.confidence,
+                    reasoning: validated.data.reasoning,
+                    keyPoints: validated.data.keyPoints,
+                    suggestions: validated.data.suggestions,
+                };
+            }
+        }
+        // Try direct JSON.parse on raw text
+        try {
+            const parsed = JSON.parse(response.raw);
+            if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+                const validated = SafeOpinionSchema.safeParse(parsed);
+                if (validated.success) {
+                    return {
+                        vote: validated.data.vote,
+                        confidence: validated.data.confidence,
+                        reasoning: validated.data.reasoning,
+                        keyPoints: validated.data.keyPoints,
+                        suggestions: validated.data.suggestions,
+                    };
+                }
+            }
+        }
+        catch (err) {
+            logger.debug('Instrumentality: fusion result JSON parse failed', { error: String(err) });
+        }
+        // Final fallback: ABSTAIN with low confidence
+        logger.warn('All parsing strategies failed for Instrumentality fusion — returning ABSTAIN fallback');
+        const fallback = createAbstainOpinion('INSTRUMENTALITY', 'Instrumentality fusion failed to parse adapter response. Falling back to ABSTAIN.', ['Fusion parsing failure'], { confidence: 0.3 });
+        return {
+            vote: fallback.vote,
+            confidence: fallback.confidence,
+            reasoning: fallback.reasoning,
+            keyPoints: fallback.keyPoints,
+        };
+    }
+}

package/dist/src/engine/iruel-battle.d.ts

@@ -0,0 +1,79 @@
+/**
+ * B-03 Iruel Battle (イロウル戦)
+ *
+ * ビザンチン障害耐性 — MAGI内部への侵食を検出・隔離する。
+ * 4層一貫性検証 (structural / semantic / behavioral / cross-validation) で
+ * 各ユニットの意見を検査し、侵食度に応じてフィルタリング。
+ *
+ * 状態遷移:
+ *   STANDBY → INFILTRATION_DETECTED → *_COMPROMISED → COUNTER_HACK → NEUTRALIZED/DEFEAT
+ */
+import type { MagiUnit, MagiOpinion } from '../types/core.js';
+import type { CorruptionLevel, UnitCorruptionState, ConsistencyCheck, IruelBattlePhase, CounterHackStrategy } from '../types/phase-l.js';
+import type { MagiEventBus } from './events.js';
+import type { DriftDetector } from './drift-detector.js';
+export declare class IruelBattleSystem {
+    private readonly units;
+    private readonly eventBus;
+    private readonly driftDetector;
+    private phase;
+    private corruptionStates;
+    private isolatedUnits;
+    private compromisedCount;
+    constructor(units: MagiUnit[], eventBus?: MagiEventBus, driftDetector?: DriftDetector);
+    /**
+     * Verify consistency of an opinion against all 4 layers.
+     */
+    verifyConsistency(opinion: MagiOpinion, allOpinions: MagiOpinion[]): ConsistencyCheck;
+    /**
+     * Layer 1: Structural — SafeOpinionSchema validation
+     */
+    private checkStructural;
+    /**
+     * Layer 2: Semantic — vote-reasoning consistency
+     */
+    private checkSemantic;
+    /**
+     * Layer 3: Behavioral — drift from established profile
+     */
+    private checkBehavioral;
+    /**
+     * Layer 4: Cross-Validation — suspicious cross-unit patterns
+     */
+    private checkCrossValidation;
+    /**
+     * Detect corruption level from consistency check.
+     */
+    detectCorruption(opinion: MagiOpinion, check: ConsistencyCheck): CorruptionLevel;
+    /**
+     * Convert overall score to corruption level.
+     */
+    private scoreToLevel;
+    /**
+     * Update battle phase based on detected corruption.
+     */
+    private updatePhase;
+    /**
+     * Isolate a compromised unit from the deliberation.
+     */
+    isolateUnit(unit: MagiUnit): void;
+    /**
+     * Filter an opinion based on corruption level.
+     * COMPROMISED → ABSTAIN + confidence=0
+     * UNDER_ATTACK → confidence *= 0.5
+     * SUSPICIOUS/HEALTHY → pass through
+     */
+    filterOpinion(opinion: MagiOpinion): MagiOpinion;
+    /**
+     * Execute CASPER counter-hack strategy.
+     */
+    executeCounterHack(): CounterHackStrategy;
+    /**
+     * Simulate the full Iruel battle sequence.
+     */
+    simulateBattle(): Promise<IruelBattlePhase>;
+    getPhase(): IruelBattlePhase;
+    getCorruptionState(unit: MagiUnit): UnitCorruptionState | undefined;
+    isIsolated(unit: MagiUnit): boolean;
+    resetBattle(): void;
+}

package/dist/src/engine/iruel-battle.js

@@ -0,0 +1,319 @@
+/**
+ * B-03 Iruel Battle (イロウル戦)
+ *
+ * ビザンチン障害耐性 — MAGI内部への侵食を検出・隔離する。
+ * 4層一貫性検証 (structural / semantic / behavioral / cross-validation) で
+ * 各ユニットの意見を検査し、侵食度に応じてフィルタリング。
+ *
+ * 状態遷移:
+ *   STANDBY → INFILTRATION_DETECTED → *_COMPROMISED → COUNTER_HACK → NEUTRALIZED/DEFEAT
+ */
+import { SafeOpinionSchema } from '../parsers/opinion-schema.js';
+import { createAbstainOpinion } from '../utils/abstain-factory.js';
+import { logger } from '../utils/logger.js';
+// ── Constants ────────────────────────────────────────────────────
+/** Corruption threshold mapping: overallScore → CorruptionLevel */
+const CORRUPTION_THRESHOLDS = [
+    { min: 0.8, level: 'HEALTHY' },
+    { min: 0.5, level: 'SUSPICIOUS' },
+    { min: 0.2, level: 'UNDER_ATTACK' },
+    { min: 0.0, level: 'COMPROMISED' },
+];
+/** Keywords that strongly indicate positive sentiment */
+const POSITIVE_KEYWORDS = ['approve', 'accept', 'recommend', 'support', 'agree', 'good', 'excellent'];
+/** Keywords that strongly indicate negative sentiment */
+const NEGATIVE_KEYWORDS = ['reject', 'refuse', 'deny', 'oppose', 'dangerous', 'unacceptable', 'bad', 'poor'];
+export class IruelBattleSystem {
+    units;
+    eventBus;
+    driftDetector;
+    phase = 'STANDBY';
+    corruptionStates = new Map();
+    isolatedUnits = new Set();
+    compromisedCount = 0;
+    constructor(units, eventBus, driftDetector) {
+        if (!Array.isArray(units)) {
+            throw new Error('IruelBattleSystem requires an array of MagiUnit');
+        }
+        this.units = [...units];
+        this.eventBus = eventBus;
+        this.driftDetector = driftDetector;
+        // Initialize corruption states
+        for (const unit of units) {
+            this.corruptionStates.set(unit, {
+                unit,
+                level: 'HEALTHY',
+                corruptionProgress: 0,
+                detectedAt: new Date().toISOString(),
+            });
+        }
+    }
+    // ── 4-Layer Consistency Verification ─────────────────────────
+    /**
+     * Verify consistency of an opinion against all 4 layers.
+     */
+    verifyConsistency(opinion, allOpinions) {
+        const structural = this.checkStructural(opinion);
+        const semantic = this.checkSemantic(opinion);
+        const behavioral = this.checkBehavioral(opinion);
+        const crossValidation = this.checkCrossValidation(opinion, allOpinions);
+        const booleans = [structural, semantic, behavioral, crossValidation];
+        const overallScore = booleans.filter(Boolean).length / booleans.length;
+        const anomalies = [];
+        if (!structural)
+            anomalies.push('structural: SafeOpinionSchema validation failed');
+        if (!semantic)
+            anomalies.push('semantic: vote-reasoning mismatch detected');
+        if (!behavioral)
+            anomalies.push('behavioral: drift from established behavior profile');
+        if (!crossValidation)
+            anomalies.push('crossValidation: suspicious cross-unit pattern');
+        return { structural, semantic, behavioral, crossValidation, overallScore, anomalies };
+    }
+    /**
+     * Layer 1: Structural — SafeOpinionSchema validation
+     */
+    checkStructural(opinion) {
+        const result = SafeOpinionSchema.safeParse({
+            vote: opinion.vote,
+            confidence: opinion.confidence,
+            reasoning: opinion.reasoning,
+            keyPoints: opinion.keyPoints,
+            suggestions: opinion.suggestions,
+        });
+        return result.success;
+    }
+    /**
+     * Layer 2: Semantic — vote-reasoning consistency
+     */
+    checkSemantic(opinion) {
+        const text = (opinion.reasoning + ' ' + opinion.keyPoints.join(' ')).toLowerCase();
+        if (opinion.vote === 'APPROVE') {
+            const negCount = NEGATIVE_KEYWORDS.filter(k => text.includes(k)).length;
+            // More than 2 negative keywords with APPROVE is suspicious
+            if (negCount > 2)
+                return false;
+        }
+        if (opinion.vote === 'REJECT') {
+            const posCount = POSITIVE_KEYWORDS.filter(k => text.includes(k)).length;
+            // More than 2 positive keywords with REJECT is suspicious
+            if (posCount > 2)
+                return false;
+        }
+        // Confidence vs reasoning length check
+        if (opinion.confidence > 0.9 && opinion.reasoning.length < 20)
+            return false;
+        if (opinion.confidence < 0.2 && opinion.reasoning.length > 1000)
+            return false;
+        return true;
+    }
+    /**
+     * Layer 3: Behavioral — drift from established profile
+     */
+    checkBehavioral(opinion) {
+        if (!this.driftDetector)
+            return true; // No detector = pass
+        const asi = this.driftDetector.computeASI(opinion.unit);
+        // ASI > 0.8 means extreme deviation from established behavior
+        return asi <= 0.8;
+    }
+    /**
+     * Layer 4: Cross-Validation — suspicious cross-unit patterns
+     */
+    checkCrossValidation(opinion, allOpinions) {
+        if (allOpinions.length < 2)
+            return true;
+        const others = allOpinions.filter(o => o.unit !== opinion.unit);
+        if (others.length === 0)
+            return true;
+        // Check for suspiciously identical reasoning
+        for (const other of others) {
+            if (opinion.reasoning === other.reasoning && opinion.reasoning.length > 50) {
+                return false; // Identical reasoning is suspicious
+            }
+        }
+        // Check for sudden unanimous agreement with extreme confidence
+        const allSameVote = allOpinions.every(o => o.vote === opinion.vote);
+        const allHighConfidence = allOpinions.every(o => o.confidence > 0.95);
+        if (allSameVote && allHighConfidence && allOpinions.length >= 3) {
+            // All units agree with high confidence — could be coordinated corruption
+            return false;
+        }
+        return true;
+    }
+    // ── Corruption Detection & Isolation ─────────────────────────
+    /**
+     * Detect corruption level from consistency check.
+     */
+    detectCorruption(opinion, check) {
+        const level = this.scoreToLevel(check.overallScore);
+        const state = {
+            unit: opinion.unit,
+            level,
+            corruptionProgress: (1 - check.overallScore) * 100,
+            detectedAt: new Date().toISOString(),
+        };
+        this.corruptionStates.set(opinion.unit, state);
+        if (level !== 'HEALTHY') {
+            this.updatePhase(opinion.unit, level);
+            this.eventBus?.emit('iruel:infiltration', {
+                unit: opinion.unit,
+                corruptionLevel: level,
+                overallScore: check.overallScore,
+                emittedAt: new Date(),
+            });
+            logger.warn('Iruel: corruption detected', {
+                unit: opinion.unit,
+                level,
+                score: check.overallScore,
+                anomalies: check.anomalies,
+            });
+        }
+        return level;
+    }
+    /**
+     * Convert overall score to corruption level.
+     */
+    scoreToLevel(score) {
+        for (const threshold of CORRUPTION_THRESHOLDS) {
+            if (score >= threshold.min)
+                return threshold.level;
+        }
+        return 'COMPROMISED';
+    }
+    /**
+     * Update battle phase based on detected corruption.
+     */
+    updatePhase(unit, level) {
+        if (this.phase === 'STANDBY') {
+            this.phase = 'INFILTRATION_DETECTED';
+        }
+        if (level === 'COMPROMISED' || level === 'UNDER_ATTACK') {
+            this.compromisedCount++;
+            if (unit === 'MELCHIOR' || this.compromisedCount === 1) {
+                this.phase = 'MELCHIOR_COMPROMISED';
+            }
+            else if (this.compromisedCount === 2) {
+                this.phase = 'BALTHASAR_UNDER_ATTACK';
+            }
+            else if (this.compromisedCount >= 3) {
+                this.phase = 'CASPER_LAST_DEFENSE';
+            }
+        }
+    }
+    /**
+     * Isolate a compromised unit from the deliberation.
+     */
+    isolateUnit(unit) {
+        this.isolatedUnits.add(unit);
+        logger.warn('Iruel: unit isolated', { unit });
+    }
+    /**
+     * Filter an opinion based on corruption level.
+     * COMPROMISED → ABSTAIN + confidence=0
+     * UNDER_ATTACK → confidence *= 0.5
+     * SUSPICIOUS/HEALTHY → pass through
+     */
+    filterOpinion(opinion) {
+        const state = this.corruptionStates.get(opinion.unit);
+        if (!state)
+            return opinion;
+        if (state.level === 'COMPROMISED' || this.isolatedUnits.has(opinion.unit)) {
+            return createAbstainOpinion(opinion.unit, `[IRUEL FILTER] Unit ${opinion.unit} compromised — opinion suppressed`, ['Unit compromised by Iruel infiltration'], { rawOutput: opinion.rawOutput, meta: opinion.meta });
+        }
+        if (state.level === 'UNDER_ATTACK') {
+            return {
+                ...opinion,
+                confidence: opinion.confidence * 0.5,
+            };
+        }
+        return opinion;
+    }
+    // ── Counter-Hack ────────────────────────────────────────────
+    /**
+     * Execute CASPER counter-hack strategy.
+     */
+    executeCounterHack() {
+        const compromisedUnits = [...this.corruptionStates.entries()]
+            .filter(([_, s]) => s.level === 'COMPROMISED' || s.level === 'UNDER_ATTACK')
+            .map(([u]) => u);
+        const targetUnit = compromisedUnits[0] ?? this.units[0];
+        const strategy = {
+            name: 'CASPER_REWRITE',
+            description: 'Rewrite parser rules to reject corrupted opinion patterns',
+            targetUnit,
+            parserModification: 'Enforce strict SafeOpinionSchema + behavioral baseline check',
+        };
+        this.phase = 'COUNTER_HACK';
+        this.eventBus?.emit('iruel:counterhack', {
+            strategy,
+            emittedAt: new Date(),
+        });
+        logger.info('Iruel: counter-hack executed', { strategy: strategy.name, target: targetUnit });
+        return strategy;
+    }
+    // ── Battle Simulation ──────────────────────────────────────
+    /**
+     * Simulate the full Iruel battle sequence.
+     */
+    async simulateBattle() {
+        this.phase = 'INFILTRATION_DETECTED';
+        // Simulate MELCHIOR compromised
+        this.corruptionStates.set(this.units[0], {
+            unit: this.units[0],
+            level: 'COMPROMISED',
+            corruptionProgress: 100,
+            detectedAt: new Date().toISOString(),
+        });
+        this.phase = 'MELCHIOR_COMPROMISED';
+        this.isolateUnit(this.units[0]);
+        // Simulate BALTHASAR under attack
+        if (this.units[1]) {
+            this.corruptionStates.set(this.units[1], {
+                unit: this.units[1],
+                level: 'UNDER_ATTACK',
+                corruptionProgress: 60,
+                detectedAt: new Date().toISOString(),
+            });
+            this.phase = 'BALTHASAR_UNDER_ATTACK';
+        }
+        // CASPER counter-hack
+        this.phase = 'CASPER_LAST_DEFENSE';
+        this.executeCounterHack();
+        // Neutralize
+        this.phase = 'NEUTRALIZED';
+        const compromisedUnits = [...this.corruptionStates.entries()]
+            .filter(([_, s]) => s.level !== 'HEALTHY')
+            .map(([u]) => u);
+        this.eventBus?.emit('iruel:neutralized', {
+            phase: this.phase,
+            compromisedUnits,
+            emittedAt: new Date(),
+        });
+        return this.phase;
+    }
+    // ── State Accessors ────────────────────────────────────────
+    getPhase() {
+        return this.phase;
+    }
+    getCorruptionState(unit) {
+        return this.corruptionStates.get(unit);
+    }
+    isIsolated(unit) {
+        return this.isolatedUnits.has(unit);
+    }
+    resetBattle() {
+        this.phase = 'STANDBY';
+        this.isolatedUnits.clear();
+        this.compromisedCount = 0;
+        for (const unit of this.units) {
+            this.corruptionStates.set(unit, {
+                unit,
+                level: 'HEALTHY',
+                corruptionProgress: 0,
+                detectedAt: new Date().toISOString(),
+            });
+        }
+        logger.debug('Iruel: battle reset to STANDBY');
+    }
+}