magi-ai 0.1.0

package/dist/src/engine/objective-judge.js

@@ -0,0 +1,214 @@
+import { logger } from '../utils/logger.js';
+/** Weights for each tool in the composite score */
+const TOOL_WEIGHTS = {
+    tsc: 0.4,
+    eslint: 0.2,
+    vitest: 0.4,
+};
+/**
+ * ObjectiveJudge: runs static analysis and tests to produce an objective
+ * quality score that supplements the subjective AI opinions.
+ *
+ * Graceful degradation: if a tool is not available, it's skipped and
+ * the score is calculated from available tools only.
+ */
+export class ObjectiveJudge {
+    cwd;
+    runCommand;
+    constructor(cwd, runCommand) {
+        this.cwd = cwd;
+        this.runCommand = runCommand ?? ObjectiveJudge.defaultRunCommand;
+    }
+    static async defaultRunCommand(cmd, args, cwd) {
+        const { spawnProcess } = await import('../utils/process.js');
+        const result = await spawnProcess({ command: cmd, args, cwd, timeoutMs: 120_000 });
+        return { stdout: result.stdout, stderr: result.stderr, exitCode: result.exitCode };
+    }
+    async evaluate() {
+        const results = await Promise.allSettled([
+            this.runTsc(),
+            this.runEslint(),
+            this.runVitest(),
+        ]);
+        const toolNames = ['tsc', 'eslint', 'vitest'];
+        const tools = results.map((r, i) => {
+            const toolName = toolNames[i];
+            if (r.status === 'fulfilled')
+                return r.value;
+            logger.warn(`ObjectiveJudge: ${toolName} failed`, { error: String(r.reason) });
+            return {
+                tool: toolName,
+                available: false,
+                passed: false,
+                issues: [],
+                summary: `${toolName} failed to run: ${String(r.reason)}`,
+            };
+        });
+        const score = this.calculateScore(tools);
+        const summary = this.buildSummary(tools, score);
+        return {
+            score,
+            tools,
+            summary,
+            evaluatedAt: new Date(),
+        };
+    }
+    calculateScore(tools) {
+        const available = tools.filter(t => t.available);
+        if (available.length === 0)
+            return 0.5; // No tools available -> neutral score
+        const totalWeight = available.reduce((sum, t) => sum + TOOL_WEIGHTS[t.tool], 0);
+        const weightedSum = available.reduce((sum, t) => {
+            const errorCount = t.issues.filter(i => i.severity === 'error').length;
+            const toolScore = t.passed ? 1.0 : Math.max(0, 1.0 - errorCount * 0.1);
+            return sum + toolScore * TOOL_WEIGHTS[t.tool];
+        }, 0);
+        return Math.max(0, Math.min(1, weightedSum / totalWeight));
+    }
+    buildSummary(tools, score) {
+        const lines = [`Objective Score: ${(score * 100).toFixed(1)}%`];
+        for (const t of tools) {
+            const status = !t.available ? 'N/A' : t.passed ? 'PASS' : 'FAIL';
+            const issueCount = t.issues.length;
+            lines.push(`  ${t.tool}: ${status}${issueCount > 0 ? ` (${issueCount} issues)` : ''}`);
+        }
+        return lines.join('\n');
+    }
+    // ---- Tool runners ----
+    async runTsc() {
+        try {
+            const result = await this.runCommand('./node_modules/.bin/tsc', ['--noEmit', '--pretty', 'false'], this.cwd);
+            const issues = this.parseTscOutput(result.stdout + result.stderr);
+            return {
+                tool: 'tsc',
+                available: true,
+                passed: result.exitCode === 0,
+                issues,
+                summary: result.exitCode === 0 ? 'No type errors' : `${issues.length} type error(s)`,
+                rawOutput: (result.stdout + result.stderr).slice(0, 5000),
+            };
+        }
+        catch (err) {
+            logger.debug('ObjectiveJudge: tsc execution failed', { error: String(err) });
+            return { tool: 'tsc', available: false, passed: false, issues: [], summary: 'tsc not available' };
+        }
+    }
+    async runEslint() {
+        try {
+            const result = await this.runCommand('./node_modules/.bin/eslint', ['.', '--format', 'json', '--no-error-on-unmatched-pattern'], this.cwd);
+            const issues = this.parseEslintOutput(result.stdout);
+            return {
+                tool: 'eslint',
+                available: true,
+                passed: result.exitCode === 0,
+                issues,
+                summary: result.exitCode === 0 ? 'No lint issues' : `${issues.length} lint issue(s)`,
+                rawOutput: result.stdout.slice(0, 5000),
+            };
+        }
+        catch (err) {
+            logger.debug('ObjectiveJudge: eslint execution failed', { error: String(err) });
+            return { tool: 'eslint', available: false, passed: false, issues: [], summary: 'eslint not available' };
+        }
+    }
+    async runVitest() {
+        try {
+            const result = await this.runCommand('./node_modules/.bin/vitest', ['run', '--reporter=json'], this.cwd);
+            const issues = this.parseVitestOutput(result.stdout);
+            return {
+                tool: 'vitest',
+                available: true,
+                passed: result.exitCode === 0,
+                issues,
+                summary: result.exitCode === 0 ? 'All tests passed' : `${issues.length} test failure(s)`,
+                rawOutput: result.stdout.slice(0, 5000),
+            };
+        }
+        catch (err) {
+            logger.debug('ObjectiveJudge: vitest execution failed', { error: String(err) });
+            return { tool: 'vitest', available: false, passed: false, issues: [], summary: 'vitest not available' };
+        }
+    }
+    // ---- Output parsers ----
+    parseTscOutput(output) {
+        const issues = [];
+        // tsc format: file(line,col): error TSxxxx: message
+        const re = /^(.+?)\((\d+),\d+\):\s*(error|warning)\s+TS\d+:\s*(.+)$/gm;
+        let match;
+        while ((match = re.exec(output)) !== null) {
+            issues.push({
+                file: match[1],
+                line: parseInt(match[2], 10),
+                severity: match[3],
+                message: match[4],
+                rule: undefined,
+            });
+        }
+        return issues;
+    }
+    parseEslintOutput(output) {
+        const issues = [];
+        try {
+            const parsed = JSON.parse(output);
+            if (Array.isArray(parsed)) {
+                for (const file of parsed) {
+                    for (const msg of file.messages ?? []) {
+                        issues.push({
+                            file: file.filePath,
+                            line: msg.line,
+                            severity: msg.severity === 2 ? 'error' : 'warning',
+                            message: msg.message,
+                            rule: msg.ruleId ?? undefined,
+                        });
+                    }
+                }
+            }
+        }
+        catch (err) {
+            logger.debug('ObjectiveJudge: eslint JSON parse failed, trying line-based', { error: String(err) });
+            const re = /^\s*(\d+):(\d+)\s+(error|warning)\s+(.+?)\s+(\S+)$/gm;
+            let match;
+            while ((match = re.exec(output)) !== null) {
+                issues.push({
+                    line: parseInt(match[1], 10),
+                    severity: match[3],
+                    message: match[4],
+                    rule: match[5],
+                });
+            }
+        }
+        return issues;
+    }
+    parseVitestOutput(output) {
+        const issues = [];
+        try {
+            const parsed = JSON.parse(output);
+            if (parsed.testResults && Array.isArray(parsed.testResults)) {
+                for (const suite of parsed.testResults) {
+                    for (const test of suite.assertionResults ?? []) {
+                        if (test.status === 'failed') {
+                            issues.push({
+                                file: suite.name,
+                                severity: 'error',
+                                message: test.fullName ?? test.title ?? 'Test failed',
+                                rule: undefined,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            logger.debug('ObjectiveJudge: vitest JSON parse failed, trying FAIL line scan', { error: String(err) });
+            const re = /FAIL\s+(.+)/g;
+            let match;
+            while ((match = re.exec(output)) !== null) {
+                issues.push({
+                    severity: 'error',
+                    message: `Test suite failed: ${match[1]}`,
+                });
+            }
+        }
+        return issues;
+    }
+}

package/dist/src/engine/offline-mode.d.ts

@@ -0,0 +1,18 @@
+/**
+ * B-09 オフラインモード (OfflineMode)
+ *
+ * 切断されたユニットの代替意見を生成する。
+ * DeliberationCacheから類似タスクを検索し、過去の意見をconfidence 0.5倍で再利用する。
+ * キャッシュミス時はABSTAIN (confidence=0.1) を返す。
+ */
+import type { MagiUnit, MagiOpinion, MagiTask } from '../types/core.js';
+import type { DeliberationCache } from '../cache/deliberation-cache.js';
+export declare class OfflineMode {
+    private readonly cache?;
+    constructor(cache?: DeliberationCache | undefined);
+    /**
+     * Generate a fallback opinion for a disconnected unit.
+     * Searches cache for a similar task and uses the unit's previous opinion.
+     */
+    generateFallbackOpinion(unit: MagiUnit, task: MagiTask): MagiOpinion;
+}

package/dist/src/engine/offline-mode.js

@@ -0,0 +1,46 @@
+/**
+ * B-09 オフラインモード (OfflineMode)
+ *
+ * 切断されたユニットの代替意見を生成する。
+ * DeliberationCacheから類似タスクを検索し、過去の意見をconfidence 0.5倍で再利用する。
+ * キャッシュミス時はABSTAIN (confidence=0.1) を返す。
+ */
+import { createAbstainOpinion } from '../utils/abstain-factory.js';
+/** Confidence decay factor for cached opinions */
+const CONFIDENCE_DECAY = 0.5;
+/** Minimum confidence for ABSTAIN fallback */
+const ABSTAIN_CONFIDENCE = 0.1;
+export class OfflineMode {
+    cache;
+    constructor(cache) {
+        this.cache = cache;
+    }
+    /**
+     * Generate a fallback opinion for a disconnected unit.
+     * Searches cache for a similar task and uses the unit's previous opinion.
+     */
+    generateFallbackOpinion(unit, task) {
+        if (this.cache) {
+            const cached = this.cache.get(task);
+            if (cached) {
+                // Find the last round's opinion for this unit
+                const lastRound = cached.rounds[cached.rounds.length - 1];
+                const opinion = lastRound?.opinions.find(o => o.unit === unit);
+                if (opinion) {
+                    return {
+                        ...opinion,
+                        confidence: opinion.confidence * CONFIDENCE_DECAY,
+                        reasoning: `[OFFLINE] キャッシュから復元された意見 (confidence ${CONFIDENCE_DECAY}x減衰): ${opinion.reasoning}`,
+                        keyPoints: [`[OFFLINE] キャッシュ復元`, ...opinion.keyPoints],
+                        meta: {
+                            ...opinion.meta,
+                            durationMs: 0,
+                        },
+                    };
+                }
+            }
+        }
+        // Cache miss — return ABSTAIN
+        return createAbstainOpinion(unit, `[OFFLINE] ${unit} は切断中。キャッシュに該当する過去の審議結果なし。`, ['[OFFLINE] ユニット切断中', 'キャッシュミス — ABSTAIN'], { confidence: ABSTAIN_CONFIDENCE });
+    }
+}

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

@@ -0,0 +1,79 @@
+/**
+ * Orchestrator — Facade for the MAGI deliberation system.
+ *
+ * Delegates all deliberation logic to the kernel modules while
+ * preserving the same public API (OrchestratorOptions + deliberate()).
+ *
+ * Responsibilities retained here:
+ * - Task input validation (trust boundary)
+ * - Semaphore concurrency control
+ * - KernelDependencies assembly from OrchestratorOptions
+ */
+import type { MagiTask, MagiDeliberation } from '../types/core.js';
+import { AdapterRegistry } from '../adapters/registry.js';
+import { PipelineRegistry } from '../pipelines/registry.js';
+import { ContextManager } from '../context/manager.js';
+import type { DeliberationCache } from '../cache/deliberation-cache.js';
+import type { MagiEventBus } from './events.js';
+import type { TokenTracker } from '../metrics/token-tracker.js';
+import type { ObjectiveJudge } from './objective-judge.js';
+import type { SyncRateTracker } from './sync-rate.js';
+import type { ATField } from './at-field.js';
+import type { GospelChronicle } from './gospel.js';
+import type { UmbilicalCable } from './umbilical-cable.js';
+import type { DummyPlugSystem } from './dummy-plug.js';
+import type { OfflineMode } from './offline-mode.js';
+import type { EngramManager } from './engram-manager.js';
+import type { LCLManager } from './lcl-manager.js';
+import type { InstrumentalityEngine } from './instrumentality.js';
+import type { DriftDetector } from './drift-detector.js';
+import type { Type666Firewall } from './type666-firewall.js';
+import type { NebuchadnezzarKey } from './nebuchadnezzar-key.js';
+import type { IruelBattleSystem } from './iruel-battle.js';
+/** Options for constructing an Orchestrator */
+export interface OrchestratorOptions {
+    adapters: AdapterRegistry;
+    pipelines: PipelineRegistry;
+    contextManager: ContextManager;
+    maxConcurrentDeliberations?: number;
+    cache?: DeliberationCache;
+    eventBus?: MagiEventBus;
+    tokenTracker?: TokenTracker;
+    objectiveJudge?: ObjectiveJudge;
+    syncRateTracker?: SyncRateTracker;
+    atField?: ATField;
+    gospel?: GospelChronicle;
+    umbilicalCable?: UmbilicalCable;
+    dummyPlug?: DummyPlugSystem;
+    offlineMode?: OfflineMode;
+    engramManager?: EngramManager;
+    lclManager?: LCLManager;
+    instrumentality?: InstrumentalityEngine;
+    driftDetector?: DriftDetector;
+    type666Firewall?: Type666Firewall;
+    nebuchadnezzarKey?: NebuchadnezzarKey;
+    iruelBattle?: IruelBattleSystem;
+    /** Allow CLIs to read project files during deliberation */
+    fileAccessEnabled?: boolean;
+}
+/**
+ * The heart of the MAGI System.
+ *
+ * Orchestrates multi-round deliberation between N MAGI units (2-7):
+ * 1. Initial Opinion (parallel) - each unit forms independent opinion
+ * 2. Cross-Examination (parallel) - each unit reviews others' opinions
+ * 3. Final Vote (parallel) - definitive vote with full context
+ *
+ * Security hardening:
+ * - Task input validated at trust boundary via MagiTaskSchema
+ * - Opinion output validated via SafeOpinionSchema (control chars stripped, size capped)
+ * - Concurrency limited by semaphore to prevent resource exhaustion
+ * - Phase-level and deliberation-level timeouts enforced
+ * - All lifecycle events emitted to audit log and event bus (fire-and-forget)
+ */
+export declare class Orchestrator {
+    private readonly semaphore;
+    private readonly kernel;
+    constructor(options: OrchestratorOptions);
+    deliberate(task: MagiTask, signal?: AbortSignal): Promise<MagiDeliberation>;
+}

package/dist/src/engine/orchestrator.js

@@ -0,0 +1,58 @@
+import { MagiTaskSchema } from '../types/core.js';
+import { Semaphore } from '../utils/semaphore.js';
+import { LatencyTracker } from '../utils/latency-tracker.js';
+import { DeliberationKernel } from './kernel/deliberation-kernel.js';
+/**
+ * The heart of the MAGI System.
+ *
+ * Orchestrates multi-round deliberation between N MAGI units (2-7):
+ * 1. Initial Opinion (parallel) - each unit forms independent opinion
+ * 2. Cross-Examination (parallel) - each unit reviews others' opinions
+ * 3. Final Vote (parallel) - definitive vote with full context
+ *
+ * Security hardening:
+ * - Task input validated at trust boundary via MagiTaskSchema
+ * - Opinion output validated via SafeOpinionSchema (control chars stripped, size capped)
+ * - Concurrency limited by semaphore to prevent resource exhaustion
+ * - Phase-level and deliberation-level timeouts enforced
+ * - All lifecycle events emitted to audit log and event bus (fire-and-forget)
+ */
+export class Orchestrator {
+    semaphore;
+    kernel;
+    constructor(options) {
+        this.semaphore = new Semaphore(options.maxConcurrentDeliberations ?? 3);
+        const deps = {
+            adapters: options.adapters,
+            pipelines: options.pipelines,
+            contextManager: options.contextManager,
+            latencyTracker: new LatencyTracker(),
+            eventBus: options.eventBus,
+            fileAccessEnabled: options.fileAccessEnabled,
+            modules: {
+                tokenTracker: options.tokenTracker,
+                objectiveJudge: options.objectiveJudge,
+                syncRateTracker: options.syncRateTracker,
+                atField: options.atField,
+                gospel: options.gospel,
+                umbilicalCable: options.umbilicalCable,
+                dummyPlug: options.dummyPlug,
+                offlineMode: options.offlineMode,
+                engramManager: options.engramManager,
+                lclManager: options.lclManager,
+                instrumentality: options.instrumentality,
+                driftDetector: options.driftDetector,
+                type666Firewall: options.type666Firewall,
+                nebuchadnezzarKey: options.nebuchadnezzarKey,
+                iruelBattle: options.iruelBattle,
+                cache: options.cache,
+            },
+        };
+        this.kernel = new DeliberationKernel(deps);
+    }
+    async deliberate(task, signal) {
+        // Validate task input at trust boundary
+        MagiTaskSchema.parse(task);
+        return this.semaphore.run(() => this.kernel.deliberate(task, signal));
+    }
+}

package/dist/src/engine/secret-cipher.d.ts

@@ -0,0 +1,26 @@
+/**
+ * B-08 裏コード (SecretCipher)
+ *
+ * MAGIシステムに隠されたメッセージ。AES-256-GCMで暗号化し、
+ * .magi/.cipher にパーミッション0o400で保存する。
+ */
+export declare class SecretCipher {
+    private readonly workspaceDir;
+    private cipherPath;
+    constructor(workspaceDir: string);
+    /** Check if cipher block exists */
+    exists(): Promise<boolean>;
+    /**
+     * Initialize with an encrypted message.
+     * Rejects if already initialized (double init protection).
+     */
+    initialize(message: string, passphrase: string): Promise<void>;
+    /** Decrypt the stored message */
+    decrypt(passphrase: string): Promise<string>;
+    /**
+     * Auto-initialize from environment variables or skip.
+     * - MAGI_CIPHER_MESSAGE + MAGI_CIPHER_PASSPHRASE → auto init
+     * - Otherwise → skip (no interactive prompt in library code)
+     */
+    autoInitialize(): Promise<boolean>;
+}

package/dist/src/engine/secret-cipher.js

@@ -0,0 +1,114 @@
+/**
+ * B-08 裏コード (SecretCipher)
+ *
+ * MAGIシステムに隠されたメッセージ。AES-256-GCMで暗号化し、
+ * .magi/.cipher にパーミッション0o400で保存する。
+ */
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from 'node:crypto';
+import { readFile, access, unlink, constants } from 'node:fs/promises';
+import { join } from 'node:path';
+import { logger } from '../utils/logger.js';
+import { safeMkdir, safeWriteFile } from '../utils/safe-fs.js';
+import { safeJsonParse } from '../utils/safe-json-parse.js';
+const CIPHER_FILENAME = '.cipher';
+const ALGORITHM = 'aes-256-gcm';
+const KEY_LENGTH = 32;
+const SALT_LENGTH = 16;
+const LEGACY_SALT = 'magi-system-secret-cipher'; // fallback for pre-salt data
+const SCRYPT_PARAMS = { N: 2 ** 17, r: 8, p: 1, maxmem: 256 * 1024 * 1024 };
+export class SecretCipher {
+    workspaceDir;
+    cipherPath;
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+        this.cipherPath = join(workspaceDir, CIPHER_FILENAME);
+    }
+    /** Check if cipher block exists */
+    async exists() {
+        try {
+            await access(this.cipherPath, constants.F_OK);
+            return true;
+        }
+        catch (err) {
+            logger.debug('SecretCipher: cipher file access check failed', { error: String(err) });
+            return false;
+        }
+    }
+    /**
+     * Initialize with an encrypted message.
+     * Rejects if already initialized (double init protection).
+     */
+    async initialize(message, passphrase) {
+        if (await this.exists()) {
+            throw new Error('SecretCipher: already initialized. Double initialization rejected.');
+        }
+        const salt = randomBytes(SALT_LENGTH);
+        const key = scryptSync(passphrase, salt, KEY_LENGTH, SCRYPT_PARAMS);
+        const iv = randomBytes(16);
+        const cipher = createCipheriv(ALGORITHM, key, iv);
+        const encrypted = Buffer.concat([
+            cipher.update(message, 'utf-8'),
+            cipher.final(),
+        ]);
+        const authTag = cipher.getAuthTag();
+        const block = {
+            iv: iv.toString('hex'),
+            authTag: authTag.toString('hex'),
+            encrypted: encrypted.toString('hex'),
+            salt: salt.toString('hex'),
+            createdAt: new Date().toISOString(),
+        };
+        await safeMkdir(this.workspaceDir);
+        await safeWriteFile(this.cipherPath, JSON.stringify(block, null, 2), {
+            mode: 0o400, // read-only for owner
+        });
+    }
+    /** Decrypt the stored message */
+    async decrypt(passphrase) {
+        if (!(await this.exists())) {
+            throw new Error('SecretCipher: no cipher block found.');
+        }
+        const raw = await readFile(this.cipherPath, 'utf-8');
+        const block = safeJsonParse(raw);
+        // Backward compat: legacy data without salt field uses the old fixed salt + old scrypt defaults
+        const isLegacy = !block.salt;
+        const salt = isLegacy
+            ? Buffer.from(LEGACY_SALT, 'utf-8')
+            : Buffer.from(block.salt, 'hex');
+        const key = isLegacy
+            ? scryptSync(passphrase, salt, KEY_LENGTH)
+            : scryptSync(passphrase, salt, KEY_LENGTH, SCRYPT_PARAMS);
+        const decipher = createDecipheriv(ALGORITHM, key, Buffer.from(block.iv, 'hex'));
+        decipher.setAuthTag(Buffer.from(block.authTag, 'hex'));
+        const decrypted = Buffer.concat([
+            decipher.update(Buffer.from(block.encrypted, 'hex')),
+            decipher.final(),
+        ]);
+        const plaintext = decrypted.toString('utf-8');
+        // Auto-upgrade legacy cipher to random salt + hardened scrypt
+        if (isLegacy) {
+            logger.info('SecretCipher: upgrading legacy cipher to random salt + hardened scrypt');
+            await unlink(this.cipherPath);
+            await this.initialize(plaintext, passphrase);
+        }
+        return plaintext;
+    }
+    /**
+     * Auto-initialize from environment variables or skip.
+     * - MAGI_CIPHER_MESSAGE + MAGI_CIPHER_PASSPHRASE → auto init
+     * - Otherwise → skip (no interactive prompt in library code)
+     */
+    async autoInitialize() {
+        if (await this.exists())
+            return false;
+        const message = process.env['MAGI_CIPHER_MESSAGE'];
+        const passphrase = process.env['MAGI_CIPHER_PASSPHRASE'];
+        delete process.env['MAGI_CIPHER_MESSAGE'];
+        delete process.env['MAGI_CIPHER_PASSPHRASE'];
+        if (message && passphrase) {
+            await this.initialize(message, passphrase);
+            return true;
+        }
+        return false; // skip — no env vars, no TTY interaction in library
+    }
+}

package/dist/src/engine/seele-council.d.ts

@@ -0,0 +1,90 @@
+/**
+ * B-07 Seele Council (ゼーレ会議)
+ *
+ * 分散MAGI合議 — 複数のMAGIノード間でPBFT/Raftによるコンセンサスを実現。
+ * シミュレーションモード (インメモリ) とネットワークモード (WebSocket) を切替可能。
+ *
+ * - PBFT (Layer 1): サブグループ内の合意形成
+ * - Raft (Layer 2): リーダー選出と提案管理
+ * - Ed25519署名: メッセージの真正性検証
+ * - SOUND ONLYパネル: 匿名参加者の可視化
+ */
+import type { MagiNodeId, MagiNodeInfo, RaftRole, SeeleSession, SeeleConfig } from '../types/phase-l.js';
+import type { MagiEventBus } from './events.js';
+export declare class SeeleCouncil {
+    private readonly localNode;
+    private readonly eventBus;
+    readonly config: SeeleConfig;
+    private nodes;
+    private keyPairs;
+    private session;
+    private raftRole;
+    private raftTerm;
+    private messageSequence;
+    constructor(localNode: MagiNodeId, eventBus?: MagiEventBus, config?: Partial<SeeleConfig>);
+    /**
+     * Initialize nodes for simulation mode.
+     */
+    initializeNodes(nodeIds?: MagiNodeId[]): void;
+    /**
+     * Run PBFT consensus among a subgroup of nodes.
+     */
+    pbftConsensus(subgroup: MagiNodeId[], proposal: string): Promise<{
+        agreed: boolean;
+        votes: Map<MagiNodeId, boolean>;
+    }>;
+    /**
+     * Perform Raft leader election among all nodes.
+     */
+    raftElection(): Promise<MagiNodeId>;
+    /**
+     * Propose a decision through Raft (leader only).
+     */
+    raftPropose(decision: string): Promise<boolean>;
+    /**
+     * Simulate an attack from attacker nodes against a target.
+     */
+    executeAttack(attackers: MagiNodeId[], target: MagiNodeId): Promise<{
+        success: boolean;
+        defenseHeld: boolean;
+    }>;
+    /**
+     * Start a new Seele council session.
+     */
+    startSession(): Promise<SeeleSession>;
+    /**
+     * Conclude a session with a decision.
+     */
+    concludeSession(decision: string | null): Promise<void>;
+    /**
+     * Run a full simulated Seele council session.
+     */
+    simulateSession(): Promise<SeeleSession>;
+    /**
+     * Create and sign a message.
+     */
+    private createMessage;
+    /**
+     * Sign a message with Ed25519 private key.
+     */
+    private signMessage;
+    /**
+     * Verify a message signature.
+     */
+    private verifyMessage;
+    /**
+     * Generate SOUND ONLY panel visualization (ANSI art).
+     */
+    formatSoundOnlyPanel(): string;
+    /**
+     * Securely destroy all private key material.
+     * Best-effort: zeros exported DER buffers and clears references.
+     */
+    destroy(): void;
+    getSession(): SeeleSession | null;
+    getNodes(): Map<MagiNodeId, MagiNodeInfo>;
+    getLocalNode(): MagiNodeId;
+    getRaftRole(): RaftRole;
+    getRaftTerm(): number;
+    private createSession;
+}