magi-ai 0.1.0

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

@@ -0,0 +1,178 @@
+import { z } from 'zod/v4';
+/** MAGI unit identifier — string to support N-body configurations (2-7 units) */
+export type MagiUnit = string;
+/** Built-in MAGI unit identifiers for the classic 3-body configuration */
+export type BuiltinMagiUnit = 'MELCHIOR' | 'BALTHASAR' | 'CASPER';
+/** Definition of a MAGI unit */
+export interface MagiUnitDefinition {
+    id: string;
+    displayName: string;
+    role: string;
+    focus: string;
+    weight: number;
+}
+/** Built-in MAGI unit definitions */
+export declare const BUILTIN_UNITS: Record<BuiltinMagiUnit, MagiUnitDefinition>;
+/** Underlying CLI tool identifier */
+export type CliTool = 'claude' | 'codex' | 'gemini';
+/** Mapping from MAGI unit to CLI tool (built-in units only) */
+export declare const MAGI_CLI_MAP: {
+    readonly MELCHIOR: "claude";
+    readonly BALTHASAR: "codex";
+    readonly CASPER: "gemini";
+};
+/** Reverse mapping from CLI tool to MAGI unit (built-in units only) */
+export declare const CLI_MAGI_MAP: {
+    readonly claude: "MELCHIOR";
+    readonly codex: "BALTHASAR";
+    readonly gemini: "CASPER";
+};
+/** MAGI persona descriptions (backward compat, derived from BUILTIN_UNITS) */
+export declare const MAGI_PERSONAS: {
+    readonly MELCHIOR: {
+        readonly name: string;
+        readonly role: string;
+        readonly focus: string;
+    };
+    readonly BALTHASAR: {
+        readonly name: string;
+        readonly role: string;
+        readonly focus: string;
+    };
+    readonly CASPER: {
+        readonly name: string;
+        readonly role: string;
+        readonly focus: string;
+    };
+};
+/** Vote schema: normalizes case and whitespace → enum literal */
+export declare const VoteSchema: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+    APPROVE: "APPROVE";
+    REJECT: "REJECT";
+    ABSTAIN: "ABSTAIN";
+}>>;
+/** Confidence schema: clamps to 0.0-1.0 range */
+export declare const ConfidenceSchema: z.ZodPipe<z.ZodNumber, z.ZodTransform<number, number>>;
+/** UUID v4 format regex */
+export declare const UUID_V4_RE: RegExp;
+/** Zod schema for task ID validation (UUID v4 format) */
+export declare const MagiTaskIdSchema: z.ZodString;
+/** Zod schema for task type validation */
+export declare const TaskTypeSchema: z.ZodEnum<{
+    custom: "custom";
+    "code-review": "code-review";
+    "architecture-decision": "architecture-decision";
+    "bug-analysis": "bug-analysis";
+    "implementation-plan": "implementation-plan";
+    "security-audit": "security-audit";
+}>;
+/** Zod schema for task artifact validation */
+export declare const TaskArtifactSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        file: "file";
+        diff: "diff";
+        snippet: "snippet";
+        url: "url";
+    }>;
+    path: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    language: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Zod schema for MagiTask validation */
+export declare const MagiTaskSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<{
+        custom: "custom";
+        "code-review": "code-review";
+        "architecture-decision": "architecture-decision";
+        "bug-analysis": "bug-analysis";
+        "implementation-plan": "implementation-plan";
+        "security-audit": "security-audit";
+    }>;
+    title: z.ZodString;
+    description: z.ZodString;
+    artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            file: "file";
+            diff: "diff";
+            snippet: "snippet";
+            url: "url";
+        }>;
+        path: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+        language: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    context: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Vote choices in MAGI deliberation (derived from VoteSchema) */
+export type Vote = z.infer<typeof VoteSchema>;
+/** Confidence level for a vote (0.0 - 1.0) (derived from ConfidenceSchema) */
+export type Confidence = z.infer<typeof ConfidenceSchema>;
+/** Supported task types (derived from TaskTypeSchema) */
+export type TaskType = z.infer<typeof TaskTypeSchema>;
+/** File or code artifact attached to a task (derived from TaskArtifactSchema) */
+export type TaskArtifact = z.infer<typeof TaskArtifactSchema>;
+/**
+ * Task submitted for MAGI deliberation.
+ *
+ * Core fields are derived from MagiTaskSchema. The `config` field is
+ * an extension not covered by the schema (pipeline-specific override).
+ */
+export type MagiTask = z.infer<typeof MagiTaskSchema> & {
+    config?: import('./pipeline.js').PipelineConfigOverride;
+};
+/**
+ * A single MAGI unit's opinion on a matter.
+ *
+ * The payload fields (vote, confidence, reasoning, keyPoints, suggestions)
+ * overlap with OpinionPayloadSchema in parsers/opinion-schema.ts.
+ * The extra fields (unit, rawOutput, meta) are adapter-level concerns
+ * not part of the validated payload, so MagiOpinion remains a manual
+ * interface to avoid circular imports.
+ */
+export interface MagiOpinion {
+    unit: MagiUnit;
+    vote: Vote;
+    confidence: Confidence;
+    reasoning: string;
+    keyPoints: string[];
+    suggestions?: string[];
+    rawOutput: string;
+    meta: ExecutionMeta;
+}
+/** Metadata about CLI execution */
+export interface ExecutionMeta {
+    durationMs: number;
+    exitCode: number;
+    model?: string;
+    tokens?: {
+        input?: number;
+        output?: number;
+    };
+    retryCount: number;
+    structuredOutput: boolean;
+}
+/** A complete deliberation round */
+export interface DeliberationRound {
+    roundNumber: number;
+    phase: DeliberationPhase;
+    opinions: MagiOpinion[];
+    startedAt: Date;
+    completedAt: Date;
+}
+/** Phases of deliberation */
+export type DeliberationPhase = 'initial-opinion' | 'cross-examination' | 'final-vote';
+/** The complete result of a MAGI deliberation */
+export interface MagiDeliberation {
+    id: string;
+    task: MagiTask;
+    rounds: DeliberationRound[];
+    consensus: import('./consensus.js').ConsensusResult;
+    totalDurationMs: number;
+    startedAt: Date;
+    completedAt: Date;
+    fromCache?: boolean;
+    objectiveResult?: import('../engine/objective-judge.js').ObjectiveResult;
+}

package/dist/src/types/core.js

@@ -0,0 +1,85 @@
+import { z } from 'zod/v4';
+/** Built-in MAGI unit definitions */
+export const BUILTIN_UNITS = {
+    MELCHIOR: {
+        id: 'MELCHIOR',
+        displayName: 'MELCHIOR-1',
+        role: 'Scientist (科学者)',
+        focus: 'Rigorous logic, correctness, type safety, edge cases, algorithmic efficiency',
+        weight: 1.0,
+    },
+    BALTHASAR: {
+        id: 'BALTHASAR',
+        displayName: 'BALTHASAR-2',
+        role: 'Pragmatist (実装者)',
+        focus: 'Practical implementation, readability, maintainability, real-world usage patterns',
+        weight: 1.0,
+    },
+    CASPER: {
+        id: 'CASPER',
+        displayName: 'CASPER-3',
+        role: 'Reviewer (審査者)',
+        focus: 'Safety, security, risk assessment, architectural implications, big picture',
+        weight: 1.0,
+    },
+};
+/** Mapping from MAGI unit to CLI tool (built-in units only) */
+export const MAGI_CLI_MAP = {
+    MELCHIOR: 'claude',
+    BALTHASAR: 'codex',
+    CASPER: 'gemini',
+};
+/** Reverse mapping from CLI tool to MAGI unit (built-in units only) */
+export const CLI_MAGI_MAP = {
+    claude: 'MELCHIOR',
+    codex: 'BALTHASAR',
+    gemini: 'CASPER',
+};
+/** MAGI persona descriptions (backward compat, derived from BUILTIN_UNITS) */
+export const MAGI_PERSONAS = {
+    MELCHIOR: { name: BUILTIN_UNITS.MELCHIOR.displayName, role: BUILTIN_UNITS.MELCHIOR.role, focus: BUILTIN_UNITS.MELCHIOR.focus },
+    BALTHASAR: { name: BUILTIN_UNITS.BALTHASAR.displayName, role: BUILTIN_UNITS.BALTHASAR.role, focus: BUILTIN_UNITS.BALTHASAR.focus },
+    CASPER: { name: BUILTIN_UNITS.CASPER.displayName, role: BUILTIN_UNITS.CASPER.role, focus: BUILTIN_UNITS.CASPER.focus },
+};
+// ============================================================
+// Zod Schemas (Single Source of Truth for runtime validation + type derivation)
+// ============================================================
+/** Vote schema: normalizes case and whitespace → enum literal */
+export const VoteSchema = z
+    .string()
+    .transform((v) => v.trim().toUpperCase())
+    .pipe(z.enum(['APPROVE', 'REJECT', 'ABSTAIN']));
+/** Confidence schema: clamps to 0.0-1.0 range */
+export const ConfidenceSchema = z
+    .number()
+    .transform((n) => Math.max(0, Math.min(1, n)));
+/** UUID v4 format regex */
+export 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;
+/** Zod schema for task ID validation (UUID v4 format) */
+export const MagiTaskIdSchema = z.string().regex(UUID_V4_RE, 'Task ID must be a valid UUID v4');
+/** Zod schema for task type validation */
+export const TaskTypeSchema = z.enum([
+    'code-review',
+    'architecture-decision',
+    'bug-analysis',
+    'implementation-plan',
+    'security-audit',
+    'custom',
+]);
+/** Zod schema for task artifact validation */
+export const TaskArtifactSchema = z.object({
+    type: z.enum(['file', 'diff', 'snippet', 'url']),
+    path: z.string().optional(),
+    content: z.string().optional(),
+    language: z.string().optional(),
+    label: z.string().optional(),
+});
+/** Zod schema for MagiTask validation */
+export const MagiTaskSchema = z.object({
+    id: MagiTaskIdSchema.optional(),
+    type: TaskTypeSchema,
+    title: z.string().min(1).max(500),
+    description: z.string().min(1).max(50_000),
+    artifacts: z.array(TaskArtifactSchema).optional(),
+    context: z.string().max(200_000).optional(),
+});

package/dist/src/types/magi-api.d.ts

@@ -0,0 +1,62 @@
+/**
+ * MAGI Namespaced API type definitions.
+ *
+ * Three namespaces: runtime / diagnostics / admin
+ * All exposed via readonly getters on the Magi class.
+ */
+import type { AngelDetection, CochangeEdge, Prophecy, ProphecyAccuracy, FirewallResult, NebuchadnezzarState, SelfDestructMotion, SelfDestructPhase } from './phase-k.js';
+import type { IruelBattlePhase, EvolutionGeneration, DiagnosticStats, SeeleSession, GenesisLog, MagiNodeId } from './phase-l.js';
+import type { MagiUnit, Vote } from './core.js';
+export interface WatchHandle {
+    stop(): void;
+    readonly running: boolean;
+}
+export interface MagiRuntime {
+    startWatch(opts?: {
+        pollIntervalMs?: number;
+        signal?: AbortSignal;
+    }): WatchHandle;
+    stopWatch(): void;
+    detectFromCommit(hash: string): Promise<AngelDetection[]>;
+    getCochangeGraph(): CochangeEdge[];
+    analyzeFile(filePath: string): Promise<Prophecy>;
+    analyzeAll(dirPath: string): Promise<Prophecy[]>;
+    getScrollsAccuracy(): ProphecyAccuracy;
+    scanFirewall(input: string): FirewallResult;
+    getFirewallStats(): {
+        patternCount: number;
+        dynamicCount: number;
+    };
+}
+export interface MagiDiagnostics {
+    simulateIruelBattle(): Promise<IruelBattlePhase>;
+    getIruelPhase(): IruelBattlePhase;
+    resetIruelBattle(): void;
+    computeASI(unit: string): number;
+    checkDrift(unit: string): boolean;
+    evolve(opts?: {
+        dryRun?: boolean;
+        maxProposals?: number;
+    }): Promise<EvolutionGeneration>;
+    diagnose(): Promise<DiagnosticStats>;
+    getChronicleEntryCount(): number;
+    getLCLDensity(phase: string): number;
+}
+export interface MagiAdmin {
+    simulateSeele(opts?: {
+        attack?: boolean;
+    }): Promise<SeeleSession>;
+    executeSeeleAttack(attackers: MagiNodeId[], target: MagiNodeId): Promise<{
+        success: boolean;
+        defenseHeld: boolean;
+    }>;
+    formatSeelePanel(): string;
+    fileDestructMotion(reason: string): SelfDestructMotion;
+    castDestructVote(motionId: string, unit: MagiUnit, vote: Vote): void;
+    executeDestruct(motionId: string): Promise<SelfDestructMotion>;
+    getDestructPhase(): SelfDestructPhase;
+    resetDestruct(): void;
+    executeGenesis(reason: string, force?: boolean): Promise<GenesisLog>;
+    loadGenesisLog(): Promise<GenesisLog | null>;
+    getNebuchadnezzarState(): NebuchadnezzarState | null;
+}

package/dist/src/types/magi-api.js

@@ -0,0 +1,7 @@
+/**
+ * MAGI Namespaced API type definitions.
+ *
+ * Three namespaces: runtime / diagnostics / admin
+ * All exposed via readonly getters on the Magi class.
+ */
+export {};

package/dist/src/types/phase-h.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Phase H (Soul Plan) — Type definitions
+ *
+ * エヴァンゲリオンの世界観をMAGIシステムに技術的に組み込むための
+ * 全モジュール共通型定義。
+ */
+import type { MagiUnit, MagiOpinion, Vote } from './core.js';
+import type { ConsensusDecision } from './consensus.js';
+/** Beta distribution parameters for Bayesian sync rate estimation */
+export interface BetaParams {
+    alpha: number;
+    beta: number;
+}
+/** A single sync rate entry for a (unit, domain) pair */
+export interface SyncRateEntry {
+    params: BetaParams;
+    updatedAt: string;
+}
+/** Map of domain → sync rate entry */
+export type UnitSyncRates = Record<string, SyncRateEntry>;
+/** Map of unit → weight for consensus injection */
+export type SyncWeightMap = Partial<Record<MagiUnit, number>>;
+/** A.T. Field threat level */
+export type ATFieldLevel = 1 | 2 | 3 | 'MAX';
+/** Result of bias detection analysis */
+export interface BiasDetectionResult {
+    level: ATFieldLevel;
+    voteEntropy: number;
+    confidenceVariance: number;
+    jaccardDistance: number;
+    unanimousStreak: number;
+    biasWarning: boolean;
+    confidenceDiscount: number;
+    catfishAdvocate?: string;
+    deliberationId: string;
+}
+/** Types of milestones the chronicle can detect */
+export type MilestoneType = 'first_deliberation' | 'first_unanimous' | 'first_deadlock' | 'centenary' | 'millennium';
+/** A single entry in the chronicle */
+export interface ChronicleEntry {
+    number: number;
+    deliberationId: string;
+    taskType: string;
+    taskTitle: string;
+    decision: ConsensusDecision;
+    confidence: number;
+    units: string[];
+    milestone?: MilestoneType;
+    timestamp: string;
+}
+/** Encrypted cipher block stored on disk */
+export interface CipherBlock {
+    iv: string;
+    authTag: string;
+    encrypted: string;
+    salt?: string;
+    createdAt: string;
+}
+/** Cable connection status */
+export type CableStatus = 'connected' | 'degraded' | 'disconnected';
+/** State of a single unit's umbilical cable */
+export interface UmbilicalState {
+    unit: MagiUnit;
+    status: CableStatus;
+    recentResults: ('SUCCESS' | 'TIMEOUT' | 'CRASH')[];
+    disconnectedAt?: number;
+    batteryLimitMs: number;
+}
+/** A dummy plug generated opinion (extends MagiOpinion conceptually) */
+export interface DummyPlugOpinion extends MagiOpinion {
+    isDummyPlug: true;
+    sourceUnit: MagiUnit;
+    profileSamples: number;
+}
+/** Result of a recovery protocol brief */
+export interface RecoveryProtocolResult {
+    unit: MagiUnit;
+    missedRounds: number;
+    brief: string;
+    generatedAt: string;
+}
+/** Behavior profile for a unit (used by DummyPlug) */
+export interface UnitProfile {
+    voteDistribution: Record<Vote, number>;
+    averageConfidence: number;
+    frequentKeyPoints: string[];
+    domainProfiles: Record<string, {
+        voteDistribution: Record<Vote, number>;
+        averageConfidence: number;
+    }>;
+    sampleCount: number;
+}
+export interface SyncRateUpdatedEvent {
+    deliberationId: string;
+    rates: Record<MagiUnit, number>;
+    domain: string;
+    emittedAt: Date;
+}
+export interface BerserkWarningEvent {
+    deliberationId: string;
+    totalSyncRate: number;
+    threshold: number;
+    units: Record<MagiUnit, number>;
+    emittedAt: Date;
+}
+export interface BiasDetectedEvent {
+    deliberationId: string;
+    level: ATFieldLevel;
+    biasWarning: boolean;
+    confidenceDiscount: number;
+    voteEntropy: number;
+    emittedAt: Date;
+}
+export interface GospelMilestoneEvent {
+    deliberationId: string;
+    milestone: MilestoneType;
+    count: number;
+    emittedAt: Date;
+}
+export interface UmbilicalStatusChangedEvent {
+    unit: MagiUnit;
+    previousStatus: CableStatus;
+    newStatus: CableStatus;
+    emittedAt: Date;
+}
+export interface DummyPlugActivatedEvent {
+    deliberationId: string;
+    unit: MagiUnit;
+    confidence: number;
+    profileSamples: number;
+    emittedAt: Date;
+}
+export interface DummyPlugRecoveryEvent {
+    unit: MagiUnit;
+    missedRounds: number;
+    emittedAt: Date;
+}
+export interface CipherDiscoveredEvent {
+    deliberationId: string;
+    deliberationCount: number;
+    emittedAt: Date;
+}

package/dist/src/types/phase-h.js

@@ -0,0 +1,7 @@
+/**
+ * Phase H (Soul Plan) — Type definitions
+ *
+ * エヴァンゲリオンの世界観をMAGIシステムに技術的に組み込むための
+ * 全モジュール共通型定義。
+ */
+export {};

package/dist/src/types/phase-i.d.ts

@@ -0,0 +1,186 @@
+/**
+ * Phase I (ロマン基盤構築層) — Type definitions
+ *
+ * A-01 記憶・人格 / A-03 暴走モード / A-05 補完計画 / B-02 LCL
+ */
+import type { MagiUnit, MagiOpinion } from './core.js';
+import type { ConsensusDecision } from './consensus.js';
+/** A single episodic memory of a past deliberation */
+export interface EpisodicMemory {
+    deliberationId: string;
+    taskType: string;
+    taskTitle: string;
+    taskDescription: string;
+    decision: ConsensusDecision;
+    confidence: number;
+    keyPoints: string[];
+    units: MagiUnit[];
+    timestamp: string;
+}
+/** Compressed semantic pattern extracted from episodic memories */
+export interface SemanticPattern {
+    pattern: string;
+    frequency: number;
+    domains: string[];
+    confidence: number;
+    extractedAt: string;
+}
+/** Procedural strategy derived from successful deliberation patterns */
+export interface ProceduralStrategy {
+    taskType: string;
+    strategy: string;
+    successRate: number;
+    sampleCount: number;
+    lastUsed: string;
+}
+/** 12-dimensional behavior vector for drift detection */
+export interface BehaviorVector {
+    approveRate: number;
+    rejectRate: number;
+    abstainRate: number;
+    avgConfidence: number;
+    avgKeyPointCount: number;
+    avgReasoningLength: number;
+    agreementRate: number;
+    dissenterRate: number;
+    responseTimeNorm: number;
+    vocabularyDiversity: number;
+    sentimentPolarity: number;
+    detailLevel: number;
+}
+/** Personality profile for a MAGI unit */
+export interface UnitPersonalityProfile {
+    unit: MagiUnit;
+    vector: BehaviorVector;
+    sampleCount: number;
+    windowSize: number;
+    updatedAt: string;
+}
+/** Interface for pluggable similarity engines */
+export interface ISimilarityEngine {
+    computeSimilarity(query: string, documents: string[]): number[];
+}
+/** Strategy variant labels for BERSERK mode */
+export type BerserkStrategyLabel = 'alpha' | 'beta' | 'gamma' | 'delta' | 'epsilon';
+/** A single strategy definition */
+export interface BerserkStrategy {
+    label: BerserkStrategyLabel;
+    name: string;
+    promptPrefix: string;
+}
+/** A candidate opinion from BERSERK parallel execution */
+export interface BerserkCandidate {
+    unit: MagiUnit;
+    strategy: BerserkStrategyLabel;
+    opinion: MagiOpinion;
+    fitnessScore: number;
+}
+/** Result of a single BERSERK round */
+export interface BerserkRoundResult {
+    roundNumber: number;
+    candidates: BerserkCandidate[];
+    survivors: BerserkCandidate[];
+    consensusReached: boolean;
+    decision?: ConsensusDecision;
+}
+/** BERSERK orchestrator configuration */
+export interface BerserkConfig {
+    maxRounds: number;
+    concurrencyLimit: number;
+    survivorCount: number;
+}
+/** Weights for fusion of multiple opinions */
+export interface FusionWeights {
+    [unit: string]: number;
+}
+/** A fused opinion derived from multiple unit opinions */
+export interface FusedOpinion extends MagiOpinion {
+    isDerived: true;
+    fusionWeights: FusionWeights;
+    sourceOpinions: MagiUnit[];
+}
+/** Result of an Instrumentality fusion */
+export interface InstrumentalityResult {
+    fused: FusedOpinion;
+    triggerReason: string;
+    roundsBeforeFusion: number;
+    tokenCostEstimate: number;
+}
+/** LCL density level (0.0 = no sharing, 1.0 = full sharing) */
+export type LCLDensity = number;
+/** Phase-specific LCL density configuration */
+export interface LCLPhaseConfig {
+    'initial-opinion': LCLDensity;
+    'cross-examination': LCLDensity;
+    'final-vote': LCLDensity;
+}
+/** Types of hallucinations that can be detected */
+export type HallucinationType = 'fabricated-path' | 'abnormal-line-number' | 'vote-reasoning-mismatch' | 'fabricated-reference';
+/** A single hallucination detection report */
+export interface HallucinationReport {
+    type: HallucinationType;
+    description: string;
+    confidence: number;
+    location?: string;
+}
+/** Result of LCL contamination analysis */
+export interface LCLContaminationResult {
+    unit: MagiUnit;
+    reports: HallucinationReport[];
+    purified: boolean;
+    originalConfidence: number;
+    adjustedConfidence: number;
+}
+export interface MemoryDriftWarningEvent {
+    unit: MagiUnit;
+    asiScore: number;
+    threshold: number;
+    consecutiveCount: number;
+    emittedAt: Date;
+}
+export interface MemoryConsolidatedEvent {
+    episodicCount: number;
+    patternsExtracted: number;
+    strategiesUpdated: number;
+    emittedAt: Date;
+}
+export interface BerserkActivatedEvent {
+    deliberationId: string;
+    round: number;
+    candidateCount: number;
+    strategies: BerserkStrategyLabel[];
+    emittedAt: Date;
+}
+export interface BerserkDeactivatedEvent {
+    deliberationId: string;
+    totalRounds: number;
+    decision: ConsensusDecision;
+    emittedAt: Date;
+}
+export interface InstrumentalityTriggeredEvent {
+    deliberationId: string;
+    reason: string;
+    roundsBeforeFusion: number;
+    emittedAt: Date;
+}
+export interface FusionCompleteEvent {
+    deliberationId: string;
+    confidence: number;
+    weights: FusionWeights;
+    emittedAt: Date;
+}
+export interface LCLContaminationDetectedEvent {
+    deliberationId: string;
+    unit: MagiUnit;
+    hallucinationCount: number;
+    types: HallucinationType[];
+    emittedAt: Date;
+}
+export interface LCLPurifiedEvent {
+    deliberationId: string;
+    unit: MagiUnit;
+    removedCount: number;
+    originalConfidence: number;
+    adjustedConfidence: number;
+    emittedAt: Date;
+}

package/dist/src/types/phase-i.js

@@ -0,0 +1,6 @@
+/**
+ * Phase I (ロマン基盤構築層) — Type definitions
+ *
+ * A-01 記憶・人格 / A-03 暴走モード / A-05 補完計画 / B-02 LCL
+ */
+export {};