magi-ai 0.1.0

package/dist/src/engine/kernel/types.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Shared types for kernel modules.
+ *
+ * Defines the dependency contracts between kernel sub-modules
+ * (UnitExecutor, PhaseRunner, PostProcessor, DeliberationKernel).
+ */
+import type { MagiTask, MagiOpinion, DeliberationRound, DeliberationPhase, MagiDeliberation } from '../../types/core.js';
+import type { PipelineConfig, IPipeline } from '../../types/pipeline.js';
+import type { ICliAdapter } from '../../types/adapter.js';
+import type { AdapterRegistry } from '../../adapters/registry.js';
+import type { PipelineRegistry } from '../../pipelines/registry.js';
+import type { ConsensusEngine } from '../consensus.js';
+import type { ConsensusResult } from '../../types/consensus.js';
+import type { ContextManager } from '../../context/manager.js';
+import type { MagiEventBus } from '../events.js';
+import type { TokenTracker } from '../../metrics/token-tracker.js';
+import type { ObjectiveJudge, ObjectiveResult } from '../objective-judge.js';
+import type { LatencyTracker } from '../../utils/latency-tracker.js';
+import type { SyncRateTracker } from '../sync-rate.js';
+import type { ATField } from '../at-field.js';
+import type { GospelChronicle } from '../gospel.js';
+import type { UmbilicalCable } from '../umbilical-cable.js';
+import type { DummyPlugSystem } from '../dummy-plug.js';
+import type { OfflineMode } from '../offline-mode.js';
+import type { EngramManager } from '../engram-manager.js';
+import type { LCLManager } from '../lcl-manager.js';
+import type { InstrumentalityEngine } from '../instrumentality.js';
+import type { DriftDetector } from '../drift-detector.js';
+import type { Type666Firewall } from '../type666-firewall.js';
+import type { NebuchadnezzarKey } from '../nebuchadnezzar-key.js';
+import type { IruelBattleSystem } from '../iruel-battle.js';
+import type { DeliberationCache } from '../../cache/deliberation-cache.js';
+/** Optional modules injected into the kernel. */
+export interface OptionalModules {
+    tokenTracker?: TokenTracker;
+    objectiveJudge?: ObjectiveJudge;
+    syncRateTracker?: SyncRateTracker;
+    atField?: ATField;
+    gospel?: GospelChronicle;
+    umbilicalCable?: UmbilicalCable;
+    dummyPlug?: DummyPlugSystem;
+    offlineMode?: OfflineMode;
+    engramManager?: EngramManager;
+    lclManager?: LCLManager;
+    instrumentality?: InstrumentalityEngine;
+    driftDetector?: DriftDetector;
+    type666Firewall?: Type666Firewall;
+    nebuchadnezzarKey?: NebuchadnezzarKey;
+    iruelBattle?: IruelBattleSystem;
+    cache?: DeliberationCache;
+}
+/** Core dependencies shared across all kernel sub-modules. */
+export interface KernelDependencies {
+    adapters: AdapterRegistry;
+    pipelines: PipelineRegistry;
+    contextManager: ContextManager;
+    latencyTracker: LatencyTracker;
+    eventBus?: MagiEventBus;
+    modules: OptionalModules;
+    /** Allow CLIs to read project files during deliberation */
+    fileAccessEnabled?: boolean;
+}
+/** BERSERK strategy metadata for unit execution. */
+export interface BerserkStrategyParam {
+    name: string;
+    promptPrefix: string;
+}
+/** Parameters for a single unit execution. */
+export interface UnitExecutionParams {
+    deliberationId: string;
+    adapter: ICliAdapter;
+    task: MagiTask;
+    pipeline: IPipeline;
+    phase: DeliberationPhase;
+    previousRounds: DeliberationRound[];
+    config: PipelineConfig;
+    objectiveSummary?: string;
+    signal?: AbortSignal;
+    /** When set, prepends BERSERK strategy prefix to the system prompt. */
+    berserkStrategy?: BerserkStrategyParam;
+    /** Allow CLIs to read project files */
+    fileAccessEnabled?: boolean;
+}
+/** Parameters for running a phase. */
+export interface PhaseRunParams {
+    deliberationId: string;
+    task: MagiTask;
+    pipeline: IPipeline;
+    phase: DeliberationPhase;
+    previousRounds: DeliberationRound[];
+    config: PipelineConfig;
+    objectiveSummary?: string;
+    /** Allow CLIs to read project files */
+    fileAccessEnabled?: boolean;
+}
+/** Result context built during a deliberation. */
+export interface DeliberationContext {
+    id: string;
+    task: MagiTask;
+    config: PipelineConfig;
+    rounds: DeliberationRound[];
+    pendingIO: Promise<void>[];
+    startedAt: Date;
+    objectiveResult?: ObjectiveResult;
+    consensus?: ConsensusResult;
+}
+export type { MagiTask, MagiOpinion, DeliberationRound, DeliberationPhase, MagiDeliberation, PipelineConfig, IPipeline, ICliAdapter, ConsensusResult, ConsensusEngine, ObjectiveResult, MagiEventBus, ContextManager, LatencyTracker, TokenTracker, AdapterRegistry, PipelineRegistry, };

package/dist/src/engine/kernel/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/engine/kernel/unit-executor.d.ts

@@ -0,0 +1,6 @@
+import type { KernelDependencies, UnitExecutionParams, MagiOpinion } from './types.js';
+export declare class UnitExecutor {
+    private readonly deps;
+    constructor(deps: KernelDependencies);
+    execute(params: UnitExecutionParams): Promise<MagiOpinion>;
+}

package/dist/src/engine/kernel/unit-executor.js

@@ -0,0 +1,132 @@
+import { OPINION_JSON_SCHEMA } from '../../types/pipeline.js';
+import { buildPersonaPrompt } from '../../prompts/personas.js';
+import { buildUserPrompt } from '../../prompts/templates.js';
+import { logger } from '../../utils/logger.js';
+import { createAbstainOpinion } from '../../utils/abstain-factory.js';
+import { SafeOpinionSchema } from '../../parsers/opinion-schema.js';
+import { estimateTokens } from '../../metrics/token-tracker.js';
+export class UnitExecutor {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async execute(params) {
+        const { deliberationId, adapter, task, pipeline, phase, previousRounds, config, objectiveSummary, signal, berserkStrategy, } = params;
+        const { eventBus, latencyTracker } = this.deps;
+        const { tokenTracker } = this.deps.modules;
+        eventBus?.emit('unit:start', {
+            deliberationId,
+            unit: adapter.unit,
+            phase,
+            emittedAt: new Date(),
+        });
+        // Build persona prompt (each AI brings its own expertise naturally)
+        const basePrompt = buildPersonaPrompt(adapter.unit, phase);
+        const systemPrompt = berserkStrategy
+            ? `[BERSERK MODE: ${berserkStrategy.name}]\n${berserkStrategy.promptPrefix}\n\n${basePrompt}`
+            : basePrompt;
+        // For cross-examination, pass other units' opinions from the last round
+        const lastRound = previousRounds[previousRounds.length - 1];
+        const otherOpinions = lastRound?.opinions.filter((o) => o.unit !== adapter.unit);
+        const userPrompt = buildUserPrompt(task, adapter.unit, phase, previousRounds, otherOpinions, objectiveSummary);
+        // File access requires more time for CLIs to explore the codebase
+        const baseTimeout = latencyTracker.getTimeout(adapter.unit, config.adapterTimeoutMs);
+        const timeoutMs = params.fileAccessEnabled ? Math.min(baseTimeout * 2, 600_000) : baseTimeout;
+        const execStart = Date.now();
+        let response;
+        try {
+            response = await adapter.execute({
+                prompt: userPrompt,
+                systemPrompt: adapter.supportsSystemPrompt() ? systemPrompt : undefined,
+                jsonSchema: adapter.supportsStructuredOutput() ? OPINION_JSON_SCHEMA : undefined,
+                timeoutMs,
+                signal,
+                fileAccessEnabled: params.fileAccessEnabled,
+                cwd: params.fileAccessEnabled ? process.cwd() : undefined,
+                onStdoutChunk: (chunk) => {
+                    eventBus?.emit('unit:chunk', {
+                        deliberationId,
+                        unit: adapter.unit,
+                        chunk,
+                        stream: 'stdout',
+                        emittedAt: new Date(),
+                    });
+                },
+                onStderrChunk: (chunk) => {
+                    eventBus?.emit('unit:chunk', {
+                        deliberationId,
+                        unit: adapter.unit,
+                        chunk,
+                        stream: 'stderr',
+                        emittedAt: new Date(),
+                    });
+                },
+            });
+            latencyTracker.record(adapter.unit, Date.now() - execStart, true);
+        }
+        catch (err) {
+            latencyTracker.record(adapter.unit, Date.now() - execStart, false);
+            throw err;
+        }
+        // Track token usage (fire-and-forget)
+        if (tokenTracker) {
+            tokenTracker.addRecord({
+                deliberationId,
+                unit: adapter.unit,
+                phase,
+                estimatedInputTokens: estimateTokens(userPrompt),
+                estimatedOutputTokens: estimateTokens(response.raw),
+                timestamp: new Date(),
+            });
+        }
+        // Parse opinion from response
+        const partialOpinion = pipeline.parseOpinion(response.raw, response.structured, adapter.unit, phase);
+        // Validate opinion at trust boundary using SafeOpinionSchema
+        const safeResult = SafeOpinionSchema.safeParse({
+            vote: partialOpinion.vote,
+            confidence: partialOpinion.confidence,
+            reasoning: partialOpinion.reasoning,
+            keyPoints: partialOpinion.keyPoints,
+            suggestions: partialOpinion.suggestions,
+        });
+        if (safeResult.success) {
+            logger.audit('adapter.success', deliberationId, {
+                unit: adapter.unit,
+                phase,
+                vote: safeResult.data.vote,
+            });
+            eventBus?.emit('unit:complete', {
+                deliberationId,
+                unit: adapter.unit,
+                phase,
+                vote: safeResult.data.vote,
+                confidence: safeResult.data.confidence,
+                durationMs: Date.now() - execStart,
+                reasoningSummary: safeResult.data.reasoning.slice(0, 300),
+                emittedAt: new Date(),
+            });
+            return {
+                unit: partialOpinion.unit,
+                vote: safeResult.data.vote,
+                confidence: safeResult.data.confidence,
+                reasoning: safeResult.data.reasoning,
+                keyPoints: safeResult.data.keyPoints,
+                suggestions: safeResult.data.suggestions,
+                rawOutput: response.raw,
+                meta: response.meta,
+            };
+        }
+        // Validation failed -- demote to ABSTAIN
+        logger.warn(`${adapter.displayName} opinion failed safe validation, demoting to ABSTAIN`, {
+            unit: adapter.unit,
+            phase,
+            error: String(safeResult.error),
+        });
+        logger.audit('validation.failure', deliberationId, {
+            unit: adapter.unit,
+            phase,
+            error: String(safeResult.error),
+        });
+        return createAbstainOpinion(adapter.unit, `Opinion from ${adapter.displayName} failed safe validation: ${String(safeResult.error)}`, ['Opinion validation failed at trust boundary'], { rawOutput: response.raw, meta: response.meta });
+    }
+}

package/dist/src/engine/lcl-manager.d.ts

@@ -0,0 +1,44 @@
+/**
+ * LCLManager — Shared Consciousness Pool (共有意識プール)
+ *
+ * Controls how much context is shared between MAGI units at each
+ * deliberation phase. Uses LCL density (0.0-1.0) to determine the
+ * degree of information sharing, and integrates HallucinationDetector
+ * to purify contaminated opinions.
+ *
+ * Part of B-02 LCL.
+ */
+import type { MagiOpinion, DeliberationPhase } from '../types/core.js';
+import type { LCLPhaseConfig, LCLDensity, LCLContaminationResult } from '../types/phase-i.js';
+import type { MagiEventBus } from './events.js';
+export declare class LCLManager {
+    private readonly densities;
+    private readonly eventBus;
+    private readonly detector;
+    constructor(config?: Partial<LCLPhaseConfig>, eventBus?: MagiEventBus);
+    /**
+     * Generate shared context string from opinions based on current phase density.
+     *
+     * density 0.0 → empty string (no sharing, full independence)
+     * density 1.0 → full reasoning + all keyPoints
+     * 0 < density < 1 → proportional trimming
+     */
+    getSharedContext(phase: DeliberationPhase, opinions: MagiOpinion[]): string;
+    /**
+     * Analyze an opinion for hallucinations and purify if contaminated.
+     * Emits events via eventBus when hallucinations are found and purified.
+     */
+    purify(opinion: MagiOpinion, deliberationId?: string): LCLContaminationResult;
+    /**
+     * Dynamically adjust the density for a specific phase.
+     */
+    setDensity(phase: DeliberationPhase, density: LCLDensity): void;
+    /**
+     * Get the current density for a specific phase.
+     */
+    getDensity(phase: DeliberationPhase): LCLDensity;
+    /**
+     * Get all phase densities as a snapshot.
+     */
+    getDensities(): Readonly<LCLPhaseConfig>;
+}

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

@@ -0,0 +1,143 @@
+/**
+ * LCLManager — Shared Consciousness Pool (共有意識プール)
+ *
+ * Controls how much context is shared between MAGI units at each
+ * deliberation phase. Uses LCL density (0.0-1.0) to determine the
+ * degree of information sharing, and integrates HallucinationDetector
+ * to purify contaminated opinions.
+ *
+ * Part of B-02 LCL.
+ */
+import { HallucinationDetector } from './hallucination-detector.js';
+// ── Constants ────────────────────────────────────────────────────
+/** Default LCL density per deliberation phase */
+const DEFAULT_DENSITIES = {
+    'initial-opinion': 0.0,
+    'cross-examination': 0.7,
+    'final-vote': 0.4,
+};
+// ── LCLManager ───────────────────────────────────────────────────
+export class LCLManager {
+    densities;
+    eventBus;
+    detector;
+    constructor(config, eventBus) {
+        this.densities = {
+            ...DEFAULT_DENSITIES,
+            ...config,
+        };
+        this.eventBus = eventBus;
+        this.detector = new HallucinationDetector();
+    }
+    // ── Shared context generation ──────────────────────────────────
+    /**
+     * Generate shared context string from opinions based on current phase density.
+     *
+     * density 0.0 → empty string (no sharing, full independence)
+     * density 1.0 → full reasoning + all keyPoints
+     * 0 < density < 1 → proportional trimming
+     */
+    getSharedContext(phase, opinions) {
+        const density = this.densities[phase];
+        if (density <= 0 || opinions.length === 0) {
+            return '';
+        }
+        const sections = [];
+        for (const opinion of opinions) {
+            const parts = [];
+            // Include unit header
+            parts.push(`[${opinion.unit}] vote=${opinion.vote} confidence=${opinion.confidence}`);
+            // Include proportional keyPoints
+            if (opinion.keyPoints.length > 0) {
+                const count = Math.max(1, Math.round(opinion.keyPoints.length * density));
+                const selectedPoints = opinion.keyPoints.slice(0, count);
+                parts.push(`Key points: ${selectedPoints.join('; ')}`);
+            }
+            // Include truncated reasoning based on density
+            if (density >= 1.0) {
+                parts.push(`Reasoning: ${opinion.reasoning}`);
+            }
+            else if (density >= 0.3) {
+                const maxLen = Math.round(opinion.reasoning.length * density);
+                const truncated = opinion.reasoning.slice(0, maxLen);
+                if (truncated.length > 0) {
+                    parts.push(`Reasoning: ${truncated}...`);
+                }
+            }
+            // density < 0.3 → no reasoning shared (too noisy at low density)
+            sections.push(parts.join('\n'));
+        }
+        return sections.join('\n\n');
+    }
+    // ── Hallucination purification ─────────────────────────────────
+    /**
+     * Analyze an opinion for hallucinations and purify if contaminated.
+     * Emits events via eventBus when hallucinations are found and purified.
+     */
+    purify(opinion, deliberationId) {
+        const reports = this.detector.detect(opinion);
+        if (reports.length === 0) {
+            return {
+                unit: opinion.unit,
+                reports: [],
+                purified: false,
+                originalConfidence: opinion.confidence,
+                adjustedConfidence: opinion.confidence,
+            };
+        }
+        // Emit contamination detection event
+        if (this.eventBus && deliberationId) {
+            this.eventBus.emit('lcl:contamination-detected', {
+                deliberationId,
+                unit: opinion.unit,
+                hallucinationCount: reports.length,
+                types: [...new Set(reports.map(r => r.type))],
+                emittedAt: new Date(),
+            });
+        }
+        // Purify the opinion
+        const purifiedOpinion = this.detector.purify(opinion, reports);
+        const wasPurified = purifiedOpinion.confidence !== opinion.confidence ||
+            purifiedOpinion.reasoning !== opinion.reasoning;
+        // Emit purification event
+        if (wasPurified && this.eventBus && deliberationId) {
+            this.eventBus.emit('lcl:purified', {
+                deliberationId,
+                unit: opinion.unit,
+                removedCount: reports.filter(r => r.confidence >= 0.7).length,
+                originalConfidence: opinion.confidence,
+                adjustedConfidence: purifiedOpinion.confidence,
+                emittedAt: new Date(),
+            });
+        }
+        return {
+            unit: opinion.unit,
+            reports,
+            purified: wasPurified,
+            originalConfidence: opinion.confidence,
+            adjustedConfidence: purifiedOpinion.confidence,
+        };
+    }
+    // ── Density management ─────────────────────────────────────────
+    /**
+     * Dynamically adjust the density for a specific phase.
+     */
+    setDensity(phase, density) {
+        if (density < 0 || density > 1) {
+            throw new RangeError(`LCL density must be between 0.0 and 1.0, got ${density}`);
+        }
+        this.densities[phase] = density;
+    }
+    /**
+     * Get the current density for a specific phase.
+     */
+    getDensity(phase) {
+        return this.densities[phase];
+    }
+    /**
+     * Get all phase densities as a snapshot.
+     */
+    getDensities() {
+        return { ...this.densities };
+    }
+}

package/dist/src/engine/middleware/cache.d.ts

@@ -0,0 +1,7 @@
+import type { MiddlewareFn } from './types.js';
+import type { DeliberationCache } from '../../cache/deliberation-cache.js';
+/**
+ * Cache middleware -- checks cache before deliberation, stores result after.
+ * Only handles the GET (read) side. The cache SET remains in the orchestrator.
+ */
+export declare function createCacheMiddleware(cache: DeliberationCache): MiddlewareFn;

package/dist/src/engine/middleware/cache.js

@@ -0,0 +1,29 @@
+import { logger } from '../../utils/logger.js';
+/**
+ * Cache middleware -- checks cache before deliberation, stores result after.
+ * Only handles the GET (read) side. The cache SET remains in the orchestrator.
+ */
+export function createCacheMiddleware(cache) {
+    return async (ctx, next) => {
+        // Check cache
+        const cached = cache.get(ctx.task);
+        if (cached) {
+            logger.info('Cache hit for deliberation', { type: ctx.task.type, title: ctx.task.title });
+            logger.audit('deliberation.cache_hit', cached.id, { type: ctx.task.type, title: ctx.task.title });
+            ctx.eventBus?.emit('deliberation:complete', {
+                deliberationId: cached.id,
+                decision: cached.consensus.decision,
+                totalDurationMs: cached.totalDurationMs,
+                rounds: cached.rounds.length,
+                fromCache: true,
+                emittedAt: new Date(),
+            });
+            ctx.cachedResult = cached;
+            ctx.skipDeliberation = true;
+            // Don't call next() -- short-circuit
+            return;
+        }
+        // Pass through to deliberation
+        await next();
+    };
+}

package/dist/src/engine/middleware/chain.d.ts

@@ -0,0 +1,18 @@
+import type { MiddlewareContext, MiddlewareFn, MiddlewareErrorInfo } from './types.js';
+/**
+ * Koa-style middleware chain with error boundary.
+ * Each middleware receives context + next().
+ * Calling next() passes control to the next middleware in the stack.
+ * If a middleware throws, the error is captured and the chain continues.
+ */
+export declare class MiddlewareChain {
+    private readonly middlewares;
+    /** Errors captured during the last execute() call */
+    readonly errors: MiddlewareErrorInfo[];
+    /** Register a middleware function */
+    use(mw: MiddlewareFn): this;
+    /** Execute the middleware chain */
+    execute(ctx: MiddlewareContext): Promise<void>;
+    /** Number of registered middlewares */
+    get length(): number;
+}

package/dist/src/engine/middleware/chain.js

@@ -0,0 +1,45 @@
+import { logger } from '../../utils/logger.js';
+/**
+ * Koa-style middleware chain with error boundary.
+ * Each middleware receives context + next().
+ * Calling next() passes control to the next middleware in the stack.
+ * If a middleware throws, the error is captured and the chain continues.
+ */
+export class MiddlewareChain {
+    middlewares = [];
+    /** Errors captured during the last execute() call */
+    errors = [];
+    /** Register a middleware function */
+    use(mw) {
+        this.middlewares.push(mw);
+        return this;
+    }
+    /** Execute the middleware chain */
+    async execute(ctx) {
+        this.errors.length = 0;
+        let index = 0;
+        const next = async () => {
+            if (index < this.middlewares.length) {
+                const currentIndex = index;
+                const mw = this.middlewares[index++];
+                try {
+                    await mw(ctx, next);
+                }
+                catch (err) {
+                    const error = err instanceof Error ? err : new Error(String(err));
+                    this.errors.push({ middlewareIndex: currentIndex, error });
+                    // If middleware set blocked before throwing, respect the block
+                    if (ctx.blocked)
+                        return;
+                    logger.warn(`Middleware[${currentIndex}] error (continuing chain): ${error.message}`);
+                    await next();
+                }
+            }
+        };
+        await next();
+    }
+    /** Number of registered middlewares */
+    get length() {
+        return this.middlewares.length;
+    }
+}

package/dist/src/engine/middleware/firewall.d.ts

@@ -0,0 +1,8 @@
+import type { MiddlewareFn } from './types.js';
+import type { Type666Firewall } from '../type666-firewall.js';
+/**
+ * Firewall middleware -- scans task input before deliberation.
+ * Only handles the pre-scan. The post-deliberation learnFromDeliberation
+ * call remains in the orchestrator.
+ */
+export declare function createFirewallMiddleware(firewall: Type666Firewall): MiddlewareFn;

package/dist/src/engine/middleware/firewall.js

@@ -0,0 +1,24 @@
+import { logger } from '../../utils/logger.js';
+/**
+ * Firewall middleware -- scans task input before deliberation.
+ * Only handles the pre-scan. The post-deliberation learnFromDeliberation
+ * call remains in the orchestrator.
+ */
+export function createFirewallMiddleware(firewall) {
+    return async (ctx, next) => {
+        const scanResult = firewall.scan(ctx.task.description);
+        if (!scanResult.passed) {
+            logger.warn('Type-666 Firewall blocked deliberation input', {
+                threats: scanResult.threats.length, totalScore: scanResult.totalScore,
+            });
+            logger.audit('firewall.blocked', ctx.deliberationId, {
+                threats: scanResult.threats.length, totalScore: scanResult.totalScore,
+            });
+            ctx.blocked = true;
+            ctx.blockedReason = `Type-666 Firewall blocked: ${scanResult.threats.length} threats detected (score: ${scanResult.totalScore.toFixed(2)})`;
+            return; // Don't call next() -- short-circuit (same pattern as cache)
+        }
+        logger.audit('firewall.scan', ctx.deliberationId, { passed: true, totalScore: scanResult.totalScore });
+        await next();
+    };
+}

package/dist/src/engine/middleware/index.d.ts

@@ -0,0 +1,4 @@
+export { MiddlewareChain } from './chain.js';
+export type { MiddlewareContext, MiddlewareFn, MiddlewareErrorInfo } from './types.js';
+export { createCacheMiddleware } from './cache.js';
+export { createFirewallMiddleware } from './firewall.js';

package/dist/src/engine/middleware/index.js

@@ -0,0 +1,3 @@
+export { MiddlewareChain } from './chain.js';
+export { createCacheMiddleware } from './cache.js';
+export { createFirewallMiddleware } from './firewall.js';

package/dist/src/engine/middleware/types.d.ts

@@ -0,0 +1,43 @@
+import type { MagiTask, MagiDeliberation } from '../../types/core.js';
+import type { PipelineConfig } from '../../types/pipeline.js';
+import type { MagiEventBus } from '../events.js';
+/**
+ * Context object passed through the middleware chain.
+ * Middleware can read and modify the context to affect deliberation behavior.
+ */
+export interface MiddlewareContext {
+    /** Unique deliberation ID */
+    deliberationId: string;
+    /** The task being deliberated */
+    task: MagiTask;
+    /** Pipeline configuration (mutable by middleware) */
+    config: PipelineConfig;
+    /** Optional event bus */
+    eventBus?: MagiEventBus;
+    /** Shared metadata bag for cross-middleware communication */
+    metadata: Map<string, unknown>;
+    /** Set by CacheMiddleware if a cached result is found */
+    cachedResult?: MagiDeliberation;
+    /** Set to true to skip remaining middleware and return cachedResult */
+    skipDeliberation?: boolean;
+    /** Set by firewall middleware when input is blocked */
+    blocked?: boolean;
+    /** Reason for blocking (set alongside blocked) */
+    blockedReason?: string;
+}
+/**
+ * Middleware function -- Koa-style with next() for chaining.
+ * Call next() to pass control to the next middleware.
+ * Not calling next() short-circuits the chain.
+ */
+export type MiddlewareFn = (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+/**
+ * Error information captured when a middleware throws.
+ * The chain continues execution despite the error.
+ */
+export interface MiddlewareErrorInfo {
+    /** Index of the middleware that threw */
+    middlewareIndex: number;
+    /** The captured error */
+    error: Error;
+}

package/dist/src/engine/middleware/types.js

@@ -0,0 +1 @@
+export {};