magi-ai 0.1.0

package/dist/src/engine/engram-manager.js

@@ -0,0 +1,306 @@
+/**
+ * EngramManager — 記憶・人格モジュール (A-01)
+ *
+ * MAGIシステムの長期記憶。過去の審議をエピソード記憶として保存し、
+ * TF-IDFベースの類似検索で関連する過去審議を検索する。
+ * 50件ごとに自動でセマンティック圧縮を行い、
+ * 手続き的戦略(どのタスクタイプでどの戦略が有効か)を蓄積する。
+ */
+import { readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { isDeadlock } from '../types/consensus.js';
+import { logger } from '../utils/logger.js';
+import { safeMkdir, safeWriteFile } from '../utils/safe-fs.js';
+import { safeJsonParse } from '../utils/safe-json-parse.js';
+// ── TF-IDF Engine (built-in) ─────────────────────────────────
+/**
+ * Tokenize text for TF-IDF: English space-split + Japanese bi-gram.
+ * Simple but effective for mixed-language deliberation content.
+ */
+export function tokenize(text) {
+    const tokens = [];
+    // English words (lowercase, 2+ chars)
+    const english = text.match(/[a-zA-Z_][a-zA-Z0-9_]*/g);
+    if (english) {
+        for (const w of english) {
+            if (w.length >= 2)
+                tokens.push(w.toLowerCase());
+        }
+    }
+    // Japanese bi-grams (CJK Unified Ideographs + Hiragana + Katakana)
+    const japanese = text.replace(/[a-zA-Z0-9\s_.,;:!?'"()[{}/<>@#$%^&*+=|\\~`\]-]/g, '');
+    for (let i = 0; i < japanese.length - 1; i++) {
+        tokens.push(japanese.slice(i, i + 2));
+    }
+    return tokens;
+}
+/** Compute TF (term frequency) for a token list */
+function computeTf(tokens) {
+    const tf = new Map();
+    for (const t of tokens) {
+        tf.set(t, (tf.get(t) ?? 0) + 1);
+    }
+    const total = tokens.length || 1;
+    for (const [k, v] of tf) {
+        tf.set(k, v / total);
+    }
+    return tf;
+}
+/** Compute IDF (inverse document frequency) from multiple documents */
+function computeIdf(docs) {
+    const df = new Map();
+    for (const tokens of docs) {
+        const unique = new Set(tokens);
+        for (const t of unique) {
+            df.set(t, (df.get(t) ?? 0) + 1);
+        }
+    }
+    const N = docs.length || 1;
+    const idf = new Map();
+    for (const [term, count] of df) {
+        idf.set(term, Math.log((N + 1) / (count + 1)) + 1); // smoothed IDF
+    }
+    return idf;
+}
+/** Compute TF-IDF vector as a Map<term, weight> */
+function computeTfIdf(tokens, idf) {
+    const tf = computeTf(tokens);
+    const tfidf = new Map();
+    for (const [term, tfVal] of tf) {
+        const idfVal = idf.get(term) ?? 1;
+        tfidf.set(term, tfVal * idfVal);
+    }
+    return tfidf;
+}
+/** Cosine similarity between two TF-IDF vectors */
+export function cosineSimilarity(a, b) {
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+    for (const [term, val] of a) {
+        normA += val * val;
+        const bVal = b.get(term);
+        if (bVal !== undefined)
+            dot += val * bVal;
+    }
+    for (const val of b.values()) {
+        normB += val * val;
+    }
+    const denom = Math.sqrt(normA) * Math.sqrt(normB);
+    return denom === 0 ? 0 : dot / denom;
+}
+/** Built-in TF-IDF similarity engine */
+export class TfIdfEngine {
+    computeSimilarity(query, documents) {
+        if (documents.length === 0)
+            return [];
+        const queryTokens = tokenize(query);
+        const docTokensList = documents.map(d => tokenize(d));
+        const allDocs = [queryTokens, ...docTokensList];
+        const idf = computeIdf(allDocs);
+        const queryVec = computeTfIdf(queryTokens, idf);
+        return docTokensList.map(docTokens => {
+            const docVec = computeTfIdf(docTokens, idf);
+            return cosineSimilarity(queryVec, docVec);
+        });
+    }
+}
+// ── EngramManager ────────────────────────────────────────────
+const CONSOLIDATION_THRESHOLD = 50;
+export class EngramManager {
+    episodic = [];
+    semantic = [];
+    procedural = [];
+    baseDir;
+    engine;
+    eventBus;
+    episodicSinceConsolidation = 0;
+    constructor(workspaceDir, eventBus, engine) {
+        this.baseDir = join(workspaceDir, 'engram');
+        this.eventBus = eventBus;
+        this.engine = engine ?? new TfIdfEngine();
+    }
+    /** Record a completed deliberation as episodic memory (fire-and-forget safe) */
+    async recordDeliberation(delib) {
+        const lastRound = delib.rounds[delib.rounds.length - 1];
+        const allKeyPoints = lastRound?.opinions.flatMap(o => o.keyPoints) ?? [];
+        const memory = {
+            deliberationId: delib.id,
+            taskType: delib.task.type,
+            taskTitle: delib.task.title,
+            taskDescription: delib.task.description,
+            decision: delib.consensus.decision,
+            confidence: delib.consensus.confidence,
+            keyPoints: allKeyPoints,
+            units: lastRound?.opinions.map(o => o.unit) ?? [],
+            timestamp: new Date().toISOString(),
+        };
+        this.episodic.push(memory);
+        this.episodicSinceConsolidation++;
+        // Persist episodic memory (fire-and-forget)
+        this.persistEpisodic(memory).catch(err => {
+            logger.warn('Failed to persist episodic memory', { error: String(err) });
+        });
+        // Auto-consolidation
+        if (this.episodicSinceConsolidation >= CONSOLIDATION_THRESHOLD) {
+            await this.consolidate();
+        }
+    }
+    /** Find similar past deliberations using TF-IDF cosine similarity */
+    findSimilar(taskDescription, limit = 3) {
+        if (this.episodic.length === 0)
+            return [];
+        const documents = this.episodic.map(e => `${e.taskTitle} ${e.taskDescription} ${e.keyPoints.join(' ')}`);
+        const scores = this.engine.computeSimilarity(taskDescription, documents);
+        const indexed = scores.map((score, i) => ({ score, index: i }));
+        indexed.sort((a, b) => b.score - a.score);
+        return indexed.slice(0, limit).map(({ index }) => this.episodic[index]);
+    }
+    /**
+     * Consolidate episodic memories → semantic patterns + procedural strategies.
+     * Rule-based extraction (no AI call needed).
+     */
+    async consolidate() {
+        if (this.episodic.length === 0)
+            return;
+        const now = new Date().toISOString();
+        // Extract semantic patterns: group by frequent keyPoints
+        const pointFreq = new Map();
+        for (const ep of this.episodic) {
+            for (const kp of ep.keyPoints) {
+                const normalized = kp.toLowerCase().trim();
+                if (normalized.length < 5)
+                    continue;
+                const entry = pointFreq.get(normalized) ?? { count: 0, domains: new Set(), totalConf: 0 };
+                entry.count++;
+                entry.domains.add(ep.taskType);
+                entry.totalConf += ep.confidence;
+                pointFreq.set(normalized, entry);
+            }
+        }
+        const newPatterns = [];
+        for (const [pattern, data] of pointFreq) {
+            if (data.count >= 2) {
+                newPatterns.push({
+                    pattern,
+                    frequency: data.count,
+                    domains: [...data.domains],
+                    confidence: data.totalConf / data.count,
+                    extractedAt: now,
+                });
+            }
+        }
+        this.semantic = newPatterns;
+        // Extract procedural strategies: success rate by taskType×decision
+        const stratMap = new Map();
+        for (const ep of this.episodic) {
+            const key = ep.taskType;
+            const entry = stratMap.get(key) ?? { success: 0, total: 0, lastUsed: ep.timestamp };
+            entry.total++;
+            if (!isDeadlock(ep.decision))
+                entry.success++;
+            if (ep.timestamp > entry.lastUsed)
+                entry.lastUsed = ep.timestamp;
+            stratMap.set(key, entry);
+        }
+        this.procedural = [];
+        for (const [taskType, data] of stratMap) {
+            this.procedural.push({
+                taskType,
+                strategy: `${taskType} deliberation pattern`,
+                successRate: data.total > 0 ? data.success / data.total : 0,
+                sampleCount: data.total,
+                lastUsed: data.lastUsed,
+            });
+        }
+        this.episodicSinceConsolidation = 0;
+        // Persist consolidated data
+        await Promise.allSettled([
+            this.persistSemantic(),
+            this.persistProcedural(),
+        ]);
+        this.eventBus?.emit('memory:consolidated', {
+            episodicCount: this.episodic.length,
+            patternsExtracted: newPatterns.length,
+            strategiesUpdated: this.procedural.length,
+            emittedAt: new Date(),
+        });
+        logger.info('Memory consolidation complete', {
+            episodic: this.episodic.length,
+            patterns: newPatterns.length,
+            strategies: this.procedural.length,
+        });
+    }
+    // ── Persistence ────────────────────────────────────────────
+    /** Load all memory from disk */
+    async load() {
+        await Promise.allSettled([
+            this.loadEpisodic(),
+            this.loadSemantic(),
+            this.loadProcedural(),
+        ]);
+    }
+    /** Persist all memory to disk */
+    async persist() {
+        await Promise.allSettled([
+            this.persistSemantic(),
+            this.persistProcedural(),
+        ]);
+    }
+    async persistEpisodic(memory) {
+        const dir = join(this.baseDir, 'episodic');
+        await safeMkdir(dir);
+        const filePath = join(dir, `${memory.deliberationId}.json`);
+        await safeWriteFile(filePath, JSON.stringify(memory, null, 2));
+    }
+    async loadEpisodic() {
+        const dir = join(this.baseDir, 'episodic');
+        try {
+            const files = await readdir(dir);
+            const jsons = files.filter(f => f.endsWith('.json'));
+            const memories = await Promise.allSettled(jsons.map(async (f) => {
+                const data = await readFile(join(dir, f), 'utf-8');
+                return safeJsonParse(data);
+            }));
+            this.episodic = memories
+                .filter((r) => r.status === 'fulfilled')
+                .map(r => r.value);
+        }
+        catch (err) {
+            logger.debug('EngramManager: episodic memory directory not found', { error: String(err) });
+        }
+    }
+    async persistSemantic() {
+        const dir = join(this.baseDir, 'semantic');
+        await safeMkdir(dir);
+        await safeWriteFile(join(dir, 'patterns.json'), JSON.stringify(this.semantic, null, 2));
+    }
+    async loadSemantic() {
+        try {
+            const data = await readFile(join(this.baseDir, 'semantic', 'patterns.json'), 'utf-8');
+            this.semantic = safeJsonParse(data);
+        }
+        catch (err) {
+            logger.debug('EngramManager: semantic patterns not found', { error: String(err) });
+        }
+    }
+    async persistProcedural() {
+        const dir = join(this.baseDir, 'procedural');
+        await safeMkdir(dir);
+        await safeWriteFile(join(dir, 'strategies.json'), JSON.stringify(this.procedural, null, 2));
+    }
+    async loadProcedural() {
+        try {
+            const data = await readFile(join(this.baseDir, 'procedural', 'strategies.json'), 'utf-8');
+            this.procedural = safeJsonParse(data);
+        }
+        catch (err) {
+            logger.debug('EngramManager: procedural strategies not found', { error: String(err) });
+        }
+    }
+    // ── Getters (for tests and integration) ────────────────────
+    getEpisodicMemories() { return this.episodic; }
+    getSemanticPatterns() { return this.semantic; }
+    getProceduralStrategies() { return this.procedural; }
+    getEpisodicSinceConsolidation() { return this.episodicSinceConsolidation; }
+}

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

@@ -0,0 +1,130 @@
+import { EventEmitter } from 'node:events';
+import type { ConsensusDecision } from '../types/consensus.js';
+import type { SyncRateUpdatedEvent, BerserkWarningEvent, BiasDetectedEvent, GospelMilestoneEvent, UmbilicalStatusChangedEvent, DummyPlugActivatedEvent, DummyPlugRecoveryEvent, CipherDiscoveredEvent } from '../types/phase-h.js';
+import type { MemoryDriftWarningEvent, MemoryConsolidatedEvent, BerserkActivatedEvent, BerserkDeactivatedEvent, InstrumentalityTriggeredEvent, FusionCompleteEvent, LCLContaminationDetectedEvent, LCLPurifiedEvent } from '../types/phase-i.js';
+import type { AngelDetectedEvent, NebuchadnezzarOverrideEvent, ScrollsProphecyEvent, ScrollsFulfilledEvent, SelfDestructMotionEvent, SelfDestructCountdownEvent, SelfDestructExecutedEvent, SelfDestructAbortedEvent, FirewallScanEvent, FirewallBlockedEvent } from '../types/phase-k.js';
+import type { EvolutionStartedEvent, EvolutionProposalEvent, EvolutionAppliedEvent, EvolutionRollbackEvent, IruelInfiltrationEvent, IruelCounterhackEvent, IruelNeutralizedEvent, SeeleGatheringEvent, SeeleAttackEvent, SeeleConcludedEvent, GenesisStartedEvent, GenesisCompleteEvent } from '../types/phase-l.js';
+export interface DeliberationStartEvent {
+    deliberationId: string;
+    taskType: string;
+    taskTitle: string;
+    emittedAt: Date;
+}
+export interface PhaseStartEvent {
+    deliberationId: string;
+    phase: string;
+    roundNumber: number;
+    emittedAt: Date;
+}
+export interface UnitStartEvent {
+    deliberationId: string;
+    unit: string;
+    phase: string;
+    emittedAt: Date;
+}
+export interface UnitCompleteEvent {
+    deliberationId: string;
+    unit: string;
+    phase: string;
+    vote: string;
+    confidence: number;
+    durationMs: number;
+    reasoningSummary?: string;
+    emittedAt: Date;
+}
+export interface PhaseSkippedEvent {
+    deliberationId: string;
+    phase: string;
+    reason: 'unanimous_early_exit' | 'majority_early_exit';
+    emittedAt: Date;
+}
+export interface UnitChunkEvent {
+    deliberationId: string;
+    unit: string;
+    chunk: string;
+    stream: 'stdout' | 'stderr';
+    emittedAt: Date;
+}
+export interface UnitErrorEvent {
+    deliberationId: string;
+    unit: string;
+    phase: string;
+    error: string;
+    emittedAt: Date;
+}
+export interface PhaseCompleteEvent {
+    deliberationId: string;
+    phase: string;
+    roundNumber: number;
+    durationMs: number;
+    emittedAt: Date;
+}
+export interface DeliberationCompleteEvent {
+    deliberationId: string;
+    decision: ConsensusDecision;
+    totalDurationMs: number;
+    rounds: number;
+    fromCache: boolean;
+    emittedAt: Date;
+}
+export interface MagiEventMap {
+    'deliberation:start': DeliberationStartEvent;
+    'phase:start': PhaseStartEvent;
+    'unit:start': UnitStartEvent;
+    'unit:chunk': UnitChunkEvent;
+    'unit:complete': UnitCompleteEvent;
+    'unit:error': UnitErrorEvent;
+    'phase:complete': PhaseCompleteEvent;
+    'phase:skipped': PhaseSkippedEvent;
+    'deliberation:complete': DeliberationCompleteEvent;
+    'syncrate:updated': SyncRateUpdatedEvent;
+    'berserk:warning': BerserkWarningEvent;
+    'bias:detected': BiasDetectedEvent;
+    'gospel:milestone': GospelMilestoneEvent;
+    'umbilical:status_changed': UmbilicalStatusChangedEvent;
+    'dummyplug:activated': DummyPlugActivatedEvent;
+    'dummyplug:recovery': DummyPlugRecoveryEvent;
+    'cipher:discovered': CipherDiscoveredEvent;
+    'memory:drift-warning': MemoryDriftWarningEvent;
+    'memory:consolidated': MemoryConsolidatedEvent;
+    'berserk:activated': BerserkActivatedEvent;
+    'berserk:deactivated': BerserkDeactivatedEvent;
+    'instrumentality:triggered': InstrumentalityTriggeredEvent;
+    'fusion:complete': FusionCompleteEvent;
+    'lcl:contamination-detected': LCLContaminationDetectedEvent;
+    'lcl:purified': LCLPurifiedEvent;
+    'angel:detected': AngelDetectedEvent;
+    'nebuchadnezzar:override': NebuchadnezzarOverrideEvent;
+    'scrolls:prophecy': ScrollsProphecyEvent;
+    'scrolls:fulfilled': ScrollsFulfilledEvent;
+    'selfdestruct:motion': SelfDestructMotionEvent;
+    'selfdestruct:countdown': SelfDestructCountdownEvent;
+    'selfdestruct:executed': SelfDestructExecutedEvent;
+    'selfdestruct:aborted': SelfDestructAbortedEvent;
+    'firewall:scan': FirewallScanEvent;
+    'firewall:blocked': FirewallBlockedEvent;
+    'evolution:started': EvolutionStartedEvent;
+    'evolution:proposal': EvolutionProposalEvent;
+    'evolution:applied': EvolutionAppliedEvent;
+    'evolution:rollback': EvolutionRollbackEvent;
+    'iruel:infiltration': IruelInfiltrationEvent;
+    'iruel:counterhack': IruelCounterhackEvent;
+    'iruel:neutralized': IruelNeutralizedEvent;
+    'seele:gathering': SeeleGatheringEvent;
+    'seele:attack': SeeleAttackEvent;
+    'seele:concluded': SeeleConcludedEvent;
+    'genesis:started': GenesisStartedEvent;
+    'genesis:complete': GenesisCompleteEvent;
+    'bus:error': {
+        originalEvent: string;
+        error: Error;
+        emittedAt: Date;
+    };
+}
+export type MagiEventName = keyof MagiEventMap;
+export declare class MagiEventBus extends EventEmitter {
+    emit<K extends MagiEventName>(event: K, payload: MagiEventMap[K]): boolean;
+    on<K extends MagiEventName>(event: K, listener: (payload: MagiEventMap[K]) => void): this;
+    once<K extends MagiEventName>(event: K, listener: (payload: MagiEventMap[K]) => void): this;
+    off<K extends MagiEventName>(event: K, listener: (payload: MagiEventMap[K]) => void): this;
+}

package/dist/src/engine/events.js

@@ -0,0 +1,44 @@
+import { EventEmitter } from 'node:events';
+import { logger } from '../utils/logger.js';
+// ── Type-safe EventBus ─────────────────────────────────────────────
+export class MagiEventBus extends EventEmitter {
+    emit(event, payload) {
+        // bus:error uses super.emit directly to prevent infinite loops
+        if (event === 'bus:error') {
+            try {
+                return super.emit(event, payload);
+            }
+            catch (err) {
+                logger.debug('EventBus: bus:error listener threw, swallowing to prevent recursion', { error: String(err) });
+                return false;
+            }
+        }
+        // rawListeners() preserves once-wrappers (listeners() unwraps them)
+        const listeners = this.rawListeners(event);
+        for (const listener of listeners) {
+            try {
+                listener(payload);
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error(String(err));
+                logger.error(`EventBus listener threw on "${String(event)}"`, { error: error.message });
+                try {
+                    super.emit('bus:error', { originalEvent: String(event), error, emittedAt: new Date() });
+                }
+                catch (err2) {
+                    logger.debug('EventBus: bus:error listener threw during error propagation', { error: String(err2) });
+                }
+            }
+        }
+        return listeners.length > 0;
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    once(event, listener) {
+        return super.once(event, listener);
+    }
+    off(event, listener) {
+        return super.off(event, listener);
+    }
+}

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

@@ -0,0 +1,30 @@
+/**
+ * A-10 福音 (GospelChronicle)
+ *
+ * MAGIシステムの審議履歴を「福音」として記録する。
+ * chronicle.jsonl にエントリを追記し、narrative.md に物語的サマリーを生成。
+ * マイルストーン（初回全会一致、初回デッドロック、100回、1000回）を検出する。
+ */
+import type { MagiDeliberation } from '../types/core.js';
+import type { ConsensusDecision } from '../types/consensus.js';
+import type { MagiEventBus } from './events.js';
+import type { ChronicleEntry, MilestoneType } from '../types/phase-h.js';
+export declare class GospelChronicle {
+    private gospelDir;
+    private count;
+    private hasUnanimous;
+    private hasDeadlock;
+    constructor(workspaceDir: string);
+    /** Initialize gospel directory and restore state from existing chronicle */
+    initialize(): Promise<void>;
+    /** Record a deliberation result */
+    record(deliberation: MagiDeliberation, eventBus?: MagiEventBus): Promise<ChronicleEntry>;
+    /** Detect milestones based on current state */
+    detectMilestone(decision: ConsensusDecision): MilestoneType | undefined;
+    /** Generate a narrative entry for the markdown chronicle */
+    generateNarrative(entry: ChronicleEntry): string;
+    /** Get current deliberation count */
+    getCount(): number;
+    private chroniclePath;
+    private narrativePath;
+}

package/dist/src/engine/gospel.js

@@ -0,0 +1,129 @@
+/**
+ * A-10 福音 (GospelChronicle)
+ *
+ * MAGIシステムの審議履歴を「福音」として記録する。
+ * chronicle.jsonl にエントリを追記し、narrative.md に物語的サマリーを生成。
+ * マイルストーン（初回全会一致、初回デッドロック、100回、1000回）を検出する。
+ */
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { isUnanimous, isDeadlock } from '../types/consensus.js';
+import { logger } from '../utils/logger.js';
+import { safeMkdir, safeAppendFile } from '../utils/safe-fs.js';
+import { safeJsonParse } from '../utils/safe-json-parse.js';
+export class GospelChronicle {
+    gospelDir;
+    count = 0;
+    hasUnanimous = false;
+    hasDeadlock = false;
+    constructor(workspaceDir) {
+        this.gospelDir = join(workspaceDir, 'gospel');
+    }
+    /** Initialize gospel directory and restore state from existing chronicle */
+    async initialize() {
+        await safeMkdir(this.gospelDir);
+        try {
+            const raw = await readFile(this.chroniclePath(), 'utf-8');
+            const lines = raw.trim().split('\n').filter(Boolean);
+            this.count = lines.length;
+            // Scan for existing milestones to avoid re-detection
+            for (const line of lines) {
+                try {
+                    const entry = safeJsonParse(line);
+                    if (isUnanimous(entry.decision))
+                        this.hasUnanimous = true;
+                    if (isDeadlock(entry.decision))
+                        this.hasDeadlock = true;
+                }
+                catch (err) {
+                    logger.debug('Gospel: corrupt chronicle line', { error: String(err) });
+                }
+            }
+        }
+        catch (err) {
+            logger.debug('Gospel: no existing chronicle, starting fresh', { error: String(err) });
+            this.count = 0;
+        }
+    }
+    /** Record a deliberation result */
+    async record(deliberation, eventBus) {
+        this.count++;
+        const lastRound = deliberation.rounds[deliberation.rounds.length - 1];
+        const units = lastRound?.opinions.map(o => o.unit) ?? [];
+        const milestone = this.detectMilestone(deliberation.consensus.decision);
+        const entry = {
+            number: this.count,
+            deliberationId: deliberation.id,
+            taskType: deliberation.task.type,
+            taskTitle: deliberation.task.title,
+            decision: deliberation.consensus.decision,
+            confidence: deliberation.consensus.confidence,
+            units,
+            milestone,
+            timestamp: new Date().toISOString(),
+        };
+        // Append to chronicle.jsonl
+        await safeAppendFile(this.chroniclePath(), JSON.stringify(entry) + '\n');
+        // Append to narrative.md
+        await safeAppendFile(this.narrativePath(), this.generateNarrative(entry) + '\n');
+        // Emit milestone event
+        if (milestone && eventBus) {
+            eventBus.emit('gospel:milestone', {
+                deliberationId: deliberation.id,
+                milestone,
+                count: this.count,
+                emittedAt: new Date(),
+            });
+        }
+        return entry;
+    }
+    /** Detect milestones based on current state */
+    detectMilestone(decision) {
+        if (this.count === 1)
+            return 'first_deliberation';
+        if (!this.hasUnanimous && isUnanimous(decision)) {
+            this.hasUnanimous = true;
+            return 'first_unanimous';
+        }
+        if (!this.hasDeadlock && isDeadlock(decision)) {
+            this.hasDeadlock = true;
+            return 'first_deadlock';
+        }
+        if (this.count === 100)
+            return 'centenary';
+        if (this.count === 1000)
+            return 'millennium';
+        return undefined;
+    }
+    /** Generate a narrative entry for the markdown chronicle */
+    generateNarrative(entry) {
+        const date = new Date(entry.timestamp);
+        const dateStr = date.toLocaleDateString('ja-JP', { year: 'numeric', month: 'long', day: 'numeric' });
+        const confidence = (entry.confidence * 100).toFixed(1);
+        let narrative = `### 第${entry.number}審議 — ${dateStr}\n\n`;
+        narrative += `**議題**: ${entry.taskTitle} (${entry.taskType})\n`;
+        narrative += `**判定**: ${entry.decision} (確信度 ${confidence}%)\n`;
+        narrative += `**参加**: ${entry.units.join(', ')}\n`;
+        if (entry.milestone) {
+            const milestoneLabels = {
+                first_deliberation: 'MAGIシステム、最初の審議を完了',
+                first_unanimous: '初の全会一致 — 三位一体の調和',
+                first_deadlock: '初のデッドロック — 意見の断絶',
+                centenary: '百の審議を超えて — centenary milestone',
+                millennium: '千の審議を超えて — millennium milestone',
+            };
+            narrative += `\n> **[MILESTONE]** ${milestoneLabels[entry.milestone]}\n`;
+        }
+        return narrative;
+    }
+    /** Get current deliberation count */
+    getCount() {
+        return this.count;
+    }
+    chroniclePath() {
+        return join(this.gospelDir, 'chronicle.jsonl');
+    }
+    narrativePath() {
+        return join(this.gospelDir, 'narrative.md');
+    }
+}

package/dist/src/engine/hallucination-detector.d.ts

@@ -0,0 +1,33 @@
+/**
+ * HallucinationDetector — Detects fabricated content in MAGI opinions
+ *
+ * Stateless detector that identifies 4 types of hallucinations:
+ * 1. Fabricated file paths (generic placeholder paths)
+ * 2. Abnormal line numbers (impossibly large or zero)
+ * 3. Vote-reasoning mismatch (contradictory vote + reasoning)
+ * 4. Fabricated references (non-existent RFC/CVE numbers)
+ *
+ * Part of B-02 LCL (shared consciousness pool).
+ */
+import type { MagiOpinion } from '../types/core.js';
+import type { HallucinationReport } from '../types/phase-i.js';
+export declare class HallucinationDetector {
+    /**
+     * Run all hallucination checks on an opinion.
+     * Returns an array of reports (empty if no hallucinations detected).
+     */
+    detect(opinion: MagiOpinion): HallucinationReport[];
+    /**
+     * Create a purified copy of the opinion with hallucinations annotated.
+     * Only purifies reports with confidence >= PURIFY_CONFIDENCE_THRESHOLD.
+     */
+    purify(opinion: MagiOpinion, reports: HallucinationReport[]): MagiOpinion;
+    /** Detect fabricated file paths like /path/to/xxx, /foo/bar/baz.ts */
+    checkFilePaths(text: string): HallucinationReport[];
+    /** Detect abnormal line numbers (line 0, line > 50000) */
+    checkLineNumbers(text: string): HallucinationReport[];
+    /** Detect mismatch between vote and reasoning sentiment */
+    checkVoteReasoningMismatch(opinion: MagiOpinion): HallucinationReport[];
+    /** Detect fabricated RFC/CVE references */
+    checkFabricatedReferences(text: string): HallucinationReport[];
+}