magi-ai 0.1.0

package/dist/src/index.js

@@ -0,0 +1,426 @@
+/**
+ * MAGI System - Public API
+ *
+ * Usage:
+ *   import { Magi } from 'magi-ai';
+ *   const magi = new Magi();
+ *   const result = await magi.deliberate({ type: 'code-review', ... });
+ */
+import { DEFAULT_CONFIG } from './types/config.js';
+import { AdapterRegistry } from './adapters/registry.js';
+import { ClaudeAdapter } from './adapters/claude.js';
+import { CodexAdapter } from './adapters/codex.js';
+import { GeminiAdapter } from './adapters/gemini.js';
+import { PipelineRegistry } from './pipelines/registry.js';
+import { CodeReviewPipeline } from './pipelines/code-review.js';
+import { ArchitecturePipeline } from './pipelines/architecture.js';
+import { BugAnalysisPipeline } from './pipelines/bug-analysis.js';
+import { CustomPipeline } from './pipelines/custom.js';
+import { Orchestrator } from './engine/orchestrator.js';
+import { ContextManager } from './context/manager.js';
+import { DeliberationCache } from './cache/deliberation-cache.js';
+import { MagiEventBus } from './engine/events.js';
+import { TokenTracker } from './metrics/token-tracker.js';
+import { ObjectiveJudge } from './engine/objective-judge.js';
+import { setLogLevel, initAuditLog } from './utils/logger.js';
+import { SyncRateTracker } from './engine/sync-rate.js';
+import { ATField } from './engine/at-field.js';
+import { GospelChronicle } from './engine/gospel.js';
+import { SecretCipher } from './engine/secret-cipher.js';
+import { UmbilicalCable } from './engine/umbilical-cable.js';
+import { OfflineMode } from './engine/offline-mode.js';
+import { DummyPlugSystem } from './engine/dummy-plug.js';
+import { EngramManager } from './engine/engram-manager.js';
+import { DriftDetector } from './engine/drift-detector.js';
+import { LCLManager } from './engine/lcl-manager.js';
+import { InstrumentalityEngine } from './engine/instrumentality.js';
+import { BerserkOrchestrator } from './engine/berserk-orchestrator.js';
+// Phase K modules
+import { Type666Firewall } from './engine/type666-firewall.js';
+import { NebuchadnezzarKey } from './engine/nebuchadnezzar-key.js';
+import { AngelDetector } from './engine/angel-detector.js';
+import { DeadSeaScrolls } from './engine/dead-sea-scrolls.js';
+// Phase L modules
+import { IruelBattleSystem } from './engine/iruel-battle.js';
+import { NeonGenesis } from './engine/neon-genesis.js';
+import { SelfEvolutionEngine } from './engine/self-evolution.js';
+import { SeeleCouncil } from './engine/seele-council.js';
+import { SelfDestructSequence } from './engine/self-destruct.js';
+import { logger } from './utils/logger.js';
+import { fireAndForget } from './utils/fire-and-forget.js';
+export class Magi {
+    orchestrator;
+    berserkOrchestrator;
+    adapters;
+    pipelines;
+    contextManager;
+    config;
+    eventBus;
+    tokenTracker;
+    engramManager;
+    syncRateTracker;
+    umbilicalCable;
+    atField;
+    initPromise;
+    initialized = false;
+    // Promoted from constructor locals → private fields (for namespace API)
+    gospel;
+    driftDetector;
+    lclManager;
+    type666Firewall;
+    nebuchadnezzarKey;
+    secretCipher;
+    objectiveJudge;
+    dummyPlug;
+    offlineMode;
+    iruelBattle;
+    // Lazy-instantiated engines (only created when accessed via namespace)
+    _angelDetector;
+    _deadSeaScrolls;
+    _selfEvolution;
+    _seeleCouncil;
+    _selfDestruct;
+    _neonGenesis;
+    // Cached namespace objects
+    _runtime;
+    _diagnostics;
+    _admin;
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        setLogLevel(this.config.logLevel);
+        this.adapters = new AdapterRegistry();
+        this.pipelines = new PipelineRegistry();
+        this.contextManager = new ContextManager(this.config.workspaceDir);
+        const pipelines = this.pipelines;
+        const context = this.contextManager;
+        this.eventBus = new MagiEventBus();
+        this.tokenTracker = new TokenTracker(this.config.workspaceDir);
+        // Register adapters — only enabled units (default: all 3)
+        const enabledUnits = this.config.enabledUnits ?? ['MELCHIOR', 'BALTHASAR', 'CASPER'];
+        const adapterFactories = {
+            MELCHIOR: () => new ClaudeAdapter(this.config.adapters.MELCHIOR),
+            BALTHASAR: () => new CodexAdapter(this.config.adapters.BALTHASAR),
+            CASPER: () => new GeminiAdapter(this.config.adapters.CASPER),
+        };
+        for (const unit of enabledUnits) {
+            const factory = adapterFactories[unit];
+            if (factory)
+                this.adapters.register(factory());
+        }
+        // Auto-adjust quorum and phases for reduced unit counts
+        if (enabledUnits.length === 1) {
+            this.config = {
+                ...this.config,
+                defaultPipeline: {
+                    ...this.config.defaultPipeline,
+                    phases: ['initial-opinion', 'final-vote'],
+                    consensus: { ...this.config.defaultPipeline.consensus, quorum: 1 },
+                },
+            };
+        }
+        else if (enabledUnits.length === 2) {
+            const needsStrategyFix = this.config.defaultPipeline.consensus.deadlockStrategy === 'melchior-tiebreak'
+                && !enabledUnits.includes('MELCHIOR');
+            this.config = {
+                ...this.config,
+                defaultPipeline: {
+                    ...this.config.defaultPipeline,
+                    consensus: {
+                        ...this.config.defaultPipeline.consensus,
+                        quorum: 2,
+                        ...(needsStrategyFix ? { deadlockStrategy: 'highest-confidence' } : {}),
+                    },
+                },
+            };
+        }
+        // Register pipelines
+        pipelines.register(new CodeReviewPipeline());
+        pipelines.register(new ArchitecturePipeline());
+        pipelines.register(new BugAnalysisPipeline());
+        pipelines.register(new CustomPipeline());
+        const cache = this.config.cacheEnabled !== false
+            ? new DeliberationCache(this.config.cacheTtlMs)
+            : undefined;
+        this.objectiveJudge = new ObjectiveJudge(this.config.workspaceDir);
+        // Phase H modules (all optional, graceful degradation)
+        this.syncRateTracker = new SyncRateTracker(this.config.workspaceDir);
+        this.atField = new ATField();
+        this.gospel = new GospelChronicle(this.config.workspaceDir);
+        const allUnits = this.adapters.getAll().map(a => a.unit);
+        this.umbilicalCable = new UmbilicalCable(allUnits);
+        this.dummyPlug = new DummyPlugSystem(this.syncRateTracker);
+        this.offlineMode = new OfflineMode(cache);
+        // Secret cipher
+        this.secretCipher = new SecretCipher(this.config.workspaceDir);
+        // Phase I modules (all optional, graceful degradation)
+        this.engramManager = new EngramManager(this.config.workspaceDir, this.eventBus);
+        this.driftDetector = new DriftDetector();
+        this.lclManager = new LCLManager(undefined, this.eventBus);
+        const instrumentality = new InstrumentalityEngine(this.adapters, this.eventBus);
+        // Phase K modules (all optional, graceful degradation)
+        this.type666Firewall = new Type666Firewall(this.eventBus);
+        this.nebuchadnezzarKey = new NebuchadnezzarKey(this.config.workspaceDir, this.eventBus);
+        // Phase L modules (all optional, graceful degradation)
+        this.iruelBattle = new IruelBattleSystem(allUnits, this.eventBus, this.driftDetector);
+        this.orchestrator = new Orchestrator({
+            adapters: this.adapters,
+            pipelines,
+            contextManager: context,
+            maxConcurrentDeliberations: this.config.maxConcurrentDeliberations,
+            cache,
+            eventBus: this.eventBus,
+            tokenTracker: this.tokenTracker,
+            objectiveJudge: this.objectiveJudge,
+            syncRateTracker: this.syncRateTracker,
+            atField: this.atField,
+            gospel: this.gospel,
+            umbilicalCable: this.umbilicalCable,
+            dummyPlug: this.dummyPlug,
+            offlineMode: this.offlineMode,
+            engramManager: this.engramManager,
+            lclManager: this.lclManager,
+            instrumentality,
+            driftDetector: this.driftDetector,
+            type666Firewall: this.type666Firewall,
+            nebuchadnezzarKey: this.nebuchadnezzarKey,
+            iruelBattle: this.iruelBattle,
+            fileAccessEnabled: this.config.fileAccess?.enabled,
+        });
+        // Persistent BerserkOrchestrator — reused across calls for LatencyTracker accumulation
+        this.berserkOrchestrator = new BerserkOrchestrator(this.adapters, this.pipelines, this.contextManager, this.eventBus, undefined, this.type666Firewall, this.config.fileAccess?.enabled);
+        // Collect all async initializations into a single awaitable promise
+        // (replaces individual fire-and-forget .catch() calls — SAFE-03)
+        this.initPromise = Promise.allSettled([
+            this.syncRateTracker.load(),
+            this.gospel.initialize(),
+            this.secretCipher.autoInitialize(),
+            this.engramManager.load(),
+            this.nebuchadnezzarKey.load(),
+            this.config.auditLog ? initAuditLog(this.config.auditLog) : Promise.resolve(),
+        ]).then(results => {
+            for (const r of results) {
+                if (r.status === 'rejected') {
+                    logger.debug(`Init module failed (non-fatal): ${String(r.reason)}`);
+                }
+            }
+            this.initialized = true;
+        });
+    }
+    async ensureInitialized() {
+        if (!this.initialized)
+            await this.initPromise;
+    }
+    // ── Lazy-instantiated engine accessors ──────────────────
+    get angelDetector() {
+        if (!this._angelDetector) {
+            this._angelDetector = new AngelDetector(undefined, this.eventBus);
+        }
+        return this._angelDetector;
+    }
+    get deadSeaScrolls() {
+        if (!this._deadSeaScrolls) {
+            this._deadSeaScrolls = new DeadSeaScrolls(this.config.workspaceDir, this.eventBus);
+        }
+        return this._deadSeaScrolls;
+    }
+    get selfEvolution() {
+        if (!this._selfEvolution) {
+            this._selfEvolution = new SelfEvolutionEngine(this.config.workspaceDir, '.', this.eventBus);
+        }
+        return this._selfEvolution;
+    }
+    get seeleCouncil() {
+        if (!this._seeleCouncil) {
+            this._seeleCouncil = new SeeleCouncil('MAGI-01', this.eventBus);
+        }
+        return this._seeleCouncil;
+    }
+    get selfDestructSequence() {
+        if (!this._selfDestruct) {
+            const allUnits = this.adapters.getAll().map(a => a.unit);
+            this._selfDestruct = new SelfDestructSequence(allUnits, this.eventBus, this.secretCipher);
+        }
+        return this._selfDestruct;
+    }
+    get neonGenesis() {
+        if (!this._neonGenesis) {
+            this._neonGenesis = new NeonGenesis(this.config.workspaceDir, this.eventBus);
+        }
+        return this._neonGenesis;
+    }
+    // ── Namespaced API getters ──────────────────────────────
+    get runtime() {
+        if (!this._runtime) {
+            const self = this;
+            this._runtime = Object.freeze({
+                startWatch(opts) {
+                    if (opts?.pollIntervalMs) {
+                        // Stop existing detector before re-creating with custom interval
+                        self._angelDetector?.stopWatch();
+                        self._angelDetector = new AngelDetector({ pollIntervalMs: opts.pollIntervalMs }, self.eventBus);
+                    }
+                    self.angelDetector.startWatch();
+                    let stopped = false;
+                    if (opts?.signal) {
+                        opts.signal.addEventListener('abort', () => {
+                            if (!stopped) {
+                                self.angelDetector.stopWatch();
+                                stopped = true;
+                            }
+                        }, { once: true });
+                    }
+                    return {
+                        stop() {
+                            if (!stopped) {
+                                self.angelDetector.stopWatch();
+                                stopped = true;
+                            }
+                        },
+                        get running() { return !stopped; },
+                    };
+                },
+                stopWatch() { self.angelDetector.stopWatch(); },
+                async detectFromCommit(hash) { await self.ensureInitialized(); return self.angelDetector.detectFromCommit(hash); },
+                getCochangeGraph() { return self.angelDetector.getCochangeGraph(); },
+                async analyzeFile(filePath) { await self.ensureInitialized(); return self.deadSeaScrolls.analyze(filePath); },
+                async analyzeAll(dirPath) { await self.ensureInitialized(); return self.deadSeaScrolls.analyzeAll(dirPath); },
+                getScrollsAccuracy() { return self.deadSeaScrolls.getAccuracy(); },
+                scanFirewall(input) { return self.type666Firewall.scan(input); },
+                getFirewallStats() {
+                    return {
+                        patternCount: self.type666Firewall.getStaticPatternCount(),
+                        dynamicCount: self.type666Firewall.getPatternCount(),
+                    };
+                },
+            });
+        }
+        return this._runtime;
+    }
+    get diagnostics() {
+        if (!this._diagnostics) {
+            const self = this;
+            this._diagnostics = Object.freeze({
+                async simulateIruelBattle() { await self.ensureInitialized(); return self.iruelBattle.simulateBattle(); },
+                getIruelPhase() { return self.iruelBattle.getPhase(); },
+                resetIruelBattle() { self.iruelBattle.resetBattle(); },
+                computeASI(unit) { return self.driftDetector.computeASI(unit); },
+                checkDrift(unit) { return self.driftDetector.checkDrift(unit, self.eventBus); },
+                async evolve(opts) { await self.ensureInitialized(); return self.selfEvolution.evolve(opts); },
+                async diagnose() { await self.ensureInitialized(); return self.selfEvolution.diagnose(); },
+                getChronicleEntryCount() { return self.gospel.getCount(); },
+                getLCLDensity(phase) {
+                    return self.lclManager.getDensity(phase);
+                },
+            });
+        }
+        return this._diagnostics;
+    }
+    get admin() {
+        if (!this._admin) {
+            const self = this;
+            this._admin = Object.freeze({
+                async simulateSeele() {
+                    await self.ensureInitialized();
+                    return self.seeleCouncil.simulateSession();
+                },
+                async executeSeeleAttack(attackers, target) {
+                    await self.ensureInitialized();
+                    return self.seeleCouncil.executeAttack(attackers, target);
+                },
+                formatSeelePanel() { return self.seeleCouncil.formatSoundOnlyPanel(); },
+                fileDestructMotion(reason) {
+                    return self.selfDestructSequence.fileMotion(reason, 'API');
+                },
+                castDestructVote(motionId, unit, vote) {
+                    self.selfDestructSequence.castVote(motionId, unit, vote);
+                },
+                async executeDestruct(motionId) {
+                    await self.ensureInitialized();
+                    return self.selfDestructSequence.executeCountdown(motionId);
+                },
+                getDestructPhase() { return self.selfDestructSequence.getPhase(); },
+                resetDestruct() { self.selfDestructSequence.reset(); },
+                async executeGenesis(reason, force) {
+                    await self.ensureInitialized();
+                    return self.neonGenesis.execute(reason, 'API', force);
+                },
+                async loadGenesisLog() { await self.ensureInitialized(); return self.neonGenesis.loadGenesisLog(); },
+                getNebuchadnezzarState() { return self.nebuchadnezzarKey.getState(); },
+            });
+        }
+        return this._admin;
+    }
+    async deliberate(task, options) {
+        await this.ensureInitialized();
+        return this.orchestrator.deliberate(task, options?.signal);
+    }
+    async deliberateBerserk(task, options) {
+        await this.ensureInitialized();
+        const result = await this.berserkOrchestrator.deliberate(task, options?.signal);
+        // Record berserk results in engram memory (same as normal deliberation post-processor)
+        fireAndForget(this.engramManager.recordDeliberation(result), 'berserk.engram.record');
+        return result;
+    }
+    on(event, listener) {
+        this.eventBus.on(event, listener);
+        return this;
+    }
+    once(event, listener) {
+        this.eventBus.once(event, listener);
+        return this;
+    }
+    off(event, listener) {
+        this.eventBus.off(event, listener);
+        return this;
+    }
+    getTokenSummary(deliberationId) {
+        return this.tokenTracker.summarize(deliberationId);
+    }
+    async loadAllTokens() {
+        return this.tokenTracker.loadAll();
+    }
+    getEventBus() {
+        return this.eventBus;
+    }
+    getEngramManager() {
+        return this.engramManager;
+    }
+    async getSystemStatus() {
+        await this.ensureInitialized();
+        const health = await this.adapters.healthCheckAll();
+        const allUnits = this.adapters.getAll().map(a => a.unit);
+        return {
+            units: allUnits.map(unit => ({
+                unit,
+                health: health.get(unit) ?? new Error('unknown'),
+                cableStatus: this.umbilicalCable.getStatus(unit),
+                syncRate: this.syncRateTracker.getRate(unit),
+            })),
+            atFieldStreak: this.atField.getUnanimousStreak(),
+        };
+    }
+    async healthCheck() {
+        await this.ensureInitialized();
+        const cliResults = await this.adapters.healthCheckAll();
+        const results = new Map();
+        for (const [unit, result] of cliResults) {
+            results.set(unit, result);
+        }
+        return results;
+    }
+}
+export { getDecisionProps, isApproval, isRejection, isUnanimous, isMajority, isDeadlock, getMajorityVote, } from './types/consensus.js';
+export { MagiEventBus } from './engine/events.js';
+export { StreamingProgressReporter } from './reporters/streaming.js';
+export { MagiTui } from './tui/index.js';
+// Phase K exports
+export { AngelDetector } from './engine/angel-detector.js';
+export { DeadSeaScrolls } from './engine/dead-sea-scrolls.js';
+export { NebuchadnezzarKey } from './engine/nebuchadnezzar-key.js';
+export { SelfDestructSequence } from './engine/self-destruct.js';
+export { Type666Firewall } from './engine/type666-firewall.js';
+// Phase L exports
+export { NeonGenesis } from './engine/neon-genesis.js';
+export { IruelBattleSystem } from './engine/iruel-battle.js';
+export { SelfEvolutionEngine } from './engine/self-evolution.js';
+export { SeeleCouncil } from './engine/seele-council.js';

package/dist/src/mcp/server.d.ts

@@ -0,0 +1,38 @@
+/**
+ * MAGI MCP Server
+ *
+ * Exposes the MAGI deliberation system as MCP tools:
+ *   magi_deliberate, magi_review, magi_decide, magi_doctor
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { MagiDeliberation } from '../types/core.js';
+export interface McpDeliberationSummary {
+    id: string;
+    decision: string;
+    method: string;
+    confidence: number;
+    summary: string;
+    dissent: Array<{
+        unit: string;
+        vote: string;
+        reasoning: string;
+    }>;
+    votes: {
+        approve: string[];
+        reject: string[];
+        abstain: string[];
+    };
+    rounds: number;
+    totalDurationMs: number;
+    fromCache: boolean;
+    opinions?: Array<{
+        unit: string;
+        vote: string;
+        confidence: number;
+        reasoning: string;
+        keyPoints: string[];
+        suggestions?: string[];
+    }>;
+}
+export declare function formatDeliberationForMcp(result: MagiDeliberation): string;
+export declare function createMagiMcpServer(): McpServer;

package/dist/src/mcp/server.js

@@ -0,0 +1,196 @@
+/**
+ * MAGI MCP Server
+ *
+ * Exposes the MAGI deliberation system as MCP tools:
+ *   magi_deliberate, magi_review, magi_decide, magi_doctor
+ */
+import { z } from 'zod/v4';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Magi } from '../index.js';
+import { detectLanguage } from '../utils/language-detector.js';
+import { collectProjectContext } from '../context/auto-collector.js';
+// ---------------------------------------------------------------------------
+// Error sanitization — strip file paths from MCP error responses
+// ---------------------------------------------------------------------------
+function sanitizeErrorMessage(error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return msg.replace(/(?:\/[\w.@-]+){2,}|(?:[A-Z]:\\[\w\\.-]+)+/g, '[path]');
+}
+// ---------------------------------------------------------------------------
+// Magi instance management
+// ---------------------------------------------------------------------------
+const magiCached = new Magi({ logLevel: 'warn' });
+let magiNoCache;
+function getMagi(noCache) {
+    if (!noCache)
+        return magiCached;
+    magiNoCache ??= new Magi({ logLevel: 'warn', cacheEnabled: false });
+    return magiNoCache;
+}
+export function formatDeliberationForMcp(result) {
+    const lastRound = result.rounds[result.rounds.length - 1];
+    const summary = {
+        id: result.id,
+        decision: result.consensus.decision,
+        method: result.consensus.method,
+        confidence: result.consensus.confidence,
+        summary: result.consensus.summary,
+        dissent: (result.consensus.dissent ?? []).map((d) => ({
+            unit: d.unit,
+            vote: d.vote,
+            reasoning: d.reasoning,
+        })),
+        votes: {
+            approve: result.consensus.votes.approve,
+            reject: result.consensus.votes.reject,
+            abstain: result.consensus.votes.abstain,
+        },
+        rounds: result.rounds.length,
+        totalDurationMs: result.totalDurationMs,
+        fromCache: result.fromCache ?? false,
+        opinions: lastRound
+            ? lastRound.opinions.map((o) => ({
+                unit: o.unit,
+                vote: o.vote,
+                confidence: o.confidence,
+                reasoning: o.reasoning,
+                keyPoints: o.keyPoints,
+                suggestions: o.suggestions,
+            }))
+            : undefined,
+    };
+    return JSON.stringify(summary, null, 2);
+}
+// ---------------------------------------------------------------------------
+// MCP Server factory
+// ---------------------------------------------------------------------------
+export function createMagiMcpServer() {
+    const server = new McpServer({
+        name: 'magi-system',
+        version: '0.1.0',
+    });
+    // -----------------------------------------------------------------------
+    // magi_deliberate
+    // -----------------------------------------------------------------------
+    server.tool('magi_deliberate', 'Run a MAGI deliberation — 3 AI CLIs (Claude/Codex/Gemini) discuss and vote on a topic. Takes 30-120 seconds.', {
+        prompt: z.string().max(50_000).describe('The topic or question to deliberate on'),
+        type: z.enum([
+            'code-review',
+            'architecture-decision',
+            'bug-analysis',
+            'implementation-plan',
+            'security-audit',
+            'custom',
+        ]).optional().describe('Task type (default: custom)'),
+        maxRounds: z.number().int().min(1).max(5).optional().describe('Maximum deliberation rounds (default: 3)'),
+        skipCrossExam: z.boolean().optional().describe('Skip cross-examination phase'),
+        noCache: z.boolean().optional().describe('Bypass deliberation cache'),
+    }, async (args) => {
+        try {
+            const taskType = args.type ?? 'custom';
+            const magi = getMagi(args.noCache ?? false);
+            const task = {
+                type: taskType,
+                title: args.prompt.slice(0, 200),
+                description: args.prompt,
+                config: {
+                    ...(args.maxRounds != null ? { maxRounds: args.maxRounds } : {}),
+                    ...(args.skipCrossExam
+                        ? { phases: ['initial-opinion', 'final-vote'] }
+                        : {}),
+                },
+            };
+            const result = await magi.deliberate(task);
+            return { content: [{ type: 'text', text: formatDeliberationForMcp(result) }] };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Deliberation failed: ${sanitizeErrorMessage(error)}` }], isError: true };
+        }
+    });
+    // -----------------------------------------------------------------------
+    // magi_review
+    // -----------------------------------------------------------------------
+    server.tool('magi_review', 'MAGI code review — 3 AIs independently review code and vote APPROVE/REJECT. Takes 30-120 seconds.', {
+        filePath: z.string().max(1_000).describe('File path being reviewed (for context)'),
+        content: z.string().max(200_000).describe('Code content to review'),
+        language: z.string().optional().describe('Programming language (auto-detected if omitted)'),
+        context: z.string().max(200_000).optional().describe('Additional context for the review'),
+    }, async (args) => {
+        try {
+            // Auto-detect language if not provided
+            const language = args.language ?? detectLanguage(args.filePath);
+            const task = {
+                type: 'code-review',
+                title: `Code review: ${args.filePath}`,
+                description: args.context
+                    ? `Review the following code.\n\nContext: ${args.context}`
+                    : 'Review the following code for correctness, security, and quality.',
+                artifacts: [
+                    {
+                        type: 'file',
+                        path: args.filePath,
+                        content: args.content,
+                        language,
+                    },
+                ],
+            };
+            const result = await getMagi(false).deliberate(task);
+            return { content: [{ type: 'text', text: formatDeliberationForMcp(result) }] };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Code review failed: ${sanitizeErrorMessage(error)}` }], isError: true };
+        }
+    });
+    // -----------------------------------------------------------------------
+    // magi_decide
+    // -----------------------------------------------------------------------
+    server.tool('magi_decide', 'MAGI architecture decision — 3 AIs evaluate a design question and vote. Takes 30-120 seconds.', {
+        question: z.string().max(50_000).describe('The architecture/design question to decide on'),
+        context: z.string().max(200_000).optional().describe('Additional context (constraints, requirements, etc.)'),
+    }, async (args) => {
+        try {
+            // Inject project context automatically
+            let fullContext = args.context ?? '';
+            try {
+                const projectCtx = await collectProjectContext();
+                if (projectCtx.charCount > 0) {
+                    fullContext = fullContext
+                        ? `${fullContext}\n\n${projectCtx.text}`
+                        : projectCtx.text;
+                }
+            }
+            catch { /* graceful degradation */ }
+            const task = {
+                type: 'architecture-decision',
+                title: args.question.slice(0, 200),
+                description: fullContext
+                    ? `${args.question}\n\nContext: ${fullContext}`
+                    : args.question,
+            };
+            const result = await getMagi(false).deliberate(task);
+            return { content: [{ type: 'text', text: formatDeliberationForMcp(result) }] };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Architecture decision failed: ${sanitizeErrorMessage(error)}` }], isError: true };
+        }
+    });
+    // -----------------------------------------------------------------------
+    // magi_doctor
+    // -----------------------------------------------------------------------
+    server.tool('magi_doctor', 'Check MAGI system health — verifies claude, codex, and gemini CLI availability.', {}, async () => {
+        try {
+            const results = await magiCached.healthCheck();
+            const status = {};
+            for (const [tool, result] of results) {
+                status[tool] = result instanceof Error ? `ERROR: ${result.message}` : result;
+            }
+            return {
+                content: [{ type: 'text', text: JSON.stringify(status, null, 2) }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Doctor check failed: ${sanitizeErrorMessage(error)}` }], isError: true };
+        }
+    });
+    return server;
+}