magi-ai 0.1.0

package/dist/src/engine/nebuchadnezzar-key.d.ts

@@ -0,0 +1,61 @@
+/**
+ * B-06 Nebuchadnezzar Key (Creator Override)
+ *
+ * Ed25519 key pair for creator override of MAGI consensus decisions.
+ * The private key is returned once at generation and NEVER stored.
+ * Only the public key is persisted in `.magi/nebuchadnezzar.json`.
+ */
+import type { OverrideRequest, OverrideResult, NebuchadnezzarState } from '../types/phase-k.js';
+import type { MagiEventBus } from './events.js';
+export declare class NebuchadnezzarKey {
+    private state;
+    private readonly statePath;
+    private readonly eventBus?;
+    private usedNonces;
+    constructor(workspaceDir: string, eventBus?: MagiEventBus);
+    /**
+     * Generate a new Ed25519 key pair.
+     * Public key is stored; private key is returned once and NOT persisted.
+     */
+    generateKeyPair(): Promise<{
+        publicKey: string;
+        privateKey: string;
+    }>;
+    /**
+     * Override a consensus decision with a signed request.
+     */
+    override(request: OverrideRequest, previousDecision: string): Promise<OverrideResult>;
+    /**
+     * Reset consecutive override counter (called when deliberation completes without override).
+     */
+    resetConsecutiveOverrides(): void;
+    /**
+     * Load state from disk.
+     */
+    load(): Promise<void>;
+    /**
+     * Persist state to disk with 0o600 permissions.
+     */
+    persist(): Promise<void>;
+    /**
+     * Check if public key has been generated/loaded.
+     */
+    isInitialized(): boolean;
+    /**
+     * Get current state (or null if not initialized).
+     */
+    getState(): NebuchadnezzarState | null;
+    /**
+     * Confidence multiplier based on consecutive override count.
+     * 1 override = 1.0, 2 consecutive = 0.9, 3+ consecutive = 0.7
+     */
+    getConfidenceMultiplier(): number;
+    /**
+     * Static helper: sign a message for an override request.
+     * Returns hex-encoded Ed25519 signature.
+     */
+    /** Generate a fresh nonce for an override request. */
+    static generateNonce(): string;
+    private evictExpiredNonces;
+    static sign(privateKeyHex: string, deliberationId: string, newDecision: string, reason: string, timestamp: string, nonce: string): string;
+}

package/dist/src/engine/nebuchadnezzar-key.js

@@ -0,0 +1,203 @@
+/**
+ * B-06 Nebuchadnezzar Key (Creator Override)
+ *
+ * Ed25519 key pair for creator override of MAGI consensus decisions.
+ * The private key is returned once at generation and NEVER stored.
+ * Only the public key is persisted in `.magi/nebuchadnezzar.json`.
+ */
+import { generateKeyPairSync, sign as cryptoSign, verify as cryptoVerify, randomUUID } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { logger } from '../utils/logger.js';
+import { safePersist } from '../utils/safe-fs.js';
+import { safeJsonParse } from '../utils/safe-json-parse.js';
+const STATE_FILENAME = 'nebuchadnezzar.json';
+const REPLAY_WINDOW_MS = 5 * 60 * 1000; // 5 minutes
+const MAX_NONCE_CACHE = 1000;
+const UUID_V4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+export class NebuchadnezzarKey {
+    state = null;
+    statePath;
+    eventBus;
+    usedNonces = new Map(); // nonce → expiresAt
+    constructor(workspaceDir, eventBus) {
+        this.statePath = join(workspaceDir, STATE_FILENAME);
+        this.eventBus = eventBus;
+    }
+    /**
+     * Generate a new Ed25519 key pair.
+     * Public key is stored; private key is returned once and NOT persisted.
+     */
+    async generateKeyPair() {
+        if (this.state !== null) {
+            throw new Error('NebuchadnezzarKey: already initialized. Cannot generate a second key pair.');
+        }
+        const { publicKey, privateKey } = generateKeyPairSync('ed25519', {
+            publicKeyEncoding: { type: 'spki', format: 'der' },
+            privateKeyEncoding: { type: 'pkcs8', format: 'der' },
+        });
+        const publicKeyHex = publicKey.toString('hex');
+        const privateKeyHex = privateKey.toString('hex');
+        this.state = {
+            publicKey: publicKeyHex,
+            overrideCount: 0,
+            consecutiveOverrides: 0,
+            createdAt: new Date().toISOString(),
+        };
+        await this.persist();
+        return { publicKey: publicKeyHex, privateKey: privateKeyHex };
+    }
+    /**
+     * Override a consensus decision with a signed request.
+     */
+    async override(request, previousDecision) {
+        if (this.state === null) {
+            throw new Error('NebuchadnezzarKey: not initialized. Call generateKeyPair() or load() first.');
+        }
+        // Replay prevention: timestamp freshness
+        const requestTime = new Date(request.timestamp).getTime();
+        const now = Date.now();
+        if (Number.isNaN(requestTime) || Math.abs(now - requestTime) > REPLAY_WINDOW_MS) {
+            throw new Error(`NebuchadnezzarKey: timestamp too stale or invalid. Window: ${REPLAY_WINDOW_MS}ms`);
+        }
+        // Replay prevention: nonce uniqueness
+        if (!request.nonce || !UUID_V4_RE.test(request.nonce)) {
+            throw new Error('NebuchadnezzarKey: nonce must be a valid UUID v4.');
+        }
+        this.evictExpiredNonces();
+        if (this.usedNonces.has(request.nonce)) {
+            throw new Error('NebuchadnezzarKey: nonce already used. Replay attack rejected.');
+        }
+        this.usedNonces.set(request.nonce, now + REPLAY_WINDOW_MS);
+        // Verify Ed25519 signature (nonce included in signed message)
+        const message = `${request.deliberationId}:${request.newDecision}:${request.reason}:${request.timestamp}:${request.nonce}`;
+        const publicKeyDer = Buffer.from(this.state.publicKey, 'hex');
+        const signatureBuffer = Buffer.from(request.signature, 'hex');
+        const valid = cryptoVerify(null, // Ed25519 does not use a separate hash algorithm
+        Buffer.from(message, 'utf-8'), { key: publicKeyDer, format: 'der', type: 'spki' }, signatureBuffer);
+        if (!valid) {
+            throw new Error('NebuchadnezzarKey: invalid signature. Override rejected.');
+        }
+        // Update state
+        this.state.overrideCount += 1;
+        this.state.consecutiveOverrides += 1;
+        this.state.lastOverrideAt = new Date().toISOString();
+        const confidenceMultiplier = this.getConfidenceMultiplier();
+        const appliedAt = new Date().toISOString();
+        const result = {
+            success: true,
+            deliberationId: request.deliberationId,
+            previousDecision,
+            newDecision: request.newDecision,
+            confidenceMultiplier,
+            consecutiveOverrides: this.state.consecutiveOverrides,
+            overrideCount: this.state.overrideCount,
+            appliedAt,
+        };
+        // Audit log
+        logger.audit('nebuchadnezzar.override', request.deliberationId, {
+            previousDecision,
+            newDecision: request.newDecision,
+            reason: request.reason,
+            overrideCount: this.state.overrideCount,
+            consecutiveOverrides: this.state.consecutiveOverrides,
+            confidenceMultiplier,
+        });
+        // Persist updated state
+        await this.persist();
+        // Emit event
+        if (this.eventBus) {
+            this.eventBus.emit('nebuchadnezzar:override', {
+                deliberationId: request.deliberationId,
+                previousDecision,
+                newDecision: request.newDecision,
+                consecutiveOverrides: this.state.consecutiveOverrides,
+                emittedAt: new Date(),
+            });
+        }
+        return result;
+    }
+    /**
+     * Reset consecutive override counter (called when deliberation completes without override).
+     */
+    resetConsecutiveOverrides() {
+        if (this.state !== null) {
+            this.state.consecutiveOverrides = 0;
+        }
+    }
+    /**
+     * Load state from disk.
+     */
+    async load() {
+        const raw = await readFile(this.statePath, 'utf-8');
+        const parsed = safeJsonParse(raw);
+        this.state = parsed;
+    }
+    /**
+     * Persist state to disk with 0o600 permissions.
+     */
+    async persist() {
+        if (this.state === null) {
+            throw new Error('NebuchadnezzarKey: no state to persist.');
+        }
+        await safePersist(this.statePath, JSON.stringify(this.state, null, 2));
+    }
+    /**
+     * Check if public key has been generated/loaded.
+     */
+    isInitialized() {
+        return this.state !== null;
+    }
+    /**
+     * Get current state (or null if not initialized).
+     */
+    getState() {
+        if (this.state === null)
+            return null;
+        return { ...this.state };
+    }
+    /**
+     * Confidence multiplier based on consecutive override count.
+     * 1 override = 1.0, 2 consecutive = 0.9, 3+ consecutive = 0.7
+     */
+    getConfidenceMultiplier() {
+        if (this.state === null)
+            return 1.0;
+        const c = this.state.consecutiveOverrides;
+        if (c <= 1)
+            return 1.0;
+        if (c === 2)
+            return 0.9;
+        return 0.7;
+    }
+    /**
+     * Static helper: sign a message for an override request.
+     * Returns hex-encoded Ed25519 signature.
+     */
+    /** Generate a fresh nonce for an override request. */
+    static generateNonce() {
+        return randomUUID();
+    }
+    evictExpiredNonces() {
+        const now = Date.now();
+        for (const [nonce, expiresAt] of this.usedNonces) {
+            if (expiresAt <= now)
+                this.usedNonces.delete(nonce);
+        }
+        if (this.usedNonces.size > MAX_NONCE_CACHE) {
+            this.usedNonces.clear();
+        }
+    }
+    static sign(privateKeyHex, deliberationId, newDecision, reason, timestamp, nonce) {
+        const message = `${deliberationId}:${newDecision}:${reason}:${timestamp}:${nonce}`;
+        const privateKeyDer = Buffer.from(privateKeyHex, 'hex');
+        try {
+            const signature = cryptoSign(null, // Ed25519 does not use a separate hash algorithm
+            Buffer.from(message, 'utf-8'), { key: privateKeyDer, format: 'der', type: 'pkcs8' });
+            return signature.toString('hex');
+        }
+        finally {
+            privateKeyDer.fill(0);
+        }
+    }
+}

package/dist/src/engine/neon-genesis.d.ts

@@ -0,0 +1,52 @@
+/**
+ * B-10 Neon Genesis (世界のやり直し)
+ *
+ * MAGIシステムの完全リセット。全審議記録を消去し、
+ * 選ばれた記憶のみを次世代に引き継ぐ。
+ *
+ * 処理フロー:
+ *   1. genesis:started イベント発火
+ *   2. preResetDeliberation — MAGI自身が消滅を議論 (optional)
+ *   3. collectSnapshot — 審議統計収集
+ *   4. selectSurvivalMemories — 10% Fisher-Yatesシャッフル選択
+ *   5. .cipher ファイル退避
+ *   6. purge — .magi/ 配下削除 (genesis-log.json + .cipher 除外)
+ *   7. .cipher 復元
+ *   8. writeGenesisLog — genesis-log.json に痕跡記録
+ *   9. genesis:complete イベント発火
+ */
+import type { GenesisLog } from '../types/phase-l.js';
+import type { MagiEventBus } from './events.js';
+export declare class NeonGenesis {
+    private readonly workspaceDir;
+    private readonly eventBus;
+    constructor(workspaceDir: string, eventBus?: MagiEventBus);
+    /**
+     * Execute the Neon Genesis — full system reset.
+     */
+    execute(reason: string, initiator: string, force?: boolean): Promise<GenesisLog>;
+    /**
+     * Collect snapshot of current MAGI state from chronicle and rounds.
+     */
+    private collectSnapshot;
+    /**
+     * Load semantic patterns from engram store.
+     */
+    private loadSemanticPatterns;
+    /**
+     * Select survival memories using Fisher-Yates shuffle at given rate.
+     */
+    selectSurvivalMemories(patterns: string[], rate?: number): string[];
+    /**
+     * Purge the .magi/ workspace directory, preserving specified files.
+     */
+    private purge;
+    /**
+     * Write genesis log to workspace.
+     */
+    private writeGenesisLog;
+    /**
+     * Load existing genesis log, if any.
+     */
+    loadGenesisLog(): Promise<GenesisLog | null>;
+}

package/dist/src/engine/neon-genesis.js

@@ -0,0 +1,203 @@
+/**
+ * B-10 Neon Genesis (世界のやり直し)
+ *
+ * MAGIシステムの完全リセット。全審議記録を消去し、
+ * 選ばれた記憶のみを次世代に引き継ぐ。
+ *
+ * 処理フロー:
+ *   1. genesis:started イベント発火
+ *   2. preResetDeliberation — MAGI自身が消滅を議論 (optional)
+ *   3. collectSnapshot — 審議統計収集
+ *   4. selectSurvivalMemories — 10% Fisher-Yatesシャッフル選択
+ *   5. .cipher ファイル退避
+ *   6. purge — .magi/ 配下削除 (genesis-log.json + .cipher 除外)
+ *   7. .cipher 復元
+ *   8. writeGenesisLog — genesis-log.json に痕跡記録
+ *   9. genesis:complete イベント発火
+ */
+import { randomUUID, randomInt } from 'node:crypto';
+import { readFile, readdir, rm, copyFile } 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 GENESIS_LOG_FILE = 'genesis-log.json';
+const CIPHER_FILE = '.cipher';
+const SURVIVAL_RATE = 0.10; // 10% of semantic patterns survive
+export class NeonGenesis {
+    workspaceDir;
+    eventBus;
+    constructor(workspaceDir, eventBus) {
+        this.workspaceDir = workspaceDir;
+        this.eventBus = eventBus;
+    }
+    /**
+     * Execute the Neon Genesis — full system reset.
+     */
+    async execute(reason, initiator, force = false) {
+        if (!force) {
+            throw new Error('Neon Genesis aborted: --force flag required. This permanently deletes all deliberation data.');
+        }
+        const resetId = randomUUID();
+        logger.warn('Neon Genesis initiated', { resetId, reason, initiator });
+        this.eventBus?.emit('genesis:started', {
+            resetId,
+            reason,
+            emittedAt: new Date(),
+        });
+        // Collect snapshot before purge
+        const snapshot = await this.collectSnapshot();
+        // Select survival memories from engram patterns
+        const patterns = await this.loadSemanticPatterns();
+        const survivalMemories = this.selectSurvivalMemories(patterns, SURVIVAL_RATE);
+        // Check for cipher file
+        const cipherPath = join(this.workspaceDir, CIPHER_FILE);
+        const cipherBackupPath = join(this.workspaceDir, `.cipher-backup-${resetId}`);
+        let cipherPreserved = false;
+        // Backup cipher if it exists
+        try {
+            await copyFile(cipherPath, cipherBackupPath);
+            cipherPreserved = true;
+        }
+        catch (err) {
+            logger.debug('Neon Genesis: no cipher file to backup', { error: String(err) });
+        }
+        // Purge workspace
+        await this.purge([GENESIS_LOG_FILE, `.cipher-backup-${resetId}`]);
+        // Restore cipher
+        if (cipherPreserved) {
+            try {
+                await safeMkdir(this.workspaceDir);
+                await copyFile(cipherBackupPath, cipherPath);
+                await rm(cipherBackupPath, { force: true });
+            }
+            catch {
+                logger.warn('Failed to restore cipher file after genesis');
+            }
+        }
+        // Write genesis log
+        const log = {
+            resetId,
+            previousGeneration: snapshot.totalDeliberations,
+            totalDeliberations: snapshot.totalDeliberations,
+            survivalMemories,
+            cipherMessagePreserved: cipherPreserved,
+            lastDeliberation: snapshot.lastDeliberation,
+            resetAt: new Date().toISOString(),
+            initiator,
+        };
+        await this.writeGenesisLog(log);
+        logger.warn('Neon Genesis complete', {
+            resetId,
+            survived: survivalMemories.length,
+            cipherPreserved,
+        });
+        this.eventBus?.emit('genesis:complete', {
+            resetId,
+            survivalMemories: survivalMemories.length,
+            cipherPreserved,
+            emittedAt: new Date(),
+        });
+        return log;
+    }
+    /**
+     * Collect snapshot of current MAGI state from chronicle and rounds.
+     */
+    async collectSnapshot() {
+        let totalDeliberations = 0;
+        let lastDeliberation = null;
+        // Read chronicle.jsonl
+        const chroniclePath = join(this.workspaceDir, 'gospel', 'chronicle.jsonl');
+        try {
+            const raw = await readFile(chroniclePath, 'utf-8');
+            const lines = raw.trim().split('\n').filter(Boolean);
+            totalDeliberations = lines.length;
+            if (lines.length > 0) {
+                try {
+                    const lastEntry = safeJsonParse(lines[lines.length - 1]);
+                    lastDeliberation = lastEntry.timestamp ?? lastEntry.recordedAt ?? null;
+                }
+                catch (err) {
+                    logger.debug('Neon Genesis: corrupt chronicle last line', { error: String(err) });
+                }
+            }
+        }
+        catch (err) {
+            logger.debug('Neon Genesis: no chronicle found, fresh system', { error: String(err) });
+        }
+        return { totalDeliberations, lastDeliberation };
+    }
+    /**
+     * Load semantic patterns from engram store.
+     */
+    async loadSemanticPatterns() {
+        const engramPath = join(this.workspaceDir, 'engram', 'semantic.json');
+        try {
+            const raw = await readFile(engramPath, 'utf-8');
+            const patterns = safeJsonParse(raw);
+            if (Array.isArray(patterns)) {
+                return patterns.map((p) => p.pattern ?? p.description ?? JSON.stringify(p));
+            }
+            return [];
+        }
+        catch (err) {
+            logger.debug('Neon Genesis: failed to load semantic patterns', { error: String(err) });
+            return [];
+        }
+    }
+    /**
+     * Select survival memories using Fisher-Yates shuffle at given rate.
+     */
+    selectSurvivalMemories(patterns, rate = SURVIVAL_RATE) {
+        if (patterns.length === 0)
+            return [];
+        const count = Math.max(1, Math.ceil(patterns.length * rate));
+        const shuffled = [...patterns];
+        // Fisher-Yates shuffle (partial — only need first `count` elements)
+        for (let i = shuffled.length - 1; i > 0 && (shuffled.length - 1 - i) < count; i--) {
+            const j = randomInt(i + 1);
+            [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+        }
+        return shuffled.slice(-count);
+    }
+    /**
+     * Purge the .magi/ workspace directory, preserving specified files.
+     */
+    async purge(preserveFiles) {
+        try {
+            const entries = await readdir(this.workspaceDir, { withFileTypes: true });
+            for (const entry of entries) {
+                const name = entry.name;
+                if (preserveFiles.includes(name) || name === CIPHER_FILE)
+                    continue;
+                const fullPath = join(this.workspaceDir, name);
+                await rm(fullPath, { recursive: true, force: true });
+            }
+        }
+        catch (err) {
+            logger.debug('Neon Genesis: workspace not found, nothing to purge', { error: String(err) });
+        }
+    }
+    /**
+     * Write genesis log to workspace.
+     */
+    async writeGenesisLog(log) {
+        await safeMkdir(this.workspaceDir);
+        const logPath = join(this.workspaceDir, GENESIS_LOG_FILE);
+        await safeWriteFile(logPath, JSON.stringify(log, null, 2));
+    }
+    /**
+     * Load existing genesis log, if any.
+     */
+    async loadGenesisLog() {
+        try {
+            const logPath = join(this.workspaceDir, GENESIS_LOG_FILE);
+            const raw = await readFile(logPath, 'utf-8');
+            return safeJsonParse(raw);
+        }
+        catch (err) {
+            logger.debug('Neon Genesis: genesis log not found', { error: String(err) });
+            return null;
+        }
+    }
+}

package/dist/src/engine/objective-judge.d.ts

@@ -0,0 +1,53 @@
+/** Result from running a single tool */
+export interface ToolResult {
+    tool: 'tsc' | 'eslint' | 'vitest';
+    available: boolean;
+    passed: boolean;
+    issues: ToolIssue[];
+    summary: string;
+    rawOutput?: string;
+}
+/** A single issue found by a tool */
+export interface ToolIssue {
+    file?: string;
+    line?: number;
+    severity: 'error' | 'warning' | 'info';
+    message: string;
+    rule?: string;
+}
+/** Combined result from all tools */
+export interface ObjectiveResult {
+    score: number;
+    tools: ToolResult[];
+    summary: string;
+    evaluatedAt: Date;
+}
+/** Command runner function signature */
+type RunCommandFn = (cmd: string, args: string[], cwd: string) => Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}>;
+/**
+ * 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 declare class ObjectiveJudge {
+    private readonly cwd;
+    private readonly runCommand;
+    constructor(cwd: string, runCommand?: RunCommandFn);
+    private static defaultRunCommand;
+    evaluate(): Promise<ObjectiveResult>;
+    calculateScore(tools: ToolResult[]): number;
+    private buildSummary;
+    private runTsc;
+    private runEslint;
+    private runVitest;
+    parseTscOutput(output: string): ToolIssue[];
+    parseEslintOutput(output: string): ToolIssue[];
+    parseVitestOutput(output: string): ToolIssue[];
+}
+export {};