magi-ai 0.1.0

package/dist/src/engine/seele-council.js

@@ -0,0 +1,482 @@
+/**
+ * B-07 Seele Council (ゼーレ会議)
+ *
+ * 分散MAGI合議 — 複数のMAGIノード間でPBFT/Raftによるコンセンサスを実現。
+ * シミュレーションモード (インメモリ) とネットワークモード (WebSocket) を切替可能。
+ *
+ * - PBFT (Layer 1): サブグループ内の合意形成
+ * - Raft (Layer 2): リーダー選出と提案管理
+ * - Ed25519署名: メッセージの真正性検証
+ * - SOUND ONLYパネル: 匿名参加者の可視化
+ */
+import { randomUUID, sign, verify, generateKeyPairSync } from 'node:crypto';
+import { logger } from '../utils/logger.js';
+// ── Constants ────────────────────────────────────────────────────
+const DEFAULT_CONFIG = {
+    pbftTimeout: 5000,
+    raftElectionTimeout: 3000,
+    maxRetries: 3,
+};
+const SOUND_ONLY_PANEL_WIDTH = 60;
+/** The 6 MAGI installations worldwide */
+const MAGI_NODES = [
+    { id: 'MAGI-01', location: 'NERV HQ (箱根)', host: 'localhost', port: 7701 },
+    { id: 'MAGI-02', location: 'NERV Berlin', host: 'localhost', port: 7702 },
+    { id: 'MAGI-03', location: 'NERV Massachusetts', host: 'localhost', port: 7703 },
+    { id: 'MAGI-04', location: 'NERV Beijing', host: 'localhost', port: 7704 },
+    { id: 'MAGI-05', location: 'NERV Matsushiro', host: 'localhost', port: 7705 },
+    { id: 'MAGI-06', location: 'NERV Moscow', host: 'localhost', port: 7706 },
+];
+/** PBFT requires 2f+1 nodes to tolerate f faults */
+function pbftQuorum(totalNodes) {
+    const f = Math.floor((totalNodes - 1) / 3);
+    return 2 * f + 1;
+}
+export class SeeleCouncil {
+    localNode;
+    eventBus;
+    config;
+    nodes = new Map();
+    keyPairs = new Map();
+    session = null;
+    raftRole = 'follower';
+    raftTerm = 0;
+    messageSequence = 0;
+    constructor(localNode, eventBus, config) {
+        this.localNode = localNode;
+        this.eventBus = eventBus;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    // ── Node Management ───────────────────────────────────────
+    /**
+     * Initialize nodes for simulation mode.
+     */
+    initializeNodes(nodeIds) {
+        const ids = nodeIds ?? MAGI_NODES.map(n => n.id);
+        for (const id of ids) {
+            const template = MAGI_NODES.find(n => n.id === id);
+            const keyPair = generateKeyPairSync('ed25519');
+            const publicKeyHex = keyPair.publicKey.export({ type: 'spki', format: 'der' }).toString('hex');
+            this.keyPairs.set(id, {
+                publicKey: keyPair.publicKey,
+                privateKey: keyPair.privateKey,
+                publicKeyHex,
+            });
+            const node = {
+                id,
+                location: template?.location ?? `Node ${id}`,
+                host: template?.host ?? 'localhost',
+                port: template?.port ?? 7700,
+                publicKey: publicKeyHex,
+                status: 'online',
+            };
+            this.nodes.set(id, node);
+        }
+        logger.info('Seele: nodes initialized', { count: this.nodes.size });
+    }
+    // ── PBFT Consensus (Layer 1) ──────────────────────────────
+    /**
+     * Run PBFT consensus among a subgroup of nodes.
+     */
+    async pbftConsensus(subgroup, proposal) {
+        const quorum = pbftQuorum(subgroup.length);
+        const votes = new Map();
+        // Pre-prepare phase (broadcast to session log)
+        this.createMessage(this.localNode, this.localNode, 'pre-prepare', {
+            proposal,
+            view: this.raftTerm,
+        });
+        // Prepare phase — each node validates and responds
+        for (const nodeId of subgroup) {
+            const node = this.nodes.get(nodeId);
+            if (!node || node.status !== 'online') {
+                votes.set(nodeId, false);
+                continue;
+            }
+            // Simulate validation (online nodes agree)
+            const prepareMsg = this.createMessage(nodeId, this.localNode, 'prepare', {
+                proposal,
+                accept: true,
+            });
+            votes.set(nodeId, this.verifyMessage(prepareMsg, nodeId));
+        }
+        // Commit phase — check quorum
+        const agreeCount = [...votes.values()].filter(v => v).length;
+        const agreed = agreeCount >= quorum;
+        // Send commit messages
+        for (const nodeId of subgroup) {
+            if (votes.get(nodeId)) {
+                this.createMessage(nodeId, this.localNode, 'commit', {
+                    proposal,
+                    agreed,
+                });
+            }
+        }
+        logger.info('Seele: PBFT consensus', {
+            agreed,
+            votes: agreeCount,
+            quorum,
+            total: subgroup.length,
+        });
+        return { agreed, votes };
+    }
+    // ── Raft Leader Election (Layer 2) ─────────────────────────
+    /**
+     * Perform Raft leader election among all nodes.
+     */
+    async raftElection() {
+        this.raftTerm++;
+        this.raftRole = 'candidate';
+        const onlineNodes = [...this.nodes.entries()]
+            .filter(([_, n]) => n.status === 'online')
+            .map(([id]) => id);
+        const votes = new Map();
+        // Self-vote
+        votes.set(this.localNode, this.localNode);
+        // Request votes from other nodes
+        for (const nodeId of onlineNodes) {
+            if (nodeId === this.localNode)
+                continue;
+            // Simulate: nodes vote for the candidate (simplified Raft)
+            const msg = this.createMessage(nodeId, this.localNode, 'raft-vote', {
+                term: this.raftTerm,
+                candidateId: this.localNode,
+                granted: true,
+            });
+            if (this.verifyMessage(msg, nodeId)) {
+                votes.set(nodeId, this.localNode);
+            }
+        }
+        const majority = Math.floor(onlineNodes.length / 2) + 1;
+        const voteCount = [...votes.values()].filter(v => v === this.localNode).length;
+        let leader;
+        if (voteCount >= majority) {
+            this.raftRole = 'leader';
+            leader = this.localNode;
+        }
+        else {
+            this.raftRole = 'follower';
+            leader = onlineNodes[0]; // Fallback to first online node
+        }
+        logger.info('Seele: Raft election complete', {
+            leader,
+            term: this.raftTerm,
+            votes: voteCount,
+            majority,
+        });
+        return leader;
+    }
+    /**
+     * Propose a decision through Raft (leader only).
+     */
+    async raftPropose(decision) {
+        if (this.raftRole !== 'leader') {
+            logger.warn('Seele: cannot propose — not leader');
+            return false;
+        }
+        const onlineNodes = [...this.nodes.entries()]
+            .filter(([_, n]) => n.status === 'online')
+            .map(([id]) => id);
+        // Use PBFT for the actual consensus
+        const result = await this.pbftConsensus(onlineNodes, decision);
+        return result.agreed;
+    }
+    // ── Attack Mode ───────────────────────────────────────────
+    /**
+     * Simulate an attack from attacker nodes against a target.
+     */
+    async executeAttack(attackers, target) {
+        if (!this.session) {
+            this.session = this.createSession();
+        }
+        this.session.phase = 'ATTACK';
+        this.eventBus?.emit('seele:attack', {
+            sessionId: this.session.id,
+            attackers,
+            target,
+            emittedAt: new Date(),
+        });
+        // Mark attackers as compromised
+        for (const attacker of attackers) {
+            const node = this.nodes.get(attacker);
+            if (node) {
+                node.status = 'compromised';
+                this.nodes.set(attacker, node);
+            }
+        }
+        // Check if defense holds: target + remaining online nodes form quorum
+        const onlineNodes = [...this.nodes.entries()]
+            .filter(([_, n]) => n.status === 'online')
+            .map(([id]) => id);
+        const totalNodes = this.nodes.size;
+        const quorum = pbftQuorum(totalNodes);
+        const defenseHeld = onlineNodes.length >= quorum;
+        logger.info('Seele: attack executed', {
+            attackers,
+            target,
+            defenseHeld,
+            onlineNodes: onlineNodes.length,
+            quorum,
+        });
+        return { success: !defenseHeld, defenseHeld };
+    }
+    // ── Session Management ────────────────────────────────────
+    /**
+     * Start a new Seele council session.
+     */
+    async startSession() {
+        this.session = this.createSession();
+        this.eventBus?.emit('seele:gathering', {
+            sessionId: this.session.id,
+            nodes: [...this.nodes.keys()],
+            emittedAt: new Date(),
+        });
+        logger.info('Seele: session started', { sessionId: this.session.id });
+        return this.session;
+    }
+    /**
+     * Conclude a session with a decision.
+     */
+    async concludeSession(decision) {
+        if (!this.session) {
+            throw new Error('Seele: no active session');
+        }
+        this.session.phase = 'CONCLUDED';
+        this.session.decision = decision;
+        this.session.completedAt = new Date().toISOString();
+        this.eventBus?.emit('seele:concluded', {
+            sessionId: this.session.id,
+            decision,
+            leader: this.session.leader,
+            emittedAt: new Date(),
+        });
+        logger.info('Seele: session concluded', {
+            sessionId: this.session.id,
+            decision,
+        });
+    }
+    // ── Simulation Mode ───────────────────────────────────────
+    /**
+     * Run a full simulated Seele council session.
+     */
+    async simulateSession() {
+        // Initialize nodes if not already done
+        if (this.nodes.size === 0) {
+            this.initializeNodes();
+        }
+        // Start session
+        const session = await this.startSession();
+        // Leader election
+        session.phase = 'LEADER_ELECTION';
+        const leader = await this.raftElection();
+        session.leader = leader;
+        // Deliberation via PBFT
+        session.phase = 'DELIBERATION';
+        const allNodes = [...this.nodes.keys()];
+        const result = await this.pbftConsensus(allNodes, 'simulation-proposal');
+        // Consensus
+        session.phase = 'CONSENSUS';
+        const decision = result.agreed ? 'APPROVED' : 'REJECTED';
+        // Conclude
+        await this.concludeSession(decision);
+        return session;
+    }
+    // ── Message Signing & Verification ─────────────────────────
+    /**
+     * Create and sign a message.
+     */
+    createMessage(from, to, type, payload) {
+        this.messageSequence++;
+        const msg = {
+            from,
+            to,
+            type,
+            payload,
+            signature: '',
+            timestamp: new Date().toISOString(),
+            sequence: this.messageSequence,
+        };
+        // Sign the message
+        msg.signature = this.signMessage(msg, from);
+        if (this.session) {
+            this.session.messages.push(msg);
+        }
+        return msg;
+    }
+    /**
+     * Sign a message with Ed25519 private key.
+     */
+    signMessage(msg, nodeId) {
+        const keyPair = this.keyPairs.get(nodeId);
+        if (!keyPair)
+            return 'unsigned';
+        try {
+            const data = Buffer.from(JSON.stringify({
+                from: msg.from,
+                to: msg.to,
+                type: msg.type,
+                payload: msg.payload,
+                timestamp: msg.timestamp,
+                sequence: msg.sequence,
+            }));
+            const signature = sign(null, data, keyPair.privateKey);
+            return signature.toString('hex');
+        }
+        catch (err) {
+            logger.debug('Seele: message signing failed', { error: String(err) });
+            return 'sign-error';
+        }
+    }
+    /**
+     * Verify a message signature.
+     */
+    verifyMessage(msg, nodeId) {
+        const keyPair = this.keyPairs.get(nodeId);
+        if (!keyPair || msg.signature === 'unsigned' || msg.signature === 'sign-error') {
+            return false;
+        }
+        try {
+            const data = Buffer.from(JSON.stringify({
+                from: msg.from,
+                to: msg.to,
+                type: msg.type,
+                payload: msg.payload,
+                timestamp: msg.timestamp,
+                sequence: msg.sequence,
+            }));
+            return verify(null, data, keyPair.publicKey, Buffer.from(msg.signature, 'hex'));
+        }
+        catch (err) {
+            logger.debug('Seele: message verification failed', { error: String(err) });
+            return false;
+        }
+    }
+    // ── SOUND ONLY Panel ──────────────────────────────────────
+    /**
+     * Generate SOUND ONLY panel visualization (ANSI art).
+     */
+    formatSoundOnlyPanel() {
+        const lines = [];
+        const border = '═'.repeat(SOUND_ONLY_PANEL_WIDTH);
+        lines.push(`╔${border}╗`);
+        lines.push(`║${centerToDisplayWidth('SEELE', SOUND_ONLY_PANEL_WIDTH)}║`);
+        lines.push(`║${centerToDisplayWidth('SOUND ONLY', SOUND_ONLY_PANEL_WIDTH)}║`);
+        lines.push(`╠${border}╣`);
+        const nodeList = [...this.nodes.entries()];
+        for (const [id, node] of nodeList) {
+            const statusIcon = node.status === 'online' ? '●'
+                : node.status === 'compromised' ? '✗' : '○';
+            const label = `${statusIcon} ${id} — ${node.location}`;
+            lines.push(`║${padToDisplayWidth(` ${label}`, SOUND_ONLY_PANEL_WIDTH)}║`);
+        }
+        lines.push(`╠${border}╣`);
+        if (this.session) {
+            const sessionInfo = `Session: ${this.session.id.slice(0, 8)} | Phase: ${this.session.phase}`;
+            lines.push(`║${padToDisplayWidth(` ${sessionInfo}`, SOUND_ONLY_PANEL_WIDTH)}║`);
+            const leaderInfo = `Leader: ${this.session.leader ?? 'N/A'} | Messages: ${this.session.messages.length}`;
+            lines.push(`║${padToDisplayWidth(` ${leaderInfo}`, SOUND_ONLY_PANEL_WIDTH)}║`);
+        }
+        else {
+            lines.push(`║${padToDisplayWidth(' No active session', SOUND_ONLY_PANEL_WIDTH)}║`);
+        }
+        lines.push(`╚${border}╝`);
+        return lines.join('\n');
+    }
+    // ── Key Material Cleanup ─────────────────────────────────
+    /**
+     * Securely destroy all private key material.
+     * Best-effort: zeros exported DER buffers and clears references.
+     */
+    destroy() {
+        for (const [, pair] of this.keyPairs) {
+            try {
+                const der = pair.privateKey.export({ type: 'pkcs8', format: 'der' });
+                der.fill(0);
+            }
+            catch {
+                // KeyObject may already be unusable — ignore
+            }
+        }
+        this.keyPairs.clear();
+        this.nodes.clear();
+        this.session = null;
+        logger.info('Seele: key material destroyed');
+    }
+    // ── State Accessors ───────────────────────────────────────
+    getSession() {
+        return this.session;
+    }
+    getNodes() {
+        return new Map(this.nodes);
+    }
+    getLocalNode() {
+        return this.localNode;
+    }
+    getRaftRole() {
+        return this.raftRole;
+    }
+    getRaftTerm() {
+        return this.raftTerm;
+    }
+    // ── Helpers ───────────────────────────────────────────────
+    createSession() {
+        return {
+            id: randomUUID(),
+            nodes: [...this.nodes.values()],
+            leader: null,
+            phase: 'GATHERING',
+            messages: [],
+            decision: null,
+            startedAt: new Date().toISOString(),
+            completedAt: null,
+        };
+    }
+}
+function charDisplayWidth(codePoint) {
+    if ((codePoint >= 0x1100 && codePoint <= 0x115F)
+        || (codePoint >= 0x2E80 && codePoint <= 0x303E)
+        || (codePoint >= 0x3041 && codePoint <= 0x33BF)
+        || (codePoint >= 0x3400 && codePoint <= 0x4DBF)
+        || (codePoint >= 0x4E00 && codePoint <= 0x9FFF)
+        || (codePoint >= 0xA000 && codePoint <= 0xA4CF)
+        || (codePoint >= 0xAC00 && codePoint <= 0xD7AF)
+        || (codePoint >= 0xF900 && codePoint <= 0xFAFF)
+        || (codePoint >= 0xFE30 && codePoint <= 0xFE4F)
+        || (codePoint >= 0xFF01 && codePoint <= 0xFF60)
+        || (codePoint >= 0xFFE0 && codePoint <= 0xFFE6)
+        || (codePoint >= 0x20000 && codePoint <= 0x2FA1F)) {
+        return 2;
+    }
+    return 1;
+}
+function stringDisplayWidth(text) {
+    let width = 0;
+    for (const ch of text) {
+        width += charDisplayWidth(ch.codePointAt(0) ?? 0);
+    }
+    return width;
+}
+function truncateToDisplayWidth(text, maxWidth) {
+    let width = 0;
+    let result = '';
+    for (const ch of text) {
+        const charWidth = charDisplayWidth(ch.codePointAt(0) ?? 0);
+        if (width + charWidth > maxWidth) {
+            break;
+        }
+        result += ch;
+        width += charWidth;
+    }
+    return result;
+}
+function padToDisplayWidth(text, width) {
+    const truncated = truncateToDisplayWidth(text, width);
+    const fillWidth = Math.max(0, width - stringDisplayWidth(truncated));
+    return truncated + ' '.repeat(fillWidth);
+}
+function centerToDisplayWidth(text, width) {
+    const truncated = truncateToDisplayWidth(text, width);
+    const displayWidth = stringDisplayWidth(truncated);
+    const leftPad = Math.max(0, Math.floor((width - displayWidth) / 2));
+    return ' '.repeat(leftPad) + padToDisplayWidth(truncated, width - leftPad);
+}

package/dist/src/engine/self-destruct.d.ts

@@ -0,0 +1,61 @@
+/**
+ * B-04 Self-Destruct Sequence (自爆シーケンス)
+ *
+ * Unanimous irreversible operations. All MAGI units must vote APPROVE
+ * for the sequence to execute. A single REJECT vote blocks execution (f=0 BFT).
+ *
+ * Phase state machine:
+ *   IDLE -> MOTION_FILED -> DELIBERATING -> COUNTDOWN(200ms) -> EXECUTING -> COMPLETED
+ *                                        \-> ABORTED (any REJECT or 2+ units request abort)
+ */
+import type { MagiUnit, Vote } from '../types/core.js';
+import type { SelfDestructPhase, SelfDestructMotion } from '../types/phase-k.js';
+import type { MagiEventBus } from './events.js';
+import type { SecretCipher } from './secret-cipher.js';
+export declare class SelfDestructSequence {
+    private phase;
+    private motion;
+    private readonly units;
+    private readonly eventBus;
+    private readonly secretCipher;
+    constructor(units: MagiUnit[], eventBus?: MagiEventBus, secretCipher?: SecretCipher);
+    /**
+     * File a self-destruct motion. Must be in IDLE phase.
+     */
+    fileMotion(reason: string, filedBy: string): SelfDestructMotion;
+    /**
+     * Cast a vote on the motion. Must be in MOTION_FILED phase.
+     * When all units have voted, transitions to DELIBERATING and evaluates.
+     */
+    castVote(motionId: string, unit: MagiUnit, vote: Vote): void;
+    /**
+     * Evaluate the votes. Requires all units to have voted.
+     * - All APPROVE -> COUNTDOWN
+     * - Any REJECT -> ABORTED
+     * - Otherwise stays DELIBERATING
+     */
+    evaluate(motionId: string): SelfDestructPhase;
+    /**
+     * Execute the countdown sequence. Must be in COUNTDOWN phase.
+     * Iterates through geoid depths, emitting events at each step.
+     * After countdown, attempts B-08 cipher reveal, then transitions to COMPLETED.
+     */
+    executeCountdown(motionId: string): Promise<SelfDestructMotion>;
+    /**
+     * Request abort from multiple units. Requires 2+ units to agree.
+     * Can abort from MOTION_FILED, DELIBERATING, or COUNTDOWN.
+     */
+    requestAbort(motionId: string, units: MagiUnit[]): boolean;
+    /**
+     * Get the current motion, if any.
+     */
+    getMotion(): SelfDestructMotion | null;
+    /**
+     * Get the current phase.
+     */
+    getPhase(): SelfDestructPhase;
+    /**
+     * Reset the sequence to IDLE state.
+     */
+    reset(): void;
+}