magi-ai 0.1.0

package/dist/src/engine/kernel/deliberation-kernel.d.ts

@@ -0,0 +1,12 @@
+import type { MagiDeliberation } from './types.js';
+import type { MagiTask } from '../../types/core.js';
+import type { KernelDependencies } from './types.js';
+export declare class DeliberationKernel {
+    private readonly deps;
+    private readonly phaseRunner;
+    private readonly postProcessor;
+    private readonly middleware;
+    constructor(deps: KernelDependencies);
+    deliberate(task: MagiTask, signal?: AbortSignal): Promise<MagiDeliberation>;
+    private buildResult;
+}

package/dist/src/engine/kernel/deliberation-kernel.js

@@ -0,0 +1,303 @@
+/**
+ * DeliberationKernel — The main deliberation loop.
+ *
+ * Responsibilities:
+ * - Middleware chain execution (cache check, firewall scan)
+ * - Pipeline config setup with sync rate weights
+ * - Phase loop with hard timeout
+ * - Early consensus exit
+ * - Final consensus calculation
+ * - Instrumentality fusion for deadlock resolution
+ * - Human-in-the-loop deadlock resolution
+ * - Build result
+ */
+import { randomUUID } from 'node:crypto';
+import { isUnanimous as isUnanimousDecision, isMajority as isMajorityDecision } from '../../types/consensus.js';
+import { ConsensusEngine } from '../consensus.js';
+import { HumanResolver } from '../human-resolver.js';
+import { logger } from '../../utils/logger.js';
+import { DeliberationTimeoutError } from '../../utils/errors.js';
+import { MiddlewareChain } from '../middleware/chain.js';
+import { createCacheMiddleware } from '../middleware/cache.js';
+import { createFirewallMiddleware } from '../middleware/firewall.js';
+import { PhaseRunner } from './phase-runner.js';
+import { PostProcessor } from './post-processor.js';
+export class DeliberationKernel {
+    deps;
+    phaseRunner;
+    postProcessor;
+    middleware;
+    constructor(deps) {
+        this.deps = deps;
+        this.phaseRunner = new PhaseRunner(deps);
+        this.postProcessor = new PostProcessor(deps);
+        // Build middleware chain (firewall FIRST, then cache)
+        this.middleware = new MiddlewareChain();
+        if (deps.modules.type666Firewall) {
+            this.middleware.use(createFirewallMiddleware(deps.modules.type666Firewall));
+        }
+        if (deps.modules.cache) {
+            this.middleware.use(createCacheMiddleware(deps.modules.cache));
+        }
+    }
+    async deliberate(task, signal) {
+        const id = task.id ?? randomUUID();
+        const { adapters, pipelines, contextManager, eventBus } = this.deps;
+        const { objectiveJudge, syncRateTracker, instrumentality } = this.deps.modules;
+        // Run pre-deliberation middleware chain (cache check, firewall scan, etc.)
+        if (this.middleware.length > 0) {
+            const mwCtx = {
+                deliberationId: id,
+                task,
+                config: {}, // not used by current middlewares
+                eventBus,
+                metadata: new Map(),
+            };
+            await this.middleware.execute(mwCtx);
+            if (mwCtx.blocked) {
+                throw new Error(mwCtx.blockedReason ?? 'Deliberation blocked by firewall');
+            }
+            if (mwCtx.skipDeliberation && mwCtx.cachedResult) {
+                return mwCtx.cachedResult;
+            }
+        }
+        const pipeline = pipelines.get(task.type);
+        const config = {
+            ...pipeline.defaultConfig,
+            ...task.config,
+            consensus: { ...pipeline.defaultConfig.consensus, ...task.config?.consensus },
+        };
+        // Phase H: Merge sync rate weights into consensus config
+        if (syncRateTracker) {
+            const units = adapters.getAll().map(a => a.unit);
+            const syncWeights = syncRateTracker.computeWeights(units, task.type);
+            if (Object.keys(syncWeights).length > 0) {
+                config.consensus = {
+                    ...config.consensus,
+                    unitWeights: { ...config.consensus.unitWeights, ...syncWeights },
+                };
+            }
+        }
+        const consensusEngine = new ConsensusEngine(config.consensus);
+        const startedAt = new Date();
+        const rounds = [];
+        const pendingIO = [];
+        await contextManager.initWorkspace(id, task);
+        logger.info(`MAGI deliberation started: ${id}`, { type: task.type, title: task.title });
+        logger.audit('deliberation.start', id, { type: task.type, title: task.title });
+        eventBus?.emit('deliberation:start', {
+            deliberationId: id,
+            taskType: task.type,
+            taskTitle: task.title,
+            emittedAt: new Date(),
+        });
+        // Run ObjectiveJudge for code-review/security-audit tasks (before phases)
+        let objectiveResult;
+        if (objectiveJudge && (task.type === 'code-review' || task.type === 'security-audit')) {
+            try {
+                objectiveResult = await objectiveJudge.evaluate();
+                logger.info('ObjectiveJudge evaluation complete', { score: objectiveResult.score });
+                logger.audit('objective.complete', id, { score: objectiveResult.score });
+            }
+            catch (err) {
+                logger.warn('ObjectiveJudge evaluation failed, continuing without', { error: String(err) });
+            }
+        }
+        const objectiveSummary = objectiveResult?.summary;
+        const objectiveScore = objectiveResult?.score;
+        // Hard timeout for entire deliberation
+        const deliberationTimeout = config.deliberationTimeoutMs;
+        const deadline = startedAt.getTime() + deliberationTimeout;
+        // Save baseline excludeFromUnanimous to prevent DummyPlug accumulation across phases
+        const baseExcludeFromUnanimous = [...(config.consensus.excludeFromUnanimous ?? [])];
+        for (const phase of config.phases) {
+            // P0-2: Check external abort signal before starting a new phase
+            if (signal?.aborted) {
+                throw new Error('Deliberation cancelled');
+            }
+            // Deep-clone config per phase to isolate from async mutations (fire-and-forget, event handlers).
+            // Prerequisite: config must be JSON-serializable (no functions, class instances, or Symbols).
+            let phaseConfig;
+            try {
+                phaseConfig = structuredClone(config);
+            }
+            catch {
+                // Fallback to JSON round-trip to deep-clone (preserves nested objects)
+                try {
+                    phaseConfig = JSON.parse(JSON.stringify(config));
+                }
+                catch {
+                    phaseConfig = { ...config };
+                }
+            }
+            phaseConfig.consensus.excludeFromUnanimous = [...baseExcludeFromUnanimous];
+            // File access requires more time for CLIs to explore the codebase
+            if (this.deps.fileAccessEnabled) {
+                phaseConfig.phaseTimeoutMs = Math.min(phaseConfig.phaseTimeoutMs * 2, 3_600_000);
+            }
+            const roundNumber = rounds.length + 1;
+            if (roundNumber > phaseConfig.maxRounds)
+                break;
+            // Check hard timeout before starting a new phase
+            if (Date.now() >= deadline) {
+                logger.warn(`Deliberation hard timeout reached`, { id, timeoutMs: deliberationTimeout });
+                logger.audit('phase.timeout', id, { phase: 'deliberation', timeoutMs: deliberationTimeout });
+                throw new DeliberationTimeoutError(id, deliberationTimeout);
+            }
+            logger.info(`Phase: ${phase} (round ${roundNumber})`);
+            logger.audit('phase.start', id, { phase, roundNumber });
+            const roundStart = new Date();
+            eventBus?.emit('phase:start', {
+                deliberationId: id,
+                phase,
+                roundNumber,
+                emittedAt: new Date(),
+            });
+            // Phase timeout with Promise.race
+            let opinions = await this.phaseRunner.runWithTimeout({
+                deliberationId: id, task, pipeline, phase,
+                previousRounds: rounds, config: phaseConfig, objectiveSummary,
+                fileAccessEnabled: this.deps.fileAccessEnabled,
+            }, signal);
+            // Post-phase processing (LCL, ATField, DummyPlug recording)
+            opinions = this.postProcessor.processPhaseOpinions(opinions, phase, id, task.type);
+            const round = {
+                roundNumber,
+                phase,
+                opinions,
+                startedAt: roundStart,
+                completedAt: new Date(),
+            };
+            rounds.push(round);
+            // Fire-and-forget: push IO to pending queue instead of awaiting
+            pendingIO.push(contextManager.saveRound(id, round).catch((err) => {
+                logger.warn('Failed to save round', { roundNumber, error: String(err) });
+            }));
+            const phaseDurationMs = round.completedAt.getTime() - round.startedAt.getTime();
+            logger.audit('phase.complete', id, {
+                phase,
+                roundNumber,
+                durationMs: phaseDurationMs,
+                votes: opinions.map((o) => ({ unit: o.unit, vote: o.vote })),
+            });
+            eventBus?.emit('phase:complete', {
+                deliberationId: id,
+                phase,
+                roundNumber,
+                durationMs: phaseDurationMs,
+                emittedAt: new Date(),
+            });
+            // Adaptive early consensus exit (skip only for final-vote)
+            if (phaseConfig.earlyConsensusExit && phase !== 'final-vote') {
+                const earlyOpinions = objectiveScore !== undefined
+                    ? opinions.map(o => ({ ...o, confidence: o.confidence * (0.5 + 0.5 * objectiveScore) }))
+                    : opinions;
+                const result = consensusEngine.calculate(earlyOpinions);
+                const thresholds = phaseConfig.earlyExitThresholds ?? { unanimous: 0.7, majority: 0.85 };
+                const isUnanimousExit = isUnanimousDecision(result.decision) && result.confidence >= thresholds.unanimous;
+                const isMajorityExit = isMajorityDecision(result.decision) && result.confidence >= thresholds.majority;
+                if (isUnanimousExit || isMajorityExit) {
+                    const reason = isUnanimousExit ? 'unanimous_early_exit' : 'majority_early_exit';
+                    const currentIdx = config.phases.indexOf(phase);
+                    for (const skipped of config.phases.slice(currentIdx + 1)) {
+                        eventBus?.emit('phase:skipped', {
+                            deliberationId: id,
+                            phase: skipped,
+                            reason,
+                            emittedAt: new Date(),
+                        });
+                    }
+                    logger.info(`Early consensus reached: ${result.decision}`);
+                    logger.audit('deliberation.complete', id, {
+                        decision: result.decision,
+                        method: 'early_consensus',
+                        rounds: rounds.length,
+                    });
+                    await Promise.allSettled(pendingIO);
+                    const earlyResult = this.buildResult(id, task, rounds, result, startedAt, objectiveResult);
+                    await contextManager.saveDeliberation(earlyResult).catch((err) => {
+                        logger.warn('Failed to save early deliberation', { error: String(err) });
+                    });
+                    eventBus?.emit('deliberation:complete', {
+                        deliberationId: id,
+                        decision: result.decision,
+                        totalDurationMs: earlyResult.totalDurationMs,
+                        rounds: rounds.length,
+                        fromCache: false,
+                        emittedAt: new Date(),
+                    });
+                    return earlyResult;
+                }
+            }
+        }
+        // Calculate final consensus from the last round (with objective confidence adjustment)
+        const lastRound = rounds[rounds.length - 1];
+        const finalOpinions = lastRound?.opinions ?? [];
+        const adjustedFinalOpinions = objectiveScore !== undefined
+            ? finalOpinions.map(o => ({ ...o, confidence: o.confidence * (0.5 + 0.5 * objectiveScore) }))
+            : finalOpinions;
+        let consensus = consensusEngine.calculate(adjustedFinalOpinions);
+        // Phase I: Instrumentality fusion for deadlock resolution
+        if (consensus.decision === 'DEADLOCK' && instrumentality &&
+            instrumentality.shouldTrigger(rounds, consensus.decision)) {
+            try {
+                const fusionResult = await instrumentality.fuse(adjustedFinalOpinions, task);
+                // Replace consensus with fused opinion result
+                const fusedOpinions = [fusionResult.fused];
+                consensus = consensusEngine.calculate(fusedOpinions);
+                logger.info('Instrumentality fusion resolved deadlock', { decision: consensus.decision });
+                logger.audit('instrumentality.resolve', id, { decision: consensus.decision });
+            }
+            catch (err) {
+                logger.warn('Instrumentality fusion failed, falling through', { error: String(err) });
+            }
+        }
+        // Human-in-the-loop deadlock resolution
+        if (consensus.decision === 'DEADLOCK' && config.consensus.deadlockStrategy === 'human-in-the-loop') {
+            const humanResolver = new HumanResolver();
+            if (humanResolver.isAvailable()) {
+                consensus = await humanResolver.resolve(adjustedFinalOpinions, consensus.votes);
+                logger.info('Deadlock resolved by human', { decision: consensus.decision });
+                logger.audit('human.resolve', id, { decision: consensus.decision });
+            }
+        }
+        // Flush all pending round IO before saving final deliberation
+        await Promise.allSettled(pendingIO);
+        const deliberation = this.buildResult(id, task, rounds, consensus, startedAt, objectiveResult);
+        await contextManager.saveDeliberation(deliberation);
+        // Post-deliberation side effects
+        await this.postProcessor.runPostDeliberation(id, task, lastRound, consensus, deliberation);
+        logger.info(`MAGI deliberation complete: ${consensus.decision}`, {
+            id,
+            rounds: rounds.length,
+            totalDurationMs: deliberation.totalDurationMs,
+        });
+        logger.audit('deliberation.complete', id, {
+            decision: consensus.decision,
+            rounds: rounds.length,
+            totalDurationMs: deliberation.totalDurationMs,
+        });
+        eventBus?.emit('deliberation:complete', {
+            deliberationId: id,
+            decision: consensus.decision,
+            totalDurationMs: deliberation.totalDurationMs,
+            rounds: rounds.length,
+            fromCache: false,
+            emittedAt: new Date(),
+        });
+        return deliberation;
+    }
+    buildResult(id, task, rounds, consensus, startedAt, objectiveResult) {
+        const completedAt = new Date();
+        return {
+            id,
+            task,
+            rounds,
+            consensus,
+            totalDurationMs: completedAt.getTime() - startedAt.getTime(),
+            startedAt,
+            completedAt,
+            objectiveResult,
+        };
+    }
+}

package/dist/src/engine/kernel/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Kernel module re-exports.
+ */
+export { DeliberationKernel } from './deliberation-kernel.js';
+export { PhaseRunner } from './phase-runner.js';
+export { UnitExecutor } from './unit-executor.js';
+export { PostProcessor } from './post-processor.js';
+export type { KernelDependencies, OptionalModules, UnitExecutionParams, PhaseRunParams, DeliberationContext, } from './types.js';

package/dist/src/engine/kernel/index.js

@@ -0,0 +1,7 @@
+/**
+ * Kernel module re-exports.
+ */
+export { DeliberationKernel } from './deliberation-kernel.js';
+export { PhaseRunner } from './phase-runner.js';
+export { UnitExecutor } from './unit-executor.js';
+export { PostProcessor } from './post-processor.js';

package/dist/src/engine/kernel/phase-runner.d.ts

@@ -0,0 +1,10 @@
+import type { KernelDependencies, PhaseRunParams, MagiOpinion } from './types.js';
+export declare class PhaseRunner {
+    private readonly deps;
+    private readonly unitExecutor;
+    constructor(deps: KernelDependencies);
+    /** Execute a phase with a timeout guard (Promise.race). */
+    runWithTimeout(params: PhaseRunParams, externalSignal?: AbortSignal): Promise<MagiOpinion[]>;
+    /** Execute a phase: filter units, run in parallel, apply DummyPlug/Iruel/Offline. */
+    private run;
+}

package/dist/src/engine/kernel/phase-runner.js

@@ -0,0 +1,155 @@
+/**
+ * PhaseRunner — Executes a deliberation phase across all active MAGI units.
+ *
+ * Responsibilities:
+ * - AbortController + phase timeout management
+ * - UmbilicalCable unit filtering (circuit breaker, battery depletion)
+ * - Parallel execution via Promise.allSettled
+ * - UmbilicalCable result recording (success/failure)
+ * - DummyPlug replacement for ABSTAIN units
+ * - Iruel consistency verification
+ * - Offline fallback for skipped adapters
+ */
+import { logger } from '../../utils/logger.js';
+import { createAbstainOpinion } from '../../utils/abstain-factory.js';
+import { PhaseTimeoutError } from '../../utils/errors.js';
+import { UnitExecutor } from './unit-executor.js';
+export class PhaseRunner {
+    deps;
+    unitExecutor;
+    constructor(deps) {
+        this.deps = deps;
+        this.unitExecutor = new UnitExecutor(deps);
+    }
+    /** Execute a phase with a timeout guard (Promise.race). */
+    async runWithTimeout(params, externalSignal) {
+        const { config } = params;
+        const controller = new AbortController();
+        // Link external signal (from REPL Ctrl+C) to internal phase controller
+        const onExternalAbort = () => controller.abort();
+        externalSignal?.addEventListener('abort', onExternalAbort, { once: true });
+        const phasePromise = this.run(params, controller.signal);
+        let timer;
+        const timeoutPromise = new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                controller.abort(); // Signal child processes to terminate
+                logger.audit('phase.timeout', params.deliberationId, {
+                    phase: params.phase, timeoutMs: config.phaseTimeoutMs,
+                });
+                reject(new PhaseTimeoutError(params.phase, config.phaseTimeoutMs));
+            }, config.phaseTimeoutMs);
+        });
+        try {
+            return await Promise.race([phasePromise, timeoutPromise]);
+        }
+        finally {
+            clearTimeout(timer);
+            externalSignal?.removeEventListener('abort', onExternalAbort);
+        }
+    }
+    /** Execute a phase: filter units, run in parallel, apply DummyPlug/Iruel/Offline. */
+    async run(params, signal) {
+        const { deliberationId, task, pipeline, phase, previousRounds, config, objectiveSummary, fileAccessEnabled } = params;
+        const { adapters, eventBus } = this.deps;
+        const { umbilicalCable, dummyPlug, iruelBattle, offlineMode } = this.deps.modules;
+        const allAdapters = adapters.getAll();
+        // Phase H: Filter out disconnected + battery-depleted units (with circuit breaker)
+        const activeAdapters = allAdapters.filter(adapter => {
+            if (umbilicalCable) {
+                // Circuit breaker: fail fast for OPEN circuits
+                if (!umbilicalCable.shouldAllow(adapter.unit)) {
+                    logger.info(`${adapter.unit} skipped: circuit breaker OPEN`);
+                    return false;
+                }
+                const status = umbilicalCable.getStatus(adapter.unit);
+                if (status === 'disconnected' && umbilicalCable.isBatteryDepleted(adapter.unit)) {
+                    logger.info(`${adapter.unit} skipped: disconnected + battery depleted`);
+                    return false;
+                }
+            }
+            return true;
+        });
+        // All phases run in parallel (Promise.allSettled for graceful degradation)
+        const results = await Promise.allSettled(activeAdapters.map((adapter) => this.unitExecutor.execute({
+            deliberationId, adapter, task, pipeline, phase,
+            previousRounds, config, objectiveSummary, signal,
+            fileAccessEnabled,
+        })));
+        const opinions = results.map((result, i) => {
+            const adapter = activeAdapters[i];
+            if (result.status === 'fulfilled') {
+                // Phase H: Record success in UmbilicalCable
+                umbilicalCable?.recordResult(adapter.unit, 'SUCCESS', eventBus);
+                return result.value;
+            }
+            // Phase H: Record failure in UmbilicalCable
+            const errorCode = String(result.reason).includes('TIMEOUT') ? 'TIMEOUT' : 'CRASH';
+            umbilicalCable?.recordResult(adapter.unit, errorCode, eventBus);
+            // On failure, produce an ABSTAIN opinion
+            logger.warn(`${adapter.displayName} failed in phase ${phase}`, {
+                error: String(result.reason),
+            });
+            logger.audit('adapter.failure', deliberationId, {
+                unit: adapter.unit,
+                phase,
+                error: String(result.reason),
+            });
+            eventBus?.emit('unit:error', {
+                deliberationId,
+                unit: adapter.unit,
+                phase,
+                error: String(result.reason),
+                emittedAt: new Date(),
+            });
+            return createAbstainOpinion(adapter.unit, `${adapter.displayName} failed: ${result.reason?.message ?? 'unknown error'}`, ['Adapter execution failed']);
+        });
+        // Phase H: Replace ABSTAIN/down units with DummyPlug proxy opinions
+        if (dummyPlug) {
+            for (let i = 0; i < opinions.length; i++) {
+                const op = opinions[i];
+                if (op.vote === 'ABSTAIN' && op.confidence === 0) {
+                    const proxy = dummyPlug.generateProxy(op.unit, activeAdapters.map(a => a.unit), opinions, task.type);
+                    if (proxy) {
+                        opinions[i] = proxy;
+                        logger.info(`DummyPlug activated for ${op.unit}`);
+                        logger.audit('dummyplug.activate', deliberationId, { unit: op.unit });
+                        eventBus?.emit('dummyplug:activated', {
+                            deliberationId, unit: op.unit,
+                            confidence: proxy.confidence, profileSamples: proxy.profileSamples,
+                            emittedAt: new Date(),
+                        });
+                    }
+                }
+            }
+            // Set excludeFromUnanimous for dummy plug units
+            const dummyUnits = dummyPlug.getDummyUnits(opinions);
+            if (dummyUnits.length > 0) {
+                config.consensus = {
+                    ...config.consensus,
+                    excludeFromUnanimous: [
+                        ...(config.consensus.excludeFromUnanimous ?? []),
+                        ...dummyUnits,
+                    ],
+                };
+            }
+        }
+        // Phase L: Iruel Battle consistency verification + filtering
+        if (iruelBattle) {
+            for (let i = 0; i < opinions.length; i++) {
+                const op = opinions[i];
+                const check = iruelBattle.verifyConsistency(op, opinions);
+                iruelBattle.detectCorruption(op, check);
+                opinions[i] = iruelBattle.filterOpinion(op);
+            }
+        }
+        // Phase H: Add offline fallback opinions for skipped (depleted) adapters
+        if (offlineMode) {
+            const skipped = allAdapters.filter(a => !activeAdapters.includes(a));
+            for (const adapter of skipped) {
+                const fallback = offlineMode.generateFallbackOpinion(adapter.unit, task);
+                opinions.push(fallback);
+            }
+        }
+        return opinions;
+    }
+}

package/dist/src/engine/kernel/post-processor.d.ts

@@ -0,0 +1,17 @@
+import type { KernelDependencies, MagiOpinion, MagiTask, DeliberationRound, MagiDeliberation } from './types.js';
+import type { ConsensusResult } from '../../types/consensus.js';
+export declare class PostProcessor {
+    private readonly deps;
+    constructor(deps: KernelDependencies);
+    /**
+     * Process opinions after a phase completes.
+     * - LCL purify (cross-examination only)
+     * - ATField bias analysis
+     * - DummyPlug profile recording
+     */
+    processPhaseOpinions(opinions: MagiOpinion[], phase: string, deliberationId: string, taskType: string): MagiOpinion[];
+    /**
+     * Run all post-deliberation side effects (mostly fire-and-forget).
+     */
+    runPostDeliberation(deliberationId: string, task: MagiTask, lastRound: DeliberationRound | undefined, consensus: ConsensusResult, deliberation: MagiDeliberation): Promise<void>;
+}

package/dist/src/engine/kernel/post-processor.js

@@ -0,0 +1,131 @@
+/**
+ * PostProcessor — Handles post-phase and post-deliberation side effects.
+ *
+ * Phase opinion processing (after each phase):
+ * - LCL purify opinions
+ * - ATField bias analysis
+ * - DummyPlug profile recording
+ *
+ * Post-deliberation processing (after consensus is determined):
+ * - SyncRate update
+ * - Gospel chronicle record
+ * - Engram memory record
+ * - Drift detection
+ * - Firewall learning
+ * - Nebuchadnezzar key reset
+ * - Cache save
+ * - Token persist
+ */
+import { logger } from '../../utils/logger.js';
+import { fireAndForget } from '../../utils/fire-and-forget.js';
+export class PostProcessor {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /**
+     * Process opinions after a phase completes.
+     * - LCL purify (cross-examination only)
+     * - ATField bias analysis
+     * - DummyPlug profile recording
+     */
+    processPhaseOpinions(opinions, phase, deliberationId, taskType) {
+        let processed = opinions;
+        const { lclManager, atField, dummyPlug } = this.deps.modules;
+        // Phase I: LCL purify opinions before cross-examination
+        if (lclManager && phase === 'cross-examination') {
+            for (let i = 0; i < processed.length; i++) {
+                const result = lclManager.purify(processed[i], deliberationId);
+                if (result.purified) {
+                    processed[i] = { ...processed[i], confidence: result.adjustedConfidence };
+                }
+            }
+        }
+        // Phase H: A.T. Field bias analysis
+        if (atField) {
+            const biasResult = atField.analyze(processed, this.deps.eventBus, deliberationId);
+            if (biasResult.biasWarning && biasResult.confidenceDiscount > 0) {
+                processed = processed.map(o => ({
+                    ...o,
+                    confidence: o.confidence * (1 - biasResult.confidenceDiscount),
+                }));
+            }
+        }
+        // Phase H: Record profiles for DummyPlug (exclude dummy opinions)
+        if (dummyPlug) {
+            for (const opinion of processed) {
+                if (!('isDummyPlug' in opinion)) {
+                    dummyPlug.recordOpinion(opinion, taskType);
+                }
+            }
+        }
+        return processed;
+    }
+    /**
+     * Run all post-deliberation side effects (mostly fire-and-forget).
+     */
+    async runPostDeliberation(deliberationId, task, lastRound, consensus, deliberation) {
+        const { adapters, eventBus } = this.deps;
+        const { syncRateTracker, gospel, engramManager, driftDetector, type666Firewall, nebuchadnezzarKey, cache, tokenTracker, } = this.deps.modules;
+        // Phase H: Update sync rates for all units
+        if (syncRateTracker && lastRound) {
+            const units = adapters.getAll().map(a => a.unit);
+            for (const opinion of lastRound.opinions) {
+                syncRateTracker.update(opinion.unit, task.type, opinion.vote, consensus.decision);
+            }
+            const rates = syncRateTracker.getAllRates(units, task.type);
+            eventBus?.emit('syncrate:updated', {
+                deliberationId, rates, domain: task.type, emittedAt: new Date(),
+            });
+            // Berserk check
+            const berserk = syncRateTracker.checkBerserk(units, task.type);
+            if (berserk) {
+                eventBus?.emit('berserk:warning', {
+                    deliberationId, totalSyncRate: berserk.totalRate, threshold: 4.0,
+                    units: berserk.rates, emittedAt: new Date(),
+                });
+            }
+            fireAndForget(syncRateTracker.persist(), 'syncrate.persist');
+        }
+        // Phase H: Record in Gospel chronicle
+        if (gospel) {
+            fireAndForget(gospel.record(deliberation, eventBus), 'gospel.record');
+        }
+        // Phase I: Record in engram memory + drift detection (fire-and-forget)
+        if (engramManager) {
+            fireAndForget(engramManager.recordDeliberation(deliberation), 'engram.record');
+        }
+        if (driftDetector && lastRound) {
+            for (const opinion of lastRound.opinions) {
+                driftDetector.updateVector(opinion.unit, opinion, consensus.decision);
+                driftDetector.checkDrift(opinion.unit, eventBus);
+            }
+        }
+        // Phase K: Firewall learns from deliberation (fire-and-forget)
+        if (type666Firewall) {
+            try {
+                type666Firewall.learnFromDeliberation({ task, consensus });
+            }
+            catch (err) {
+                logger.debug('Firewall learn failed', { error: String(err) });
+            }
+        }
+        // Phase K: Reset Nebuchadnezzar consecutive overrides on normal completion
+        if (nebuchadnezzarKey) {
+            nebuchadnezzarKey.resetConsecutiveOverrides();
+        }
+        // Cache result (fire-and-forget)
+        if (cache) {
+            try {
+                cache.set(task, deliberation);
+            }
+            catch (err) {
+                logger.debug('Cache set failed', { error: String(err) });
+            }
+        }
+        // Persist token data (fire-and-forget)
+        if (tokenTracker) {
+            fireAndForget(tokenTracker.persist(deliberationId), 'token.persist');
+        }
+    }
+}