magi-ai 0.1.0

package/dist/src/tui/status-bar.js

@@ -0,0 +1,124 @@
+/**
+ * Bottom status bar renderer.
+ * Shows phase, round, elapsed time, and system indicators.
+ */
+import { BOX } from './layout.js';
+import { isApproval, isRejection } from '../types/consensus.js';
+import { EVA_PALETTE } from './colors.js';
+import { ATTR_BOLD, stringDisplayWidth, truncateToDisplayWidth } from './screen-buffer.js';
+import { phaseCode, formatElapsedMmSs } from './tui-helpers.js';
+// ── Status Bar Renderer ─────────────────────────────────────
+export class StatusBarRenderer {
+    drawStatusBar(buf, rect, data) {
+        const fc = EVA_PALETTE.frame;
+        const tc = EVA_PALETTE.textPrimary;
+        const tw = EVA_PALETTE.textSecondary;
+        const { row, col, width } = rect;
+        // Top separator line
+        buf.writeAt(row, col, BOX.lT, fc.r, fc.g, fc.b);
+        for (let x = col + 1; x < col + width - 1; x++) {
+            buf.writeAt(row, x, BOX.h, fc.r, fc.g, fc.b);
+        }
+        buf.writeAt(row, col + width - 1, BOX.rT, fc.r, fc.g, fc.b);
+        // Status content (row + 1)
+        const contentRow = row + 1;
+        // Clear content area
+        for (let x = col + 1; x < col + width - 1; x++) {
+            buf.writeAt(contentRow, x, ' ');
+        }
+        if (data.decision) {
+            // Final result
+            const decColor = isApproval(data.decision) ? EVA_PALETTE.approve
+                : isRejection(data.decision) ? EVA_PALETTE.reject
+                    : EVA_PALETTE.textSecondary;
+            if (data.showPrompt) {
+                // Decision + prompt on same line
+                const prompt = 'ANY KEY // 1-3 DETAIL';
+                const label = data.fromCache ? `${data.decision} (cached)` : data.decision;
+                const combined = `${label}  ${prompt}`;
+                const centered = Math.max(1, Math.floor((width - stringDisplayWidth(combined)) / 2));
+                buf.writeAt(contentRow, col + centered, label, decColor.r, decColor.g, decColor.b, 0, 0, 0, ATTR_BOLD);
+                const promptCol = col + centered + stringDisplayWidth(label) + 2;
+                const pc = EVA_PALETTE.frame;
+                buf.writeAt(contentRow, promptCol, prompt, pc.r, pc.g, pc.b);
+            }
+            else {
+                const label = data.fromCache ? `${data.decision} (cached)` : data.decision;
+                const centered = Math.max(1, Math.floor((width - stringDisplayWidth(label)) / 2));
+                buf.writeAt(contentRow, col + centered, label, decColor.r, decColor.g, decColor.b, 0, 0, 0, ATTR_BOLD);
+            }
+        }
+        else {
+            // Progress info
+            const elapsed = formatElapsedMmSs(data.elapsedMs);
+            const { left, middle, right } = buildProgressSegments(width, {
+                phase: data.phase,
+                roundNumber: data.roundNumber,
+                maxRounds: data.maxRounds,
+                elapsed,
+                atFieldLevel: data.atFieldLevel,
+                syncSummary: data.syncSummary,
+                modeLabel: data.modeLabel,
+                umbilicalStatus: data.umbilicalStatus,
+                alertCode: data.alertCode ?? data.warning ?? 'ALERT:NONE',
+            });
+            buf.writeAt(contentRow, col + 2, left, tc.r, tc.g, tc.b);
+            const middleCol = col + 2 + stringDisplayWidth(left) + 2;
+            if (middle) {
+                buf.writeAt(contentRow, middleCol, middle, tw.r, tw.g, tw.b);
+            }
+            const rightColor = right === 'ALERT NONE' || right === 'ALERT:NONE' ? tc : EVA_PALETTE.warning;
+            const rightCol = Math.max(col + 2, col + width - stringDisplayWidth(right) - 2);
+            buf.writeAt(contentRow, rightCol, right, rightColor.r, rightColor.g, rightColor.b, 0, 0, 0, ATTR_BOLD);
+        }
+    }
+}
+function buildProgressSegments(width, data) {
+    const phase = phaseCode(data.phase, 'STBY');
+    const atf = data.atFieldLevel !== undefined
+        ? data.atFieldLevel === 'MAX' ? 'AT MAX' : `AT L${data.atFieldLevel}`
+        : 'AT STB';
+    const sync = data.syncSummary ? `SYNC ${data.syncSummary}` : 'SYNC --';
+    const mode = data.modeLabel ? `MODE ${data.modeLabel}` : 'MODE NORMAL';
+    const cable = data.umbilicalStatus ? `UMB ${data.umbilicalStatus}` : 'UMB CONNECTED';
+    const alert = normalizeAlert(data.alertCode);
+    const leftVariants = [
+        `PHASE ${phase}  ROUND ${data.roundNumber}/${data.maxRounds}  ELAPSED ${data.elapsed}`,
+        `PH ${phase}  R ${data.roundNumber}/${data.maxRounds}  T ${data.elapsed}`,
+    ];
+    const middleVariants = [
+        `${mode}  ${sync}`,
+        `${mode}`,
+        '',
+    ];
+    const rightVariants = [
+        `${atf}  ${cable}  ${alert}`,
+        `${atf}  ${alert}`,
+        `${alert}`,
+    ];
+    for (const leftCandidate of leftVariants) {
+        for (const middleCandidate of middleVariants) {
+            for (const rightCandidate of rightVariants) {
+                const totalWidth = stringDisplayWidth(leftCandidate)
+                    + stringDisplayWidth(middleCandidate || '')
+                    + stringDisplayWidth(rightCandidate)
+                    + (middleCandidate ? 4 : 2);
+                if (totalWidth <= Math.max(10, width - 4)) {
+                    return {
+                        left: leftCandidate,
+                        middle: middleCandidate,
+                        right: rightCandidate,
+                    };
+                }
+            }
+        }
+    }
+    return {
+        left: truncateToDisplayWidth(leftVariants[leftVariants.length - 1], Math.max(12, Math.floor(width * 0.45))),
+        middle: '',
+        right: truncateToDisplayWidth(rightVariants[rightVariants.length - 1], Math.max(10, Math.floor(width * 0.3))),
+    };
+}
+function normalizeAlert(alertCode) {
+    return alertCode.replace(/:/g, ' ').replace(/\s+/g, ' ').trim();
+}

package/dist/src/tui/terminal-detect.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Terminal capability detection for TUI mode.
+ */
+import { type TuiProfile } from './layout.js';
+export declare const MIN_COLS = 80;
+export declare const MIN_ROWS = 24;
+export interface TerminalCapabilities {
+    readonly cols: number;
+    readonly rows: number;
+    readonly trueColor: boolean;
+    readonly color256: boolean;
+    readonly unicode: boolean;
+    readonly isTTY: boolean;
+    readonly profile: TuiProfile;
+}
+export declare function getTerminalSize(): {
+    cols: number;
+    rows: number;
+};
+export declare function detectCapabilities(): TerminalCapabilities;
+/**
+ * Check if the terminal meets minimum TUI requirements.
+ * Returns a failure reason string, or null if capable.
+ */
+export declare function tuiCheckFailure(caps: TerminalCapabilities): string | null;
+export declare function isTuiCapable(caps: TerminalCapabilities): boolean;

package/dist/src/tui/terminal-detect.js

@@ -0,0 +1,44 @@
+/**
+ * Terminal capability detection for TUI mode.
+ */
+import chalk from 'chalk';
+import { getTuiProfile } from './layout.js';
+// ── Minimum requirements ────────────────────────────────────
+export const MIN_COLS = 80;
+export const MIN_ROWS = 24;
+// ── Detection ───────────────────────────────────────────────
+export function getTerminalSize() {
+    return {
+        cols: process.stdout.columns ?? 80,
+        rows: process.stdout.rows ?? 24,
+    };
+}
+export function detectCapabilities() {
+    const { cols, rows } = getTerminalSize();
+    const lang = process.env['LC_ALL'] ?? process.env['LC_CTYPE'] ?? process.env['LANG'] ?? '';
+    return {
+        cols,
+        rows,
+        trueColor: chalk.level >= 3,
+        color256: chalk.level >= 2,
+        unicode: /utf-?8/i.test(lang),
+        isTTY: process.stdout.isTTY === true,
+        profile: getTuiProfile(cols, rows),
+    };
+}
+/**
+ * Check if the terminal meets minimum TUI requirements.
+ * Returns a failure reason string, or null if capable.
+ */
+export function tuiCheckFailure(caps) {
+    if (!caps.isTTY) {
+        return 'stdout is not a TTY';
+    }
+    if (caps.cols < MIN_COLS || caps.rows < MIN_ROWS) {
+        return `Terminal too small (${caps.cols}x${caps.rows}, need ${MIN_COLS}x${MIN_ROWS})`;
+    }
+    return null;
+}
+export function isTuiCapable(caps) {
+    return tuiCheckFailure(caps) === null;
+}

package/dist/src/tui/tui-helpers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Shared helper functions for TUI renderers.
+ * Single source of truth for logic previously duplicated across magi-tui.ts, header.ts, status-bar.ts, panel.ts.
+ */
+/** Derive a compact source label for the header display. */
+export declare function deriveSourceLabel(taskType: string, taskTitle: string): string;
+/** Derive a priority label from task type. */
+export declare function derivePriorityLabel(taskType: string): string;
+/** Convert phase name to compact 3-4 char code. */
+export declare function phaseCode(phase: string, defaultCode?: string): string;
+/** Format milliseconds as MM:SS. */
+export declare function formatElapsedMmSs(ms: number): string;

package/dist/src/tui/tui-helpers.js

@@ -0,0 +1,37 @@
+/**
+ * Shared helper functions for TUI renderers.
+ * Single source of truth for logic previously duplicated across magi-tui.ts, header.ts, status-bar.ts, panel.ts.
+ */
+/** Derive a compact source label for the header display. */
+export function deriveSourceLabel(taskType, taskTitle) {
+    if (taskType === 'code-review' && taskTitle.startsWith('Code Review: ')) {
+        return taskTitle.slice('Code Review: '.length);
+    }
+    return `NERV://${taskType}`;
+}
+/** Derive a priority label from task type. */
+export function derivePriorityLabel(taskType) {
+    switch (taskType) {
+        case 'security-audit': return 'AAA';
+        case 'code-review': return 'AA';
+        case 'bug-analysis': return 'A+';
+        case 'architecture-decision': return 'A';
+        default: return 'B';
+    }
+}
+/** Convert phase name to compact 3-4 char code. */
+export function phaseCode(phase, defaultCode = 'MAGI') {
+    switch (phase) {
+        case 'initial-opinion': return 'IOP';
+        case 'cross-examination': return 'XAM';
+        case 'final-vote': return 'VOTE';
+        default: return phase ? phase.toUpperCase().slice(0, 4) : defaultCode;
+    }
+}
+/** Format milliseconds as MM:SS. */
+export function formatElapsedMmSs(ms) {
+    const totalSec = Math.floor(ms / 1000);
+    const min = Math.floor(totalSec / 60);
+    const sec = totalSec % 60;
+    return `${String(min).padStart(2, '0')}:${String(sec).padStart(2, '0')}`;
+}

package/dist/src/types/adapter.d.ts

@@ -0,0 +1,75 @@
+import type { MagiUnit, CliTool, ExecutionMeta } from './core.js';
+import { z } from 'zod/v4';
+/** Zod schema for binaryPath validation — rejects ".." segments and unknown basenames */
+export declare const binaryPathSchema: z.ZodString;
+/** Zod schema for adapter configuration validation */
+export declare const AdapterConfigSchema: z.ZodObject<{
+    binaryPath: z.ZodOptional<z.ZodString>;
+    timeoutMs: z.ZodNumber;
+    maxRetries: z.ZodNumber;
+    cwd: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    model: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Configuration for a CLI adapter */
+export interface AdapterConfig {
+    binaryPath?: string;
+    timeoutMs: number;
+    maxRetries: number;
+    cwd?: string;
+    env?: Record<string, string>;
+    model?: string;
+}
+/** Request to send to a CLI adapter */
+export interface AdapterRequest {
+    prompt: string;
+    systemPrompt?: string;
+    jsonSchema?: Record<string, unknown>;
+    maxBudgetUsd?: number;
+    timeoutMs?: number;
+    cwd?: string;
+    contextFiles?: string[];
+    onStdoutChunk?: (chunk: string) => void;
+    onStderrChunk?: (chunk: string) => void;
+    signal?: AbortSignal;
+    /** When true, adapters may enable file-reading tools/flags */
+    fileAccessEnabled?: boolean;
+}
+/** Response from a CLI adapter */
+export interface AdapterResponse {
+    structured: Record<string, unknown> | null;
+    raw: string;
+    meta: ExecutionMeta;
+    parsed: boolean;
+}
+/** Known error codes from CLI adapters */
+export type AdapterErrorCode = 'TIMEOUT' | 'CRASH' | 'PARSE_ERROR' | 'BINARY_NOT_FOUND' | 'UNKNOWN';
+/** Error from a CLI adapter */
+export declare class AdapterError extends Error {
+    readonly unit: MagiUnit;
+    readonly tool: CliTool;
+    readonly code: AdapterErrorCode;
+    readonly stderr?: string;
+    readonly exitCode?: number;
+    readonly partialOutput?: string;
+    constructor(opts: {
+        unit: MagiUnit;
+        tool: CliTool;
+        code: AdapterErrorCode;
+        message: string;
+        stderr?: string;
+        exitCode?: number;
+        partialOutput?: string;
+    });
+}
+/** Abstract interface for CLI adapters */
+export interface ICliAdapter {
+    readonly unit: MagiUnit;
+    readonly tool: CliTool;
+    readonly displayName: string;
+    healthCheck(): Promise<string>;
+    execute(request: AdapterRequest): Promise<AdapterResponse>;
+    supportsStructuredOutput(): boolean;
+    supportsSystemPrompt(): boolean;
+    buildCommand(request: AdapterRequest): string[];
+}

package/dist/src/types/adapter.js

@@ -0,0 +1,36 @@
+import { z } from 'zod/v4';
+/** Known binary basenames for MAGI adapters */
+const KNOWN_BINARIES = new Set(['claude', 'codex', 'gemini']);
+/** Zod schema for binaryPath validation — rejects ".." segments and unknown basenames */
+export const binaryPathSchema = z.string()
+    .refine(p => !p.split('/').includes('..'), 'binaryPath must not contain ".." segments')
+    .refine(p => KNOWN_BINARIES.has(p.split('/').pop() ?? ''), 'binaryPath basename must be claude, codex, or gemini');
+/** Zod schema for adapter configuration validation */
+export const AdapterConfigSchema = z.object({
+    binaryPath: binaryPathSchema.optional(),
+    timeoutMs: z.number().int().min(1_000).max(600_000),
+    maxRetries: z.number().int().min(0).max(5),
+    cwd: z.string().optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    model: z.string().optional(),
+});
+/** Error from a CLI adapter */
+export class AdapterError extends Error {
+    unit;
+    tool;
+    code;
+    stderr;
+    exitCode;
+    partialOutput;
+    constructor(opts) {
+        super(opts.message);
+        this.name = 'AdapterError';
+        this.unit = opts.unit;
+        this.tool = opts.tool;
+        this.code = opts.code;
+        this.stderr = opts.stderr;
+        this.exitCode = opts.exitCode;
+        this.partialOutput = opts.partialOutput;
+        Error.captureStackTrace?.(this, AdapterError);
+    }
+}

package/dist/src/types/config.d.ts

@@ -0,0 +1,108 @@
+import { z } from 'zod/v4';
+import type { BuiltinMagiUnit } from './core.js';
+import type { AdapterConfig } from './adapter.js';
+import type { PipelineConfig } from './pipeline.js';
+import type { AuditLogConfig } from '../audit/types.js';
+/**
+ * Adapter map: built-in units are guaranteed present, additional custom units allowed.
+ * This ensures `config.adapters.MELCHIOR` etc. are non-undefined while supporting N-body.
+ */
+export type AdapterMap = Record<BuiltinMagiUnit, AdapterConfig> & Record<string, AdapterConfig>;
+/** Configuration for CLI file access during deliberation */
+export interface FileAccessConfig {
+    enabled: boolean;
+    /** Glob patterns for allowed paths (default: all in cwd) */
+    allowedPaths?: string[];
+    /** Glob patterns to deny (default: .env, *.key, credentials*, etc.) */
+    deniedPatterns?: string[];
+}
+/** Top-level MAGI system configuration */
+export interface MagiConfig {
+    adapters: AdapterMap;
+    defaultPipeline: PipelineConfig;
+    workspaceDir: string;
+    logLevel: 'debug' | 'info' | 'warn' | 'error';
+    outputFormat: 'console' | 'json' | 'markdown';
+    preserveWorkspace: boolean;
+    maxConcurrentDeliberations: number;
+    cacheEnabled?: boolean;
+    cacheTtlMs?: number;
+    auditLog?: AuditLogConfig;
+    /** Which units to enable. undefined = all 3 built-in units. */
+    enabledUnits?: BuiltinMagiUnit[];
+    /** CLI file access during deliberation. Default: disabled. */
+    fileAccess?: FileAccessConfig;
+}
+/** Zod schema for MagiConfig validation */
+export declare const MagiConfigSchema: z.ZodObject<{
+    adapters: z.ZodRecord<z.ZodString, z.ZodObject<{
+        binaryPath: z.ZodOptional<z.ZodString>;
+        timeoutMs: z.ZodNumber;
+        maxRetries: z.ZodNumber;
+        cwd: z.ZodOptional<z.ZodString>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    defaultPipeline: z.ZodObject<{
+        phases: z.ZodArray<z.ZodEnum<{
+            "initial-opinion": "initial-opinion";
+            "cross-examination": "cross-examination";
+            "final-vote": "final-vote";
+        }>>;
+        maxRounds: z.ZodNumber;
+        parallelInitialOpinions: z.ZodBoolean;
+        earlyConsensusExit: z.ZodBoolean;
+        earlyExitThresholds: z.ZodOptional<z.ZodObject<{
+            unanimous: z.ZodNumber;
+            majority: z.ZodNumber;
+        }, z.core.$strip>>;
+        consensus: z.ZodObject<{
+            minConfidenceThreshold: z.ZodNumber;
+            useWeightedVoting: z.ZodBoolean;
+            unitWeights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+            deadlockStrategy: z.ZodEnum<{
+                escalate: "escalate";
+                "melchior-tiebreak": "melchior-tiebreak";
+                "highest-confidence": "highest-confidence";
+                "human-in-the-loop": "human-in-the-loop";
+            }>;
+            quorum: z.ZodNumber;
+        }, z.core.$strip>;
+        phaseTimeoutMs: z.ZodNumber;
+        adapterTimeoutMs: z.ZodNumber;
+        deliberationTimeoutMs: z.ZodNumber;
+    }, z.core.$strip>;
+    workspaceDir: z.ZodString;
+    logLevel: z.ZodEnum<{
+        error: "error";
+        debug: "debug";
+        info: "info";
+        warn: "warn";
+    }>;
+    outputFormat: z.ZodEnum<{
+        json: "json";
+        console: "console";
+        markdown: "markdown";
+    }>;
+    preserveWorkspace: z.ZodBoolean;
+    maxConcurrentDeliberations: z.ZodNumber;
+    cacheEnabled: z.ZodOptional<z.ZodBoolean>;
+    cacheTtlMs: z.ZodOptional<z.ZodNumber>;
+    enabledUnits: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        MELCHIOR: "MELCHIOR";
+        BALTHASAR: "BALTHASAR";
+        CASPER: "CASPER";
+    }>>>;
+    fileAccess: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        allowedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        deniedPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    auditLog: z.ZodOptional<z.ZodObject<{
+        logDir: z.ZodString;
+        maxFileSize: z.ZodOptional<z.ZodNumber>;
+        maxFiles: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** Default configuration */
+export declare const DEFAULT_CONFIG: Readonly<MagiConfig>;

package/dist/src/types/config.js

@@ -0,0 +1,85 @@
+import { z } from 'zod/v4';
+import { binaryPathSchema } from './adapter.js';
+import { deepFreeze } from '../utils/freeze.js';
+/** Zod schema for MagiConfig validation */
+export const MagiConfigSchema = z.object({
+    adapters: z.record(z.string(), z.object({
+        binaryPath: binaryPathSchema.optional(),
+        timeoutMs: z.number().int().min(1_000).max(600_000),
+        maxRetries: z.number().int().min(0).max(5),
+        cwd: z.string().optional(),
+        env: z.record(z.string(), z.string()).optional(),
+        model: z.string().optional(),
+    })),
+    defaultPipeline: z.object({
+        phases: z.array(z.enum(['initial-opinion', 'cross-examination', 'final-vote'])).min(1),
+        maxRounds: z.number().int().min(1).max(10),
+        parallelInitialOpinions: z.boolean(),
+        earlyConsensusExit: z.boolean(),
+        earlyExitThresholds: z.object({
+            unanimous: z.number().min(0).max(1),
+            majority: z.number().min(0).max(1),
+        }).optional(),
+        consensus: z.object({
+            minConfidenceThreshold: z.number().min(0).max(1),
+            useWeightedVoting: z.boolean(),
+            unitWeights: z.record(z.string(), z.number()).optional(),
+            deadlockStrategy: z.enum(['escalate', 'melchior-tiebreak', 'highest-confidence', 'human-in-the-loop']),
+            quorum: z.number().int().min(1).max(7),
+        }),
+        phaseTimeoutMs: z.number().int().min(1_000).max(3_600_000),
+        adapterTimeoutMs: z.number().int().min(1_000).max(600_000),
+        deliberationTimeoutMs: z.number().int().min(10_000).max(7_200_000),
+    }),
+    workspaceDir: z.string().min(1),
+    logLevel: z.enum(['debug', 'info', 'warn', 'error']),
+    outputFormat: z.enum(['console', 'json', 'markdown']),
+    preserveWorkspace: z.boolean(),
+    maxConcurrentDeliberations: z.number().int().min(1).max(10),
+    cacheEnabled: z.boolean().optional(),
+    cacheTtlMs: z.number().int().min(0).max(86_400_000).optional(),
+    enabledUnits: z.array(z.enum(['MELCHIOR', 'BALTHASAR', 'CASPER'])).min(1).max(3).optional(),
+    fileAccess: z.object({
+        enabled: z.boolean(),
+        allowedPaths: z.array(z.string()).optional(),
+        deniedPatterns: z.array(z.string()).optional(),
+    }).optional(),
+    auditLog: z.object({
+        logDir: z.string().min(1),
+        maxFileSize: z.number().int().min(1024).optional(),
+        maxFiles: z.number().int().min(1).max(100).optional(),
+    }).optional(),
+});
+/** Default configuration */
+export const DEFAULT_CONFIG = deepFreeze({
+    adapters: {
+        MELCHIOR: { timeoutMs: 120_000, maxRetries: 2 },
+        BALTHASAR: { timeoutMs: 120_000, maxRetries: 2 },
+        CASPER: { timeoutMs: 120_000, maxRetries: 2 },
+    },
+    defaultPipeline: {
+        phases: ['initial-opinion', 'cross-examination', 'final-vote'],
+        maxRounds: 3,
+        parallelInitialOpinions: true,
+        earlyConsensusExit: true,
+        earlyExitThresholds: { unanimous: 0.7, majority: 0.85 },
+        consensus: {
+            minConfidenceThreshold: 0.3,
+            useWeightedVoting: false,
+            deadlockStrategy: 'melchior-tiebreak',
+            quorum: 2,
+        },
+        phaseTimeoutMs: 300_000,
+        adapterTimeoutMs: 120_000,
+        deliberationTimeoutMs: 1_800_000,
+    },
+    workspaceDir: '.magi',
+    logLevel: 'info',
+    outputFormat: 'console',
+    preserveWorkspace: false,
+    maxConcurrentDeliberations: 3,
+    fileAccess: { enabled: false },
+    auditLog: {
+        logDir: '.magi/audit',
+    },
+});

package/dist/src/types/consensus.d.ts

@@ -0,0 +1,55 @@
+import type { MagiUnit, Vote, Confidence } from './core.js';
+/** Result of consensus calculation */
+export interface ConsensusResult {
+    decision: ConsensusDecision;
+    method: ConsensusMethod;
+    votes: VoteSummary;
+    confidence: Confidence;
+    summary: string;
+    dissent?: DissentRecord[];
+}
+/** Possible consensus outcomes */
+export type ConsensusDecision = 'UNANIMOUS_APPROVE' | 'MAJORITY_APPROVE' | 'UNANIMOUS_REJECT' | 'MAJORITY_REJECT' | 'DEADLOCK' | 'INSUFFICIENT';
+/** Type-safe decision property helpers */
+export interface DecisionProperties {
+    readonly isApproval: boolean;
+    readonly isRejection: boolean;
+    readonly isUnanimous: boolean;
+    readonly isMajority: boolean;
+    readonly isDeadlock: boolean;
+    readonly isInsufficient: boolean;
+    readonly majorityVote: 'APPROVE' | 'REJECT' | 'ABSTAIN';
+}
+export declare function getDecisionProps(decision: ConsensusDecision): DecisionProperties;
+export declare function isApproval(d: ConsensusDecision): boolean;
+export declare function isRejection(d: ConsensusDecision): boolean;
+export declare function isUnanimous(d: ConsensusDecision): boolean;
+export declare function isMajority(d: ConsensusDecision): boolean;
+export declare function isDeadlock(d: ConsensusDecision): boolean;
+export declare function getMajorityVote(d: ConsensusDecision): 'APPROVE' | 'REJECT' | 'ABSTAIN';
+/** How the consensus was reached */
+export type ConsensusMethod = 'unanimous' | 'majority' | 'weighted' | 'tiebreak' | 'escalated' | 'human';
+/** Vote breakdown */
+export interface VoteSummary {
+    approve: MagiUnit[];
+    reject: MagiUnit[];
+    abstain: MagiUnit[];
+    weightedApprove: number;
+    weightedReject: number;
+}
+/** Record of a dissenting opinion */
+export interface DissentRecord {
+    unit: MagiUnit;
+    vote: Vote;
+    reasoning: string;
+}
+/** Configuration for the consensus engine */
+export interface ConsensusConfig {
+    minConfidenceThreshold: Confidence;
+    useWeightedVoting: boolean;
+    unitWeights?: Partial<Record<MagiUnit, number>>;
+    deadlockStrategy: 'escalate' | 'melchior-tiebreak' | 'highest-confidence' | 'human-in-the-loop';
+    quorum: number;
+    /** Units to exclude from UNANIMOUS judgment (e.g., dummy plug units) */
+    excludeFromUnanimous?: MagiUnit[];
+}

package/dist/src/types/consensus.js

@@ -0,0 +1,17 @@
+const DECISION_PROPERTIES = {
+    UNANIMOUS_APPROVE: { isApproval: true, isRejection: false, isUnanimous: true, isMajority: false, isDeadlock: false, isInsufficient: false, majorityVote: 'APPROVE' },
+    MAJORITY_APPROVE: { isApproval: true, isRejection: false, isUnanimous: false, isMajority: true, isDeadlock: false, isInsufficient: false, majorityVote: 'APPROVE' },
+    UNANIMOUS_REJECT: { isApproval: false, isRejection: true, isUnanimous: true, isMajority: false, isDeadlock: false, isInsufficient: false, majorityVote: 'REJECT' },
+    MAJORITY_REJECT: { isApproval: false, isRejection: true, isUnanimous: false, isMajority: true, isDeadlock: false, isInsufficient: false, majorityVote: 'REJECT' },
+    DEADLOCK: { isApproval: false, isRejection: false, isUnanimous: false, isMajority: false, isDeadlock: true, isInsufficient: false, majorityVote: 'ABSTAIN' },
+    INSUFFICIENT: { isApproval: false, isRejection: false, isUnanimous: false, isMajority: false, isDeadlock: false, isInsufficient: true, majorityVote: 'ABSTAIN' },
+};
+export function getDecisionProps(decision) {
+    return DECISION_PROPERTIES[decision];
+}
+export function isApproval(d) { return DECISION_PROPERTIES[d].isApproval; }
+export function isRejection(d) { return DECISION_PROPERTIES[d].isRejection; }
+export function isUnanimous(d) { return DECISION_PROPERTIES[d].isUnanimous; }
+export function isMajority(d) { return DECISION_PROPERTIES[d].isMajority; }
+export function isDeadlock(d) { return DECISION_PROPERTIES[d].isDeadlock; }
+export function getMajorityVote(d) { return DECISION_PROPERTIES[d].majorityVote; }