@mulep/core 0.2.14

package/dist/index.d.ts

@@ -0,0 +1,2902 @@
+import { z } from 'zod';
+import { Ignore } from 'ignore';
+import Database from 'better-sqlite3';
+import { EventEmitter } from 'eventemitter3';
+
+type ModelProvider = 'openai';
+interface CliAdapterConfig {
+    command: string;
+    args: string[];
+    timeout: number;
+    outputFile?: string;
+    maxOutputBytes?: number;
+    envAllowlist?: string[];
+}
+interface ModelConfig {
+    provider: ModelProvider;
+    model: string;
+    maxTokens: number;
+    temperature: number;
+    timeout: number;
+    cliAdapter?: CliAdapterConfig;
+}
+interface RoleConfig {
+    model: string;
+    temperature?: number;
+    maxTokens?: number;
+    systemPromptFile?: string;
+}
+interface DebateConfig {
+    defaultPattern: DebatePattern;
+    maxRounds: number;
+    consensusThreshold: number;
+}
+type DebatePattern = 'structured-rounds' | 'proposal-critique' | 'free-flowing' | 'parallel-panel';
+interface MemoryConfig {
+    embeddingModel?: string;
+    autoExtractFacts: boolean;
+    contextBudget: {
+        activeContext: number;
+        retrievedMemory: number;
+        messageBuffer: number;
+    };
+}
+interface BudgetConfig {
+    perSession: number;
+    perDay: number;
+    perMonth: number;
+    warningAt: number;
+    action: 'warn' | 'pause' | 'block';
+}
+interface OutputConfig {
+    saveTranscripts: boolean;
+    transcriptFormat: 'markdown' | 'json';
+    transcriptDir: string;
+}
+interface ProjectConfig {
+    configVersion?: number;
+    project: {
+        name: string;
+        description: string;
+    };
+    models: Record<string, ModelConfig>;
+    roles: Record<string, RoleConfig>;
+    workflow: string;
+    mode: ExecutionMode;
+    debate: DebateConfig;
+    memory: MemoryConfig;
+    budget: BudgetConfig;
+    output: OutputConfig;
+    advanced: {
+        retryAttempts: number;
+        stream: boolean;
+        logLevel: 'debug' | 'info' | 'warn' | 'error';
+    };
+}
+type ExecutionMode = 'autonomous' | 'interactive' | 'dashboard';
+type PresetName = 'cli-first';
+
+declare enum ErrorCode {
+    INVALID_INPUT = "INVALID_INPUT",
+    MODEL_UNAVAILABLE = "MODEL_UNAVAILABLE",
+    RATE_LIMITED = "RATE_LIMITED",
+    TIMEOUT = "TIMEOUT",
+    DLP_BLOCKED = "DLP_BLOCKED",
+    EGRESS_BLOCKED = "EGRESS_BLOCKED",
+    BUDGET_EXCEEDED = "BUDGET_EXCEEDED",
+    CLI_NOT_FOUND = "CLI_NOT_FOUND",
+    CLI_AUTH_FAILED = "CLI_AUTH_FAILED",
+    CANCELLED = "CANCELLED",
+    INTERNAL_ERROR = "INTERNAL_ERROR"
+}
+declare enum TerminalReason {
+    COMPLETED = "COMPLETED",
+    TIMEOUT = "TIMEOUT",
+    CANCELLED = "CANCELLED",
+    BUDGET_EXCEEDED = "BUDGET_EXCEEDED",
+    MAX_RETRIES = "MAX_RETRIES"
+}
+type ResultStatus = 'success' | 'partial' | 'error';
+declare enum DlpReasonCode {
+    SECRET_DETECTED = "SECRET_DETECTED",
+    HIGH_ENTROPY = "HIGH_ENTROPY",
+    ABSOLUTE_PATH = "ABSOLUTE_PATH",
+    CONTEXT_TRUNCATED = "CONTEXT_TRUNCATED",
+    DECODE_BLOCKED = "DECODE_BLOCKED",
+    BUDGET_EXCEEDED = "BUDGET_EXCEEDED"
+}
+type MeteringSource = 'billed' | 'estimated' | 'sdk';
+interface ReviewResult {
+    status: ResultStatus;
+    score: number;
+    verdict: 'approved' | 'needs_revision';
+    feedback: string[];
+    tokenUsage: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+        costUsd: number;
+    };
+    latencyMs: number;
+    meteringSource: MeteringSource;
+    model: string;
+    egressControl: 'mulep-enforced' | 'cli-managed';
+}
+interface DebateResponse {
+    model: string;
+    role: string;
+    text: string;
+    tokenUsage: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+        costUsd: number;
+    };
+    latencyMs: number;
+    meteringSource: MeteringSource;
+    error?: string;
+}
+interface DebateResult {
+    status: ResultStatus;
+    responses: DebateResponse[];
+    synthesis?: string;
+    agreement?: number;
+    totalTokenUsage: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+        costUsd: number;
+    };
+    partialFailure?: boolean;
+    egressControl: 'mulep-enforced' | 'cli-managed';
+}
+declare const reviewInputSchema: z.ZodObject<{
+    content: z.ZodString;
+    criteria: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    model: z.ZodOptional<z.ZodString>;
+    strict: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    strict: boolean;
+    timeout: number;
+    criteria?: string[] | undefined;
+    model?: string | undefined;
+}, {
+    content: string;
+    criteria?: string[] | undefined;
+    model?: string | undefined;
+    strict?: boolean | undefined;
+    timeout?: number | undefined;
+}>;
+type ReviewInput = z.infer<typeof reviewInputSchema>;
+declare const planInputSchema: z.ZodObject<{
+    task: z.ZodString;
+    maxRounds: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    stream: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    timeout: number;
+    task: string;
+    maxRounds: number;
+    stream: boolean;
+}, {
+    task: string;
+    timeout?: number | undefined;
+    maxRounds?: number | undefined;
+    stream?: boolean | undefined;
+}>;
+type PlanInput = z.infer<typeof planInputSchema>;
+declare const debateInputSchema: z.ZodObject<{
+    question: z.ZodString;
+    models: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    synthesize: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    maxRounds: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    timeout: number;
+    maxRounds: number;
+    question: string;
+    synthesize: boolean;
+    models?: string[] | undefined;
+}, {
+    question: string;
+    timeout?: number | undefined;
+    maxRounds?: number | undefined;
+    models?: string[] | undefined;
+    synthesize?: boolean | undefined;
+}>;
+type DebateInput = z.infer<typeof debateInputSchema>;
+declare const memoryInputSchema: z.ZodObject<{
+    action: z.ZodEnum<["save", "search", "get", "delete"]>;
+    content: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodString>;
+    memoryId: z.ZodOptional<z.ZodNumber>;
+    category: z.ZodOptional<z.ZodEnum<["decision", "convention", "pattern", "issue", "preference"]>>;
+    importance: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    timeout: number;
+    action: "save" | "search" | "get" | "delete";
+    importance: number;
+    content?: string | undefined;
+    query?: string | undefined;
+    memoryId?: number | undefined;
+    category?: "decision" | "convention" | "pattern" | "issue" | "preference" | undefined;
+}, {
+    action: "save" | "search" | "get" | "delete";
+    content?: string | undefined;
+    timeout?: number | undefined;
+    query?: string | undefined;
+    memoryId?: number | undefined;
+    category?: "decision" | "convention" | "pattern" | "issue" | "preference" | undefined;
+    importance?: number | undefined;
+}>;
+type MemoryInput = z.infer<typeof memoryInputSchema>;
+declare const costInputSchema: z.ZodObject<{
+    scope: z.ZodDefault<z.ZodOptional<z.ZodEnum<["session", "daily", "all"]>>>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    days: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    timeout: number;
+    scope: "session" | "daily" | "all";
+    days: number;
+    sessionId?: string | undefined;
+}, {
+    timeout?: number | undefined;
+    scope?: "session" | "daily" | "all" | undefined;
+    sessionId?: string | undefined;
+    days?: number | undefined;
+}>;
+type CostInput = z.infer<typeof costInputSchema>;
+declare const reviewOutputSchema: z.ZodObject<{
+    status: z.ZodEnum<["success", "partial", "error"]>;
+    score: z.ZodNumber;
+    verdict: z.ZodEnum<["approved", "needs_revision"]>;
+    feedback: z.ZodArray<z.ZodString, "many">;
+    tokenUsage: z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        totalTokens: z.ZodNumber;
+        costUsd: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+        costUsd: number;
+    }, {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+        costUsd: number;
+    }>;
+    latencyMs: z.ZodNumber;
+    meteringSource: z.ZodEnum<["billed", "estimated", "sdk"]>;
+    model: z.ZodString;
+    egressControl: z.ZodEnum<["mulep-enforced", "cli-managed"]>;
+}, "strip", z.ZodTypeAny, {
+    status: "error" | "success" | "partial";
+    model: string;
+    score: number;
+    verdict: "approved" | "needs_revision";
+    feedback: string[];
+    tokenUsage: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+        costUsd: number;
+    };
+    latencyMs: number;
+    meteringSource: "billed" | "estimated" | "sdk";
+    egressControl: "mulep-enforced" | "cli-managed";
+}, {
+    status: "error" | "success" | "partial";
+    model: string;
+    score: number;
+    verdict: "approved" | "needs_revision";
+    feedback: string[];
+    tokenUsage: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+        costUsd: number;
+    };
+    latencyMs: number;
+    meteringSource: "billed" | "estimated" | "sdk";
+    egressControl: "mulep-enforced" | "cli-managed";
+}>;
+declare const debateOutputSchema: z.ZodObject<{
+    status: z.ZodEnum<["success", "partial", "error"]>;
+    responses: z.ZodArray<z.ZodObject<{
+        model: z.ZodString;
+        role: z.ZodString;
+        text: z.ZodString;
+        tokenUsage: z.ZodObject<{
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            totalTokens: z.ZodNumber;
+            costUsd: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+            costUsd: number;
+        }, {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+            costUsd: number;
+        }>;
+        latencyMs: z.ZodNumber;
+        meteringSource: z.ZodEnum<["billed", "estimated", "sdk"]>;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        model: string;
+        tokenUsage: {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+            costUsd: number;
+        };
+        latencyMs: number;
+        meteringSource: "billed" | "estimated" | "sdk";
+        role: string;
+        text: string;
+        error?: string | undefined;
+    }, {
+        model: string;
+        tokenUsage: {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+            costUsd: number;
+        };
+        latencyMs: number;
+        meteringSource: "billed" | "estimated" | "sdk";
+        role: string;
+        text: string;
+        error?: string | undefined;
+    }>, "many">;
+    synthesis: z.ZodOptional<z.ZodString>;
+    agreement: z.ZodOptional<z.ZodNumber>;
+    totalTokenUsage: z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        totalTokens: z.ZodNumber;
+        costUsd: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+        costUsd: number;
+    }, {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+        costUsd: number;
+    }>;
+    partialFailure: z.ZodOptional<z.ZodBoolean>;
+    egressControl: z.ZodEnum<["mulep-enforced", "cli-managed"]>;
+}, "strip", z.ZodTypeAny, {
+    status: "error" | "success" | "partial";
+    egressControl: "mulep-enforced" | "cli-managed";
+    responses: {
+        model: string;
+        tokenUsage: {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+            costUsd: number;
+        };
+        latencyMs: number;
+        meteringSource: "billed" | "estimated" | "sdk";
+        role: string;
+        text: string;
+        error?: string | undefined;
+    }[];
+    totalTokenUsage: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+        costUsd: number;
+    };
+    synthesis?: string | undefined;
+    agreement?: number | undefined;
+    partialFailure?: boolean | undefined;
+}, {
+    status: "error" | "success" | "partial";
+    egressControl: "mulep-enforced" | "cli-managed";
+    responses: {
+        model: string;
+        tokenUsage: {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+            costUsd: number;
+        };
+        latencyMs: number;
+        meteringSource: "billed" | "estimated" | "sdk";
+        role: string;
+        text: string;
+        error?: string | undefined;
+    }[];
+    totalTokenUsage: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+        costUsd: number;
+    };
+    synthesis?: string | undefined;
+    agreement?: number | undefined;
+    partialFailure?: boolean | undefined;
+}>;
+
+/**
+ * A workflow is a DAG of steps loaded from YAML.
+ * Sprint 1 supports: generate, review. Other types are parsed but not executed.
+ */
+interface WorkflowDefinition {
+    name: string;
+    description?: string;
+    steps: StepDefinition[];
+}
+interface StepDefinition {
+    id: string;
+    type: StepType;
+    role: string;
+    input?: string[];
+    output?: string;
+    loop?: LoopConfig;
+    steps?: StepDefinition[];
+    command?: string;
+    gateMode?: 'always' | 'conditional';
+}
+type StepType = 'generate' | 'review' | 'debate' | 'transform' | 'gate' | 'parallel' | 'conditional';
+interface LoopConfig {
+    maxIterations: number;
+    exitWhen: string;
+    iteratesWith: string;
+}
+/**
+ * Validated workflow: steps resolved into execution order.
+ * The engine works with this, not the raw definition.
+ */
+interface ResolvedWorkflow {
+    name: string;
+    executionOrder: ResolvedStep[];
+}
+interface ResolvedStep {
+    definition: StepDefinition;
+    inputStepIds: string[];
+    isLoopEntry: boolean;
+    loopPartnerStepId?: string;
+}
+
+/**
+ * AG-UI compatible event types.
+ * Emitted by the core engine and consumed by CLI / Web.
+ * Type names follow AG-UI convention (dot-separated).
+ */
+interface SessionStartedEvent {
+    type: 'session.started';
+    sessionId: string;
+    workflow: string;
+    task: string;
+    timestamp: string;
+}
+interface SessionCompletedEvent {
+    type: 'session.completed';
+    sessionId: string;
+    finalOutput: string;
+    totalCost: number;
+    totalTokens: number;
+    durationMs: number;
+    timestamp: string;
+}
+interface SessionFailedEvent {
+    type: 'session.failed';
+    sessionId: string;
+    error: string;
+    lastStep: string;
+    timestamp: string;
+}
+interface StepStartedEvent {
+    type: 'step.started';
+    stepId: string;
+    role: string;
+    model: string;
+    iteration: number;
+    timestamp: string;
+}
+interface StepCompletedEvent {
+    type: 'step.completed';
+    stepId: string;
+    output: string;
+    tokenUsage: TokenUsage;
+    durationMs: number;
+    timestamp: string;
+}
+interface StepFailedEvent {
+    type: 'step.failed';
+    stepId: string;
+    error: string;
+    retriesExhausted: boolean;
+    timestamp: string;
+}
+interface TextDeltaEvent {
+    type: 'text.delta';
+    stepId: string;
+    role: string;
+    delta: string;
+}
+interface TextDoneEvent {
+    type: 'text.done';
+    stepId: string;
+    role: string;
+    fullText: string;
+}
+interface LoopIterationEvent {
+    type: 'loop.iteration';
+    stepId: string;
+    iteration: number;
+    maxIterations: number;
+    verdict: 'approved' | 'needs_revision';
+    feedback?: string;
+    timestamp: string;
+}
+interface CostUpdateEvent {
+    type: 'cost.update';
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    costUsd: number;
+    cumulativeSessionCost: number;
+    timestamp: string;
+}
+interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    costUsd: number;
+}
+type EngineEvent = SessionStartedEvent | SessionCompletedEvent | SessionFailedEvent | StepStartedEvent | StepCompletedEvent | StepFailedEvent | TextDeltaEvent | TextDoneEvent | LoopIterationEvent | CostUpdateEvent;
+
+type SessionStatus = 'running' | 'paused' | 'completed' | 'failed' | 'cancelled';
+interface Session {
+    id: string;
+    projectId: string;
+    workflowId: string;
+    task: string;
+    status: SessionStatus;
+    mode: ExecutionMode;
+    currentStep: string | null;
+    configSnapshot: string;
+    startedAt: string;
+    updatedAt: string;
+    completedAt: string | null;
+    summary: string | null;
+    totalCost: number;
+    totalTokens: number;
+    metadata: Record<string, unknown>;
+}
+interface TranscriptEntry {
+    id?: number;
+    sessionId: string;
+    stepId: string;
+    iteration: number | null;
+    role: string;
+    modelId: string | null;
+    content: string;
+    tokenCount: number | null;
+    cost: number | null;
+    createdAt: string;
+    metadata: Record<string, unknown> | null;
+}
+
+type MemoryCategory = 'decision' | 'convention' | 'pattern' | 'issue' | 'preference';
+interface MemoryRecord {
+    id?: number;
+    projectId: string;
+    category: MemoryCategory;
+    content: string;
+    sourceSessionId: string | null;
+    importance: number;
+    createdAt: string;
+    accessedAt: string;
+    accessCount: number;
+}
+type ArtifactType = 'plan' | 'code' | 'review' | 'test';
+interface ArtifactRecord {
+    id?: number;
+    sessionId: string;
+    stepId: string;
+    iteration: number;
+    type: ArtifactType;
+    filePath: string | null;
+    content: string;
+    version: number;
+    createdAt: string;
+    metadata: Record<string, unknown> | null;
+}
+interface CostLogEntry {
+    id?: number;
+    sessionId: string;
+    stepId: string | null;
+    modelId: string;
+    inputTokens: number;
+    outputTokens: number;
+    costUsd: number;
+    latencyMs: number;
+    createdAt: string;
+}
+
+/**
+ * Chat message format. Aligns with Vercel AI SDK's CoreMessage.
+ */
+interface ChatMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+interface CallModelOptions {
+    maxTokens?: number;
+    temperature?: number;
+    systemPrompt?: string;
+    /** Timeout in seconds for CLI subprocess calls. Default: 120. */
+    timeout?: number;
+}
+interface ModelCallResult {
+    text: string;
+    model: string;
+    provider: ModelProvider;
+    usage: TokenUsage;
+    finishReason: string;
+    durationMs: number;
+    meteringSource?: MeteringSource;
+    /** Codex thread ID for session resume. */
+    sessionId?: string;
+}
+interface FallbackConfig {
+    primary: string;
+    fallbacks: string[];
+    maxRetries: number;
+    retryOn: {
+        rateLimit: boolean;
+        timeout: boolean;
+        serverError: boolean;
+    };
+}
+
+type BuiltInRole = 'architect' | 'reviewer' | 'implementer';
+interface Role {
+    id: string;
+    description: string;
+    modelAlias: string;
+    systemPrompt: string;
+    temperature: number;
+    maxTokens: number;
+}
+
+type BuildStatus = 'planning' | 'implementing' | 'reviewing' | 'fixing' | 'completed' | 'failed' | 'paused';
+type BuildPhase = 'debate' | 'plan_approved' | 'implementing' | 'review' | 'fix' | 'done';
+type BuildEventType = 'debate_started' | 'debate_converged' | 'plan_approved' | 'impl_started' | 'impl_completed' | 'review_requested' | 'review_verdict' | 'bug_found' | 'fix_started' | 'fix_completed' | 'phase_transition' | 'error' | 'resumed' | 'scan_completed' | 'merge_completed' | 'adjudicated';
+type BuildActor = 'claude' | 'codex' | 'system';
+interface BuildRun {
+    id: number;
+    buildId: string;
+    task: string;
+    status: BuildStatus;
+    currentPhase: BuildPhase;
+    currentLoop: number;
+    lastEventSeq: number;
+    phaseCursor: PhaseCursor;
+    debateId: string | null;
+    baselineRef: string | null;
+    planCodexSession: string | null;
+    reviewCodexSession: string | null;
+    planVersion: number;
+    reviewCycles: number;
+    createdAt: number;
+    updatedAt: number;
+    completedAt: number | null;
+    metadata: Record<string, unknown> | null;
+}
+interface PhaseCursor {
+    phase: BuildPhase;
+    loop: number;
+    actor: BuildActor;
+    attempt: number;
+    lastEventId: number;
+    baselineRef?: string;
+}
+interface BuildEvent {
+    id: number;
+    buildId: string;
+    seq: number;
+    eventType: BuildEventType;
+    actor: BuildActor;
+    phase: BuildPhase;
+    loopIndex: number;
+    payload: Record<string, unknown> | null;
+    codexThreadId: string | null;
+    tokensUsed: number;
+    createdAt: number;
+}
+interface BuildSummary {
+    buildId: string;
+    task: string;
+    status: BuildStatus;
+    phase: BuildPhase;
+    loop: number;
+    reviewCycles: number;
+    planVersion: number;
+    debateId: string | null;
+    baselineRef: string | null;
+    createdAt: number;
+    updatedAt: number;
+}
+
+type CleanupScope = 'deps' | 'unused-exports' | 'hardcoded' | 'duplicates' | 'deadcode' | 'security' | 'near-duplicates' | 'anti-patterns';
+type CleanupConfidence = 'high' | 'medium' | 'low';
+/** Which analysis sources identified this finding */
+type CleanupSource = 'deterministic' | 'semantic' | 'host';
+interface CleanupFinding {
+    /** Canonical key for merge matching: scope:normalizedPath:symbol */
+    key: string;
+    scope: CleanupScope;
+    confidence: CleanupConfidence;
+    file: string;
+    line?: number;
+    description: string;
+    recommendation: string;
+    /** Evidence from deterministic scanner */
+    deterministicEvidence: string[];
+    /** Evidence from semantic (codex) scanner */
+    semanticEvidence: string[];
+    /** Evidence from host AI (Claude) scanner */
+    hostEvidence: string[];
+    /** Which sources identified this finding */
+    sources: CleanupSource[];
+    /** Whether this finding was disputed between scanners */
+    disputed: boolean;
+    /** Group key for duplicate findings (sorted file:line pairs) */
+    groupKey?: string;
+    /** Package name for monorepo context */
+    packageName?: string;
+}
+interface CleanupReport {
+    scopes: CleanupScope[];
+    findings: CleanupFinding[];
+    stats: {
+        deterministic: number;
+        semantic: number;
+        host: number;
+        agreed: number;
+        disputed: number;
+        adjudicated: number;
+        highConfidence: number;
+        mediumConfidence: number;
+        lowConfidence: number;
+    };
+    durationMs: number;
+}
+
+type DebateId = string;
+type MessageId = string;
+/** Stance a debater takes relative to the current proposal. */
+type Stance = 'support' | 'oppose' | 'uncertain';
+/** Message types in a debate thread. */
+type DebateMessageKind = 'topic' | 'proposal' | 'critique' | 'rebuttal' | 'summary' | 'verdict';
+/** A single message in the debate thread. */
+interface DebateMessage {
+    id: MessageId;
+    turn: number;
+    round: number;
+    speakerId: string;
+    kind: DebateMessageKind;
+    text: string;
+    replyTo?: MessageId;
+    stance?: Stance;
+    confidence?: number;
+    tokens?: {
+        prompt: number;
+        completion: number;
+    };
+    createdAt: number;
+}
+/** Mutable state of an ongoing debate. */
+interface DebateEngineState {
+    debateId: DebateId;
+    question: string;
+    models: string[];
+    round: number;
+    turn: number;
+    thread: DebateMessage[];
+    runningSummary: string;
+    stanceHistory: Array<{
+        round: number;
+        speakerId: string;
+        stance: Stance;
+    }>;
+    usage: {
+        totalPromptTokens: number;
+        totalCompletionTokens: number;
+        totalCalls: number;
+        startedAt: number;
+    };
+    status: 'running' | 'stopped';
+    /** Codex session IDs per speaker for resume. */
+    sessionIds: Record<string, string>;
+    /** Resume telemetry. */
+    resumeStats: {
+        attempted: number;
+        succeeded: number;
+        fallbacks: number;
+    };
+}
+/** Why the debate stopped. */
+type StopReason = 'converged' | 'max_rounds' | 'time_budget' | 'error';
+/** Final result of a debate. */
+interface DebateEngineResult {
+    debateId: DebateId;
+    answer: string;
+    reason: StopReason;
+    rounds: number;
+    thread: DebateMessage[];
+    stanceHistory: DebateEngineState['stanceHistory'];
+    usage: DebateEngineState['usage'];
+}
+
+type JobType = 'review' | 'cleanup' | 'build-review' | 'composite' | 'watch-review';
+type JobStatus = 'queued' | 'running' | 'succeeded' | 'failed' | 'canceled';
+interface JobRecord {
+    id: string;
+    type: JobType;
+    status: JobStatus;
+    priority: number;
+    dedupeKey: string | null;
+    payloadJson: string;
+    resultJson: string | null;
+    errorText: string | null;
+    retryCount: number;
+    maxRetries: number;
+    sessionId: string | null;
+    workerId: string | null;
+    startedAt: number | null;
+    finishedAt: number | null;
+    createdAt: number;
+    updatedAt: number;
+}
+interface JobLogRecord {
+    id: number;
+    jobId: string;
+    seq: number;
+    level: 'debug' | 'info' | 'warn' | 'error';
+    eventType: string;
+    message: string | null;
+    payloadJson: string | null;
+    createdAt: number;
+}
+interface EnqueueOptions {
+    type: JobType;
+    payload: Record<string, unknown>;
+    priority?: number;
+    dedupeKey?: string;
+    sessionId?: string;
+    maxRetries?: number;
+}
+
+/** Generate a session ID with "ses_" prefix. */
+declare function generateSessionId(): string;
+/** Generate a generic unique ID. */
+declare function generateId(prefix?: string): string;
+
+declare class ConfigError extends Error {
+    readonly field?: string | undefined;
+    constructor(message: string, field?: string | undefined);
+}
+declare class ModelError extends Error {
+    readonly provider?: string | undefined;
+    readonly model?: string | undefined;
+    readonly statusCode?: number | undefined;
+    constructor(message: string, provider?: string | undefined, model?: string | undefined, statusCode?: number | undefined);
+    get isRateLimit(): boolean;
+    get isTimeout(): boolean;
+    get isServerError(): boolean;
+}
+declare class WorkflowError extends Error {
+    readonly stepId?: string | undefined;
+    constructor(message: string, stepId?: string | undefined);
+}
+declare class DatabaseError extends Error {
+    readonly operation?: string | undefined;
+    constructor(message: string, operation?: string | undefined);
+}
+
+interface RetryOptions {
+    attempts: number;
+    backoff: number;
+    retryOn?: (error: unknown) => boolean;
+}
+/**
+ * Retry an async function with exponential backoff.
+ * Returns the result on success, throws the last error after all attempts exhausted.
+ */
+declare function withRetry<T>(fn: () => Promise<T>, options?: Partial<RetryOptions>): Promise<T>;
+
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface Logger {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+declare function createLogger(level?: LogLevel): Logger;
+
+interface VerdictResult {
+    verdict: 'approved' | 'needs_revision';
+    feedback: string;
+}
+/**
+ * Parse a reviewer response to extract the verdict.
+ *
+ * Looks for "VERDICT: APPROVED" or "VERDICT: NEEDS_REVISION" in the response.
+ * If APPROVED, feedback is empty.
+ * If NEEDS_REVISION, feedback is the text before the verdict line.
+ * If no match, conservatively returns needs_revision with the full response as feedback.
+ */
+declare function parseVerdict(response: string): VerdictResult;
+
+/** Promise-based delay. */
+declare function sleep(ms: number): Promise<void>;
+
+/** Default timeout for model calls in seconds */
+declare const DEFAULT_TIMEOUT_SEC = 600;
+/** Default cleanup scan timeout in seconds */
+declare const CLEANUP_TIMEOUT_SEC = 1200;
+/** Default max tokens for model output */
+declare const DEFAULT_MAX_TOKENS = 4096;
+/** Implementer max tokens (larger for code generation) */
+declare const IMPLEMENTER_MAX_TOKENS = 8192;
+/** Max content length for MCP review input */
+declare const MCP_CONTENT_MAX_LENGTH = 100000;
+/** Max content length for MCP task/question input */
+declare const MCP_TASK_MAX_LENGTH = 50000;
+/** Max timeout for MCP tool calls in seconds */
+declare const MCP_TIMEOUT_MAX = 900;
+/** HTTP 429 Too Many Requests status code */
+declare const HTTP_TOO_MANY_REQUESTS = 429;
+/** Days in a year (for cost aggregation) */
+declare const DAYS_PER_YEAR = 365;
+/** Max diff size sent to reviewer */
+declare const REVIEW_DIFF_MAX_CHARS = 50000;
+/** Max review text stored in DB */
+declare const REVIEW_TEXT_MAX_CHARS = 5000;
+/** Binary detection buffer size */
+declare const BINARY_SNIFF_BYTES = 512;
+/** Context budget defaults */
+declare const CONTEXT_ACTIVE = 8000;
+declare const CONTEXT_RETRIEVED = 4000;
+declare const CONTEXT_BUFFER = 2000;
+/** DLP max content length */
+declare const DLP_MAX_CONTENT = 2000;
+/** DLP max processing time in milliseconds */
+declare const DLP_MAX_PROCESSING_MS = 2000;
+
+declare const DEFAULT_CONFIG: ProjectConfig;
+
+declare const projectConfigSchema: z.ZodEffects<z.ZodObject<{
+    configVersion: z.ZodOptional<z.ZodNumber>;
+    project: z.ZodDefault<z.ZodObject<{
+        name: z.ZodDefault<z.ZodString>;
+        description: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description: string;
+    }, {
+        name?: string | undefined;
+        description?: string | undefined;
+    }>>;
+    models: z.ZodRecord<z.ZodString, z.ZodObject<{
+        provider: z.ZodLiteral<"openai">;
+        model: z.ZodString;
+        maxTokens: z.ZodDefault<z.ZodNumber>;
+        temperature: z.ZodDefault<z.ZodNumber>;
+        timeout: z.ZodDefault<z.ZodNumber>;
+        cliAdapter: z.ZodOptional<z.ZodObject<{
+            command: z.ZodString;
+            args: z.ZodArray<z.ZodString, "many">;
+            timeout: z.ZodNumber;
+            outputFile: z.ZodOptional<z.ZodString>;
+            maxOutputBytes: z.ZodOptional<z.ZodNumber>;
+            envAllowlist: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            timeout: number;
+            command: string;
+            args: string[];
+            outputFile?: string | undefined;
+            maxOutputBytes?: number | undefined;
+            envAllowlist?: string[] | undefined;
+        }, {
+            timeout: number;
+            command: string;
+            args: string[];
+            outputFile?: string | undefined;
+            maxOutputBytes?: number | undefined;
+            envAllowlist?: string[] | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        model: string;
+        timeout: number;
+        provider: "openai";
+        maxTokens: number;
+        temperature: number;
+        cliAdapter?: {
+            timeout: number;
+            command: string;
+            args: string[];
+            outputFile?: string | undefined;
+            maxOutputBytes?: number | undefined;
+            envAllowlist?: string[] | undefined;
+        } | undefined;
+    }, {
+        model: string;
+        provider: "openai";
+        timeout?: number | undefined;
+        maxTokens?: number | undefined;
+        temperature?: number | undefined;
+        cliAdapter?: {
+            timeout: number;
+            command: string;
+            args: string[];
+            outputFile?: string | undefined;
+            maxOutputBytes?: number | undefined;
+            envAllowlist?: string[] | undefined;
+        } | undefined;
+    }>>;
+    roles: z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodString;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+        systemPromptFile: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        model: string;
+        maxTokens?: number | undefined;
+        temperature?: number | undefined;
+        systemPromptFile?: string | undefined;
+    }, {
+        model: string;
+        maxTokens?: number | undefined;
+        temperature?: number | undefined;
+        systemPromptFile?: string | undefined;
+    }>>;
+    workflow: z.ZodDefault<z.ZodString>;
+    mode: z.ZodDefault<z.ZodEnum<["autonomous", "interactive", "dashboard"]>>;
+    debate: z.ZodDefault<z.ZodObject<{
+        defaultPattern: z.ZodDefault<z.ZodEnum<["structured-rounds", "proposal-critique", "free-flowing", "parallel-panel"]>>;
+        maxRounds: z.ZodDefault<z.ZodNumber>;
+        consensusThreshold: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxRounds: number;
+        defaultPattern: "structured-rounds" | "proposal-critique" | "free-flowing" | "parallel-panel";
+        consensusThreshold: number;
+    }, {
+        maxRounds?: number | undefined;
+        defaultPattern?: "structured-rounds" | "proposal-critique" | "free-flowing" | "parallel-panel" | undefined;
+        consensusThreshold?: number | undefined;
+    }>>;
+    memory: z.ZodDefault<z.ZodObject<{
+        embeddingModel: z.ZodOptional<z.ZodString>;
+        autoExtractFacts: z.ZodDefault<z.ZodBoolean>;
+        contextBudget: z.ZodDefault<z.ZodObject<{
+            activeContext: z.ZodDefault<z.ZodNumber>;
+            retrievedMemory: z.ZodDefault<z.ZodNumber>;
+            messageBuffer: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            activeContext: number;
+            retrievedMemory: number;
+            messageBuffer: number;
+        }, {
+            activeContext?: number | undefined;
+            retrievedMemory?: number | undefined;
+            messageBuffer?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        autoExtractFacts: boolean;
+        contextBudget: {
+            activeContext: number;
+            retrievedMemory: number;
+            messageBuffer: number;
+        };
+        embeddingModel?: string | undefined;
+    }, {
+        embeddingModel?: string | undefined;
+        autoExtractFacts?: boolean | undefined;
+        contextBudget?: {
+            activeContext?: number | undefined;
+            retrievedMemory?: number | undefined;
+            messageBuffer?: number | undefined;
+        } | undefined;
+    }>>;
+    budget: z.ZodDefault<z.ZodObject<{
+        perSession: z.ZodDefault<z.ZodNumber>;
+        perDay: z.ZodDefault<z.ZodNumber>;
+        perMonth: z.ZodDefault<z.ZodNumber>;
+        warningAt: z.ZodDefault<z.ZodNumber>;
+        action: z.ZodDefault<z.ZodEnum<["warn", "pause", "block"]>>;
+    }, "strip", z.ZodTypeAny, {
+        action: "warn" | "pause" | "block";
+        perSession: number;
+        perDay: number;
+        perMonth: number;
+        warningAt: number;
+    }, {
+        action?: "warn" | "pause" | "block" | undefined;
+        perSession?: number | undefined;
+        perDay?: number | undefined;
+        perMonth?: number | undefined;
+        warningAt?: number | undefined;
+    }>>;
+    output: z.ZodDefault<z.ZodObject<{
+        saveTranscripts: z.ZodDefault<z.ZodBoolean>;
+        transcriptFormat: z.ZodDefault<z.ZodEnum<["markdown", "json"]>>;
+        transcriptDir: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        saveTranscripts: boolean;
+        transcriptFormat: "markdown" | "json";
+        transcriptDir: string;
+    }, {
+        saveTranscripts?: boolean | undefined;
+        transcriptFormat?: "markdown" | "json" | undefined;
+        transcriptDir?: string | undefined;
+    }>>;
+    advanced: z.ZodDefault<z.ZodObject<{
+        retryAttempts: z.ZodDefault<z.ZodNumber>;
+        stream: z.ZodDefault<z.ZodBoolean>;
+        logLevel: z.ZodDefault<z.ZodEnum<["debug", "info", "warn", "error"]>>;
+    }, "strip", z.ZodTypeAny, {
+        stream: boolean;
+        retryAttempts: number;
+        logLevel: "warn" | "debug" | "info" | "error";
+    }, {
+        stream?: boolean | undefined;
+        retryAttempts?: number | undefined;
+        logLevel?: "warn" | "debug" | "info" | "error" | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    models: Record<string, {
+        model: string;
+        timeout: number;
+        provider: "openai";
+        maxTokens: number;
+        temperature: number;
+        cliAdapter?: {
+            timeout: number;
+            command: string;
+            args: string[];
+            outputFile?: string | undefined;
+            maxOutputBytes?: number | undefined;
+            envAllowlist?: string[] | undefined;
+        } | undefined;
+    }>;
+    debate: {
+        maxRounds: number;
+        defaultPattern: "structured-rounds" | "proposal-critique" | "free-flowing" | "parallel-panel";
+        consensusThreshold: number;
+    };
+    project: {
+        name: string;
+        description: string;
+    };
+    roles: Record<string, {
+        model: string;
+        maxTokens?: number | undefined;
+        temperature?: number | undefined;
+        systemPromptFile?: string | undefined;
+    }>;
+    workflow: string;
+    mode: "autonomous" | "interactive" | "dashboard";
+    memory: {
+        autoExtractFacts: boolean;
+        contextBudget: {
+            activeContext: number;
+            retrievedMemory: number;
+            messageBuffer: number;
+        };
+        embeddingModel?: string | undefined;
+    };
+    budget: {
+        action: "warn" | "pause" | "block";
+        perSession: number;
+        perDay: number;
+        perMonth: number;
+        warningAt: number;
+    };
+    output: {
+        saveTranscripts: boolean;
+        transcriptFormat: "markdown" | "json";
+        transcriptDir: string;
+    };
+    advanced: {
+        stream: boolean;
+        retryAttempts: number;
+        logLevel: "warn" | "debug" | "info" | "error";
+    };
+    configVersion?: number | undefined;
+}, {
+    models: Record<string, {
+        model: string;
+        provider: "openai";
+        timeout?: number | undefined;
+        maxTokens?: number | undefined;
+        temperature?: number | undefined;
+        cliAdapter?: {
+            timeout: number;
+            command: string;
+            args: string[];
+            outputFile?: string | undefined;
+            maxOutputBytes?: number | undefined;
+            envAllowlist?: string[] | undefined;
+        } | undefined;
+    }>;
+    roles: Record<string, {
+        model: string;
+        maxTokens?: number | undefined;
+        temperature?: number | undefined;
+        systemPromptFile?: string | undefined;
+    }>;
+    debate?: {
+        maxRounds?: number | undefined;
+        defaultPattern?: "structured-rounds" | "proposal-critique" | "free-flowing" | "parallel-panel" | undefined;
+        consensusThreshold?: number | undefined;
+    } | undefined;
+    configVersion?: number | undefined;
+    project?: {
+        name?: string | undefined;
+        description?: string | undefined;
+    } | undefined;
+    workflow?: string | undefined;
+    mode?: "autonomous" | "interactive" | "dashboard" | undefined;
+    memory?: {
+        embeddingModel?: string | undefined;
+        autoExtractFacts?: boolean | undefined;
+        contextBudget?: {
+            activeContext?: number | undefined;
+            retrievedMemory?: number | undefined;
+            messageBuffer?: number | undefined;
+        } | undefined;
+    } | undefined;
+    budget?: {
+        action?: "warn" | "pause" | "block" | undefined;
+        perSession?: number | undefined;
+        perDay?: number | undefined;
+        perMonth?: number | undefined;
+        warningAt?: number | undefined;
+    } | undefined;
+    output?: {
+        saveTranscripts?: boolean | undefined;
+        transcriptFormat?: "markdown" | "json" | undefined;
+        transcriptDir?: string | undefined;
+    } | undefined;
+    advanced?: {
+        stream?: boolean | undefined;
+        retryAttempts?: number | undefined;
+        logLevel?: "warn" | "debug" | "info" | "error" | undefined;
+    } | undefined;
+}>, {
+    models: Record<string, {
+        model: string;
+        timeout: number;
+        provider: "openai";
+        maxTokens: number;
+        temperature: number;
+        cliAdapter?: {
+            timeout: number;
+            command: string;
+            args: string[];
+            outputFile?: string | undefined;
+            maxOutputBytes?: number | undefined;
+            envAllowlist?: string[] | undefined;
+        } | undefined;
+    }>;
+    debate: {
+        maxRounds: number;
+        defaultPattern: "structured-rounds" | "proposal-critique" | "free-flowing" | "parallel-panel";
+        consensusThreshold: number;
+    };
+    project: {
+        name: string;
+        description: string;
+    };
+    roles: Record<string, {
+        model: string;
+        maxTokens?: number | undefined;
+        temperature?: number | undefined;
+        systemPromptFile?: string | undefined;
+    }>;
+    workflow: string;
+    mode: "autonomous" | "interactive" | "dashboard";
+    memory: {
+        autoExtractFacts: boolean;
+        contextBudget: {
+            activeContext: number;
+            retrievedMemory: number;
+            messageBuffer: number;
+        };
+        embeddingModel?: string | undefined;
+    };
+    budget: {
+        action: "warn" | "pause" | "block";
+        perSession: number;
+        perDay: number;
+        perMonth: number;
+        warningAt: number;
+    };
+    output: {
+        saveTranscripts: boolean;
+        transcriptFormat: "markdown" | "json";
+        transcriptDir: string;
+    };
+    advanced: {
+        stream: boolean;
+        retryAttempts: number;
+        logLevel: "warn" | "debug" | "info" | "error";
+    };
+    configVersion?: number | undefined;
+}, {
+    models: Record<string, {
+        model: string;
+        provider: "openai";
+        timeout?: number | undefined;
+        maxTokens?: number | undefined;
+        temperature?: number | undefined;
+        cliAdapter?: {
+            timeout: number;
+            command: string;
+            args: string[];
+            outputFile?: string | undefined;
+            maxOutputBytes?: number | undefined;
+            envAllowlist?: string[] | undefined;
+        } | undefined;
+    }>;
+    roles: Record<string, {
+        model: string;
+        maxTokens?: number | undefined;
+        temperature?: number | undefined;
+        systemPromptFile?: string | undefined;
+    }>;
+    debate?: {
+        maxRounds?: number | undefined;
+        defaultPattern?: "structured-rounds" | "proposal-critique" | "free-flowing" | "parallel-panel" | undefined;
+        consensusThreshold?: number | undefined;
+    } | undefined;
+    configVersion?: number | undefined;
+    project?: {
+        name?: string | undefined;
+        description?: string | undefined;
+    } | undefined;
+    workflow?: string | undefined;
+    mode?: "autonomous" | "interactive" | "dashboard" | undefined;
+    memory?: {
+        embeddingModel?: string | undefined;
+        autoExtractFacts?: boolean | undefined;
+        contextBudget?: {
+            activeContext?: number | undefined;
+            retrievedMemory?: number | undefined;
+            messageBuffer?: number | undefined;
+        } | undefined;
+    } | undefined;
+    budget?: {
+        action?: "warn" | "pause" | "block" | undefined;
+        perSession?: number | undefined;
+        perDay?: number | undefined;
+        perMonth?: number | undefined;
+        warningAt?: number | undefined;
+    } | undefined;
+    output?: {
+        saveTranscripts?: boolean | undefined;
+        transcriptFormat?: "markdown" | "json" | undefined;
+        transcriptDir?: string | undefined;
+    } | undefined;
+    advanced?: {
+        stream?: boolean | undefined;
+        retryAttempts?: number | undefined;
+        logLevel?: "warn" | "debug" | "info" | "error" | undefined;
+    } | undefined;
+}>;
+type ProjectConfigInput = z.input<typeof projectConfigSchema>;
+/**
+ * Validate and parse a config object. Throws ConfigError on invalid input.
+ */
+declare function validateConfig(config: unknown): z.output<typeof projectConfigSchema>;
+
+/**
+ * Load a built-in preset by name. Returns a partial config to be merged with defaults.
+ */
+declare function loadPreset(name: PresetName): Record<string, unknown>;
+/** List available preset names. */
+declare function listPresets(): PresetName[];
+
+/**
+ * Load config with precedence: overrides > .mulep.yml > preset > defaults.
+ *
+ * 1. Start with hardcoded defaults
+ * 2. If a preset name is found (in file or overrides), merge preset on top
+ * 3. Merge .mulep.yml from projectDir on top
+ * 4. Merge programmatic overrides on top
+ * 5. Validate the final result
+ */
+declare function loadConfig(options?: {
+    projectDir?: string;
+    preset?: PresetName;
+    overrides?: Partial<ProjectConfig>;
+    skipFile?: boolean;
+}): ProjectConfig;
+/**
+ * Write a ProjectConfig to .mulep.yml in the given directory.
+ * Also creates .mulep/db/ and .mulep/transcripts/ directories.
+ */
+declare function writeConfig(config: ProjectConfig, dir: string): void;
+
+declare const CURRENT_VERSION = 2;
+/**
+ * Migrate a ProjectConfig from an older schema version to the current version.
+ * Creates a .bak backup before writing changes if configPath is provided.
+ * Returns the migrated config (always in-memory; optionally persisted to disk).
+ */
+declare function migrateConfig(config: ProjectConfig, configPath?: string): ProjectConfig;
+
+interface ReviewPreset {
+    name: string;
+    focus: string;
+    constraints: string[];
+    timeoutSec: number;
+    severityFloor: 'info' | 'warning' | 'critical';
+    strictOutput: boolean;
+}
+declare const REVIEW_PRESETS: Record<string, ReviewPreset>;
+declare function getReviewPreset(name: string): ReviewPreset | undefined;
+declare function listPresetNames(): string[];
+
+/**
+ * Load and compile all ignore patterns into a single matcher.
+ * Precedence: builtins -> .gitignore -> .mulepignore
+ */
+declare function createIgnoreFilter(projectDir: string, options?: {
+    skipGitignore?: boolean;
+}): Ignore;
+declare function loadIgnorePatterns(projectDir: string): string[];
+declare function shouldIgnore(filePath: string, patterns: string[]): boolean;
+
+/**
+ * Open a SQLite database and run migrations.
+ * Pass ':memory:' for in-memory databases (testing).
+ */
+declare function openDatabase(dbPath: string): Database.Database;
+/**
+ * Run all schema migrations. Idempotent (uses IF NOT EXISTS).
+ */
+declare function runMigrations(db: Database.Database): void;
+/** Get the current schema version. */
+declare function getSchemaVersion(db: Database.Database): string | null;
+
+declare class SessionStore {
+    private db;
+    constructor(db: Database.Database);
+    create(params: {
+        projectId: string;
+        workflowId: string;
+        task: string;
+        mode: ExecutionMode;
+        config: ProjectConfig;
+    }): Session;
+    get(sessionId: string): Session | null;
+    list(filter?: {
+        status?: SessionStatus;
+        projectId?: string;
+        limit?: number;
+    }): Session[];
+    updateStatus(sessionId: string, status: SessionStatus): void;
+    updateCurrentStep(sessionId: string, stepId: string): void;
+    complete(sessionId: string, summary?: string): void;
+    addUsage(sessionId: string, cost: number, tokens: number): void;
+    saveTranscriptEntry(entry: TranscriptEntry): void;
+    getTranscript(sessionId: string): TranscriptEntry[];
+    private rowToSession;
+}
+
+declare class MemoryStore {
+    private db;
+    constructor(db: Database.Database);
+    save(memory: Omit<MemoryRecord, 'id' | 'createdAt' | 'accessedAt' | 'accessCount'>): number;
+    search(query: string, projectId: string, limit?: number): MemoryRecord[];
+    getByCategory(projectId: string, category: MemoryCategory): MemoryRecord[];
+    getById(memoryId: number): MemoryRecord | null;
+    recordAccess(memoryId: number): void;
+    /** Check if a memory with matching category and content prefix already exists. */
+    findByPrefix(projectId: string, category: string, contentPrefix: string): MemoryRecord | null;
+    delete(memoryId: number): void;
+    private rowToMemory;
+}
+
+declare class ArtifactStore {
+    private db;
+    constructor(db: Database.Database);
+    save(artifact: Omit<ArtifactRecord, 'id' | 'createdAt'>): number;
+    getBySession(sessionId: string): ArtifactRecord[];
+    getByStep(sessionId: string, stepId: string): ArtifactRecord[];
+    getLatestByStep(sessionId: string, stepId: string): ArtifactRecord | null;
+    getByType(sessionId: string, type: ArtifactType): ArtifactRecord[];
+    private rowToArtifact;
+}
+
+interface CostSummary {
+    modelId: string;
+    callCount: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalCost: number;
+    avgLatencyMs: number;
+}
+declare class CostStore {
+    private db;
+    constructor(db: Database.Database);
+    log(entry: Omit<CostLogEntry, 'id' | 'createdAt'>): number;
+    getBySession(sessionId: string): CostLogEntry[];
+    getSessionSummary(sessionId: string): CostSummary[];
+    getDailySummary(days?: number): Record<string, unknown>[];
+    private rowToEntry;
+}
+
+type DebateTurnStatus = 'active' | 'completed' | 'interrupted' | 'stale' | 'expired';
+interface DebateTurnRow {
+    id: number;
+    debateId: string;
+    role: string;
+    codexSessionId: string | null;
+    round: number;
+    status: DebateTurnStatus;
+    resumeFailCount: number;
+    lastActivityAt: number;
+    createdAt: number;
+    stateJson: string | null;
+}
+declare class DebateStore {
+    private db;
+    constructor(db: Database.Database);
+    /** Create or update a debate turn (upsert on debate_id + role). */
+    upsert(params: {
+        debateId: string;
+        role: string;
+        codexSessionId?: string;
+        round?: number;
+        status?: DebateTurnStatus;
+        stateJson?: string;
+    }): void;
+    /** Get a debate turn by debate_id and role. */
+    get(debateId: string, role: string): DebateTurnRow | null;
+    /** Get all turns for a debate. */
+    getByDebateId(debateId: string): DebateTurnRow[];
+    /** List debates, optionally filtered by status. */
+    list(filter?: {
+        status?: DebateTurnStatus;
+        limit?: number;
+    }): DebateTurnRow[];
+    /** Update session ID after a successful codex call. */
+    updateSessionId(debateId: string, role: string, codexSessionId: string): void;
+    /** Update status (e.g., active → completed). */
+    updateStatus(debateId: string, role: string, status: DebateTurnStatus): void;
+    /** Increment resume failure count. */
+    incrementResumeFailCount(debateId: string, role: string): void;
+    /** Persist full debate state as JSON for crash recovery. */
+    saveState(debateId: string, role: string, state: DebateEngineState): void;
+    /** Load saved debate state from JSON. */
+    loadState(debateId: string, role: string): DebateEngineState | null;
+    /** Mark stale debates (active but inactive for > threshold). */
+    markStale(thresholdMs: number): number;
+    /** Mark expired debates (stale and older than threshold). */
+    markExpired(thresholdMs: number): number;
+    private toRow;
+}
+
+declare class BuildStore {
+    private db;
+    constructor(db: Database.Database);
+    /** Create a new build run. */
+    create(params: {
+        buildId: string;
+        task: string;
+        debateId?: string;
+        baselineRef?: string;
+    }): void;
+    /** Get a build run by build_id. */
+    get(buildId: string): BuildRun | null;
+    /** List builds, optionally filtered by status. */
+    list(filter?: {
+        status?: BuildStatus;
+        limit?: number;
+    }): BuildSummary[];
+    /** Update build run fields atomically with event append. */
+    updateWithEvent(buildId: string, updates: Partial<{
+        status: BuildStatus;
+        currentPhase: BuildPhase;
+        currentLoop: number;
+        debateId: string;
+        baselineRef: string;
+        planCodexSession: string;
+        reviewCodexSession: string;
+        planVersion: number;
+        reviewCycles: number;
+        completedAt: number;
+        metadata: Record<string, unknown>;
+    }>, event: {
+        eventType: BuildEventType;
+        actor: BuildActor;
+        phase: BuildPhase;
+        loopIndex?: number;
+        payload?: Record<string, unknown>;
+        codexThreadId?: string;
+        tokensUsed?: number;
+    }): void;
+    /** Get events for a build, ordered by seq. */
+    getEvents(buildId: string, afterSeq?: number): BuildEvent[];
+    /** Count events by type for a build. */
+    countEventsByType(buildId: string, eventType: BuildEventType): number;
+    private toRun;
+    private toEvent;
+}
+
+type MessageStatus = 'queued' | 'running' | 'completed' | 'failed';
+interface DebateMessageRow {
+    id: number;
+    debateId: string;
+    round: number;
+    role: string;
+    bridge: string;
+    model: string;
+    promptText: string;
+    responseText: string | null;
+    stance: string | null;
+    confidence: number | null;
+    verdictRaw: string | null;
+    usageJson: string | null;
+    durationMs: number | null;
+    sessionId: string | null;
+    status: MessageStatus;
+    error: string | null;
+    createdAt: number;
+    updatedAt: number;
+    completedAt: number | null;
+}
+interface ParsedVerdict {
+    stance: string | null;
+    confidence: number | null;
+    raw: string | null;
+}
+/** Parse structured verdict from model response. */
+declare function parseDebateVerdict(text: string): ParsedVerdict;
+declare class MessageStore {
+    private db;
+    constructor(db: Database.Database);
+    /** Insert a new message in queued state. Returns the row ID. */
+    insertQueued(params: {
+        debateId: string;
+        round: number;
+        role: string;
+        bridge: string;
+        model: string;
+        promptText: string;
+    }): number;
+    /** Update prompt text on a queued or failed row (for retries with different prompts). */
+    updatePrompt(id: number, promptText: string): boolean;
+    /** Transition to running. Only from queued or failed. Returns true if transition succeeded. */
+    markRunning(id: number): boolean;
+    /** Transition to completed with response data. Only from running. */
+    markCompleted(id: number, params: {
+        responseText: string;
+        verdict: ParsedVerdict;
+        usageJson: string;
+        durationMs: number;
+        sessionId: string | null;
+    }): boolean;
+    /** Transition to failed with error. Only from running. */
+    markFailed(id: number, error: string): boolean;
+    /** Get a message by debate_id, round, and role (for idempotency checks). */
+    getByRound(debateId: string, round: number, role: string): DebateMessageRow | null;
+    /** Get full message history for a debate, ordered by round. */
+    getHistory(debateId: string): DebateMessageRow[];
+    /** Recover stale running rows older than threshold. Returns count recovered. */
+    recoverStale(thresholdMs: number): number;
+    /** Recover stale running rows for a specific debate only. */
+    recoverStaleForDebate(debateId: string, thresholdMs: number): number;
+    private toRow;
+}
+
+/**
+ * Build a reconstruction preamble from stored debate messages.
+ * Used when session resume fails and we need to give GPT context of previous rounds.
+ *
+ * Strategy:
+ * - If history fits within tokenBudget: include all rounds verbatim
+ * - If over budget: summarize oldest rounds, keep newest verbatim
+ *
+ * @param history - Previous completed messages from MessageStore.getHistory()
+ * @param currentPrompt - The new prompt for this round
+ * @param maxChars - Approximate character budget (rough proxy for tokens; ~4 chars/token)
+ * @returns The reconstructed prompt with history preamble
+ */
+declare function buildReconstructionPrompt(history: DebateMessageRow[], currentPrompt: string, maxChars?: number): string;
+
+interface TokenBudgetStatus {
+    /** Total tokens used across all rounds. */
+    totalTokensUsed: number;
+    /** Maximum context tokens for the model. */
+    maxContextTokens: number;
+    /** Usage as a fraction (0-1). */
+    utilizationRatio: number;
+    /** Whether auto-summarization is recommended (>= 70%). */
+    shouldSummarize: boolean;
+    /** Whether the debate should be completed (>= 90%). */
+    shouldStop: boolean;
+    /** Estimated tokens remaining. */
+    tokensRemaining: number;
+}
+/** Estimate token count from character length. */
+declare function estimateTokens(text: string): number;
+/**
+ * Calculate total tokens used in a debate from stored messages.
+ * Uses actual usage_json when available, falls back to text length estimation.
+ */
+declare function calculateDebateTokens(history: DebateMessageRow[]): number;
+/**
+ * Get the current token budget status for a debate.
+ */
+declare function getTokenBudgetStatus(history: DebateMessageRow[], maxContextTokens: number): TokenBudgetStatus;
+/**
+ * Preflight check: estimate if a new prompt will fit within budget.
+ * Returns the status AFTER the hypothetical send.
+ */
+declare function preflightTokenCheck(history: DebateMessageRow[], newPrompt: string, maxContextTokens: number): TokenBudgetStatus;
+
+interface UnifiedSession {
+    id: string;
+    name: string | null;
+    codexThreadId: string | null;
+    status: 'active' | 'completed' | 'stale';
+    tokenUsage: number;
+    maxContext: number;
+    createdAt: number;
+    updatedAt: number;
+    completedAt: number | null;
+}
+interface SessionEvent {
+    id: number;
+    sessionId: string;
+    command: string;
+    subcommand: string | null;
+    promptPreview: string | null;
+    responsePreview: string | null;
+    usageJson: string | null;
+    durationMs: number | null;
+    codexThreadId: string | null;
+    createdAt: number;
+}
+declare class SessionManager {
+    private db;
+    constructor(db: Database.Database);
+    /** Create a new session. Returns the session ID. */
+    create(name?: string): string;
+    /** Get a session by ID. */
+    get(id: string): UnifiedSession | null;
+    /** Get the current active session (most recently updated). */
+    getActive(): UnifiedSession | null;
+    /** Get or create the active session. If none exists, auto-create one. */
+    resolveActive(autoName?: string): UnifiedSession;
+    /** Update the codex thread ID for a session. Pass null to clear. */
+    updateThreadId(sessionId: string, threadId: string | null): void;
+    /** Update token usage for a session. Ignores negative values. */
+    addTokenUsage(sessionId: string, tokens: number): void;
+    /**
+     * Add token usage from a model call result. Uses real usage when available,
+     * falls back to char/4 estimate only when usage data is missing.
+     */
+    addUsageFromResult(sessionId: string, usage: {
+        totalTokens?: number;
+        inputTokens?: number;
+        outputTokens?: number;
+    }, promptText?: string, responseText?: string): void;
+    /** Touch the updated_at timestamp. */
+    touch(sessionId: string): void;
+    /** Mark a session as completed. */
+    complete(sessionId: string): void;
+    /** List sessions, optionally filtered by status. */
+    list(options?: {
+        status?: string;
+        limit?: number;
+    }): UnifiedSession[];
+    /** Record a GPT interaction event. Stores preview (500 chars) + optional full text. */
+    recordEvent(params: {
+        sessionId: string;
+        command: string;
+        subcommand?: string;
+        promptPreview?: string;
+        responsePreview?: string;
+        promptFull?: string;
+        responseFull?: string;
+        usageJson?: string;
+        durationMs?: number;
+        codexThreadId?: string;
+    }): number;
+    /** Get events for a session. */
+    getEvents(sessionId: string, rawLimit?: number): SessionEvent[];
+    /** Estimate tokens from prompt + response text (for usage tracking when real usage unavailable). */
+    estimateEventTokens(promptText: string, responseText: string): number;
+    private toSession;
+}
+
+declare class JobStore {
+    private db;
+    constructor(db: Database.Database);
+    /** Enqueue a new job. Returns the job ID. */
+    enqueue(options: EnqueueOptions): string;
+    /** Get a job by ID. */
+    get(id: string): JobRecord | null;
+    /** Atomically claim the next N queued jobs. Returns claimed jobs. */
+    claimNext(workerId: string, limit?: number): JobRecord[];
+    /** Mark a job as succeeded. Only updates if still running (not canceled). */
+    succeed(id: string, result: Record<string, unknown>): void;
+    /** Mark a job as failed. Only updates if still running (not canceled). */
+    fail(id: string, error: string): void;
+    /** Cancel a job. */
+    cancel(id: string): void;
+    /** Retry a failed/canceled job. */
+    retry(id: string): boolean;
+    /** List jobs with optional filters. */
+    list(options?: {
+        status?: JobStatus;
+        type?: JobType;
+        limit?: number;
+    }): JobRecord[];
+    /** Check if a dedupe key already has an active (queued/running) job. */
+    hasActive(dedupeKey: string): boolean;
+    /** Check if any active job exists for a given type. */
+    hasActiveByType(type: string): boolean;
+    /** Append a log entry. */
+    appendLog(jobId: string, level: JobLogRecord['level'], eventType: string, message?: string, payload?: Record<string, unknown>): void;
+    /** Get logs for a job. */
+    getLogs(jobId: string, fromSeq?: number, limit?: number): JobLogRecord[];
+    private toJob;
+}
+
+interface CacheEntry {
+    id: number;
+    key: string;
+    kind: string;
+    contentHash: string;
+    configHash: string;
+    model: string;
+    valueJson: string;
+    expiresAt: number;
+    hitCount: number;
+    createdAt: number;
+}
+declare class CacheStore {
+    private db;
+    constructor(db: Database.Database);
+    get(key: string, contentHash: string, configHash: string): CacheEntry | null;
+    set(entry: {
+        key: string;
+        kind: string;
+        contentHash: string;
+        configHash: string;
+        model: string;
+        valueJson: string;
+        ttlMs: number;
+    }): void;
+    evictExpired(): number;
+    clear(): number;
+    stats(): {
+        totalEntries: number;
+        totalHits: number;
+        expiredCount: number;
+    };
+}
+declare function hashContent(content: string): string;
+declare function hashConfig(config: Record<string, unknown>): string;
+
+/** Capabilities that a bridge implementation advertises. */
+interface BridgeCapabilities {
+    /** Whether the bridge supports session resume (multi-turn statefulness). */
+    supportsResume: boolean;
+    /** Whether the bridge supports streaming output. */
+    supportsStream: boolean;
+    /** Maximum context window in tokens. */
+    maxContextTokens: number;
+    /** Whether the bridge can use tools (read files, run commands). */
+    supportsTools: boolean;
+    /** Whether the bridge can access the project working directory. */
+    supportsCwd: boolean;
+}
+/** Options for a bridge send/resume call. */
+interface BridgeOptions extends ProgressCallbacks {
+    timeout?: number;
+    maxOutputBytes?: number;
+    idleTimeout?: number;
+}
+/** Options for a bridge resume call. */
+interface BridgeResumeOptions extends BridgeOptions {
+    sessionId: string;
+}
+/**
+ * Generic interface for bridging communication between two CLI tools.
+ * Each implementation handles its own CLI's quirks (JSONL parsing, session format, auth).
+ */
+interface CliBridge {
+    /** Human-readable bridge name (e.g., 'codex', 'gemini', 'claude'). */
+    readonly name: string;
+    /** Model identifier. */
+    readonly model: string;
+    /** Advertised capabilities. */
+    readonly capabilities: BridgeCapabilities;
+    /** Send a prompt and get a response. */
+    send(prompt: string, options?: BridgeOptions): Promise<ModelCallResult>;
+    /** Resume a previous session with a new prompt. Falls back to send() if resume unsupported. */
+    resume(sessionId: string, prompt: string, options?: BridgeOptions): Promise<ModelCallResult>;
+}
+
+/** Progress callbacks for real-time feedback during CLI subprocess execution. */
+interface ProgressCallbacks {
+    /** Called when the subprocess successfully spawns. */
+    onSpawn?: (pid: number, command: string) => void;
+    /** Called on each stderr chunk (tool calls, activity). */
+    onStderr?: (chunk: string) => void;
+    /** Called periodically (every 15s) with elapsed seconds. */
+    onHeartbeat?: (elapsedSec: number) => void;
+    /** Called on each stdout chunk for progress feedback. */
+    onProgress?: (chunk: string) => void;
+    /** Called when the subprocess closes — flush any buffered state. */
+    onClose?: () => void;
+}
+interface CliCallOptions extends ProgressCallbacks {
+    /** Total timeout in ms. Default: 600_000 (10 min). */
+    timeout?: number;
+    /** Inactivity timeout — kill if no stdout for this long. Default: 120_000 (2 min). */
+    idleTimeout?: number;
+    maxOutputBytes?: number;
+    envAllowlist?: string[];
+}
+interface ResumeCallOptions extends CliCallOptions {
+    /** Codex thread_id to resume a conversation. */
+    sessionId?: string;
+}
+declare class CliAdapter implements CliBridge {
+    private command;
+    private baseArgs;
+    private provider;
+    readonly modelId: string;
+    private cliName;
+    private projectDir;
+    readonly capabilities: BridgeCapabilities;
+    get name(): string;
+    get model(): string;
+    constructor(config: {
+        command: string;
+        args: string[];
+        provider: ModelProvider;
+        model: string;
+        cliName: string;
+        projectDir?: string;
+    });
+    /** CliBridge.send — send a prompt without session resume. */
+    send(prompt: string, options?: CliCallOptions): Promise<ModelCallResult>;
+    /** CliBridge.resume — resume a session or fall back to send. */
+    resume(sessionId: string, prompt: string, options?: CliCallOptions): Promise<ModelCallResult>;
+    call(prompt: string, options?: CliCallOptions): Promise<ModelCallResult>;
+    /**
+     * Call codex with session resume support via --json JSONL output.
+     * If sessionId is provided, resumes the conversation. On resume failure,
+     * falls back to a fresh exec and returns the new sessionId.
+     */
+    callWithResume(prompt: string, options?: ResumeCallOptions): Promise<ModelCallResult>;
+    private buildArgs;
+    private runProcess;
+}
+
+/** All models are CLI adapters now. */
+type ModelAdapter = CliAdapter;
+declare class ModelRegistry {
+    private models;
+    private configs;
+    private constructor();
+    /**
+     * Build a registry from a ProjectConfig.
+     * All models are CLI adapters (codex).
+     */
+    static fromConfig(config: ProjectConfig, projectDir?: string): ModelRegistry;
+    /**
+     * Resolve auto mode — probe codex CLI availability.
+     * Kept for API compatibility; all models are CLI now.
+     */
+    resolveAutoMode(): Promise<void>;
+    /** Get the adapter for an alias, or null if not found. */
+    tryGetAdapter(alias: string): ModelAdapter | null;
+    /** Get the adapter for an alias. Throws if not found. */
+    getAdapter(alias: string): ModelAdapter;
+    /** Check if an alias is backed by CLI adapter (always true now). */
+    isCliMode(_alias: string): boolean;
+    /** Get the ModelConfig for an alias. */
+    getModelConfig(alias: string): ModelConfig;
+    /** Resolve role -> alias -> ModelAdapter. */
+    getAdapterForRole(role: string, config: ProjectConfig): ModelAdapter;
+    /** Resolve role -> alias -> ModelConfig. */
+    getModelConfigForRole(role: string, config: ProjectConfig): ModelConfig;
+    /** List all registered model aliases. */
+    listAliases(): string[];
+    /**
+     * Health check: verify codex CLI is available and authenticated.
+     */
+    healthCheckAll(): Promise<Map<string, boolean>>;
+}
+
+/**
+ * Callback for receiving streaming text deltas.
+ */
+type TextDeltaEmitter = (delta: string) => void;
+/**
+ * Unified model call: routes to CLI adapter.
+ */
+declare function callModel(model: ModelAdapter, messages: ChatMessage[], options?: CallModelOptions): Promise<ModelCallResult>;
+/**
+ * Unified streaming model call.
+ * CLI: chunked pseudo-streaming (paragraph-split after process completes).
+ */
+declare function streamModel(model: ModelAdapter, messages: ChatMessage[], onDelta: TextDeltaEmitter, _stepId: string, _role: string, options?: CallModelOptions): Promise<ModelCallResult>;
+
+/**
+ * Execute a model call with fallback support.
+ *
+ * Tries the primary call first. On retryable errors, tries each fallback in order.
+ * The `callFn` receives the model alias and must perform the actual model call.
+ */
+declare function withFallback(callFn: (modelAlias: string) => Promise<ModelCallResult>, config: FallbackConfig): Promise<ModelCallResult>;
+
+/**
+ * Wraps model calls and records cost/usage to the CostStore.
+ * Created per-session by the Orchestrator.
+ */
+declare class CostTracker {
+    private costStore;
+    private sessionId;
+    constructor(costStore: CostStore, sessionId: string);
+    /**
+     * Execute a model call and record its cost.
+     * Usage: `costTracker.tracked(() => callModel(model, msgs, opts), 'plan')`
+     */
+    tracked(fn: () => Promise<ModelCallResult>, stepId?: string): Promise<ModelCallResult>;
+    /** Record usage from an already-completed model call. */
+    record(result: ModelCallResult, stepId?: string): void;
+}
+
+interface ModelPricing {
+    inputPer1M: number;
+    outputPer1M: number;
+}
+declare function getModelPricing(modelId: string): ModelPricing | null;
+/**
+ * Calculate cost in USD for a model call.
+ * Returns 0 if the model is not in the pricing table.
+ */
+declare function calculateCost(modelId: string, inputTokens: number, outputTokens: number): number;
+
+interface CliDetectionResult {
+    available: boolean;
+    path?: string;
+    version?: string;
+    authOk?: boolean;
+    detectedAt: number;
+    error?: string;
+}
+declare function detectCli(name: 'codex'): Promise<CliDetectionResult>;
+declare function clearDetectionCache(): void;
+
+/**
+ * The 5 prompt types supported in Sprint 1.
+ */
+type PromptType = 'plan' | 'plan-review' | 'plan-revision' | 'code' | 'code-review';
+/**
+ * Variables passed into prompt templates.
+ */
+interface PromptVariables {
+    task: string;
+    projectName?: string;
+    projectDescription?: string;
+    plan?: string;
+    previousPlan?: string;
+    feedback?: string;
+    code?: string;
+}
+/**
+ * Render a prompt template into ChatMessage[] (system + user messages).
+ */
+declare function renderPrompt(type: PromptType, vars: PromptVariables): ChatMessage[];
+
+/**
+ * Resolves roles from config, provides prompt rendering and message assembly.
+ */
+declare class RoleManager {
+    private config;
+    constructor(config: ProjectConfig);
+    /**
+     * Resolve a role name to a fully hydrated Role object.
+     * Merges built-in defaults with config overrides.
+     */
+    getRole(roleName: string): Role;
+    /**
+     * Build a ChatMessage[] for a model call.
+     * Renders the appropriate prompt template with project context and variables.
+     */
+    buildMessages(promptType: PromptType, vars: PromptVariables): ChatMessage[];
+    /** List all configured role names. */
+    listRoles(): string[];
+    /** Get the RoleConfig for a role name. */
+    getRoleConfig(roleName: string): RoleConfig;
+}
+
+interface EventBusEvents {
+    event: (event: EngineEvent) => void;
+}
+/**
+ * Typed event bus for AG-UI compatible engine events.
+ * Wraps eventemitter3 with typed EngineEvent emission.
+ */
+declare class EventBus extends EventEmitter<EventBusEvents> {
+    /** Emit a typed AG-UI event, auto-injecting timestamp if missing. */
+    emitEvent(event: EngineEvent): void;
+}
+
+interface StepResult {
+    stepId: string;
+    output: string;
+    usage: TokenUsage;
+    durationMs: number;
+    verdict?: 'approved' | 'needs_revision';
+    feedback?: string;
+    score?: number;
+}
+declare class StepRunner {
+    private registry;
+    private roleManager;
+    private costTracker;
+    private eventBus;
+    private sessionStore;
+    private config;
+    private sessionId;
+    constructor(registry: ModelRegistry, roleManager: RoleManager, costTracker: CostTracker, eventBus: EventBus, sessionStore: SessionStore, config: ProjectConfig, sessionId: string);
+    execute(step: ResolvedStep, inputs: Map<string, string>, task: string, iteration: number, options?: {
+        stream?: boolean;
+    }): Promise<StepResult>;
+    private resolvePromptType;
+    private buildPromptVars;
+}
+
+interface LoopResult {
+    finalOutput: string;
+    iterations: number;
+    approved: boolean;
+    history: StepResult[];
+    finalScore?: number;
+}
+interface LoopOptions {
+    /** Score threshold for auto-approval on iteration >= 2. Only applies when set. */
+    autoApproveThreshold?: number;
+}
+declare class LoopController {
+    executeLoop(generateStep: ResolvedStep, reviewStep: ResolvedStep, inputs: Map<string, string>, task: string, maxIterations: number, runner: StepRunner, eventBus: EventBus, loopOptions?: LoopOptions): Promise<LoopResult>;
+}
+
+declare class CancellationToken {
+    private cancelled;
+    private callbacks;
+    /** Signal cancellation. Idempotent — multiple calls are safe. */
+    cancel(): void;
+    get isCancelled(): boolean;
+    /** Throw if already cancelled. Call before starting expensive work. */
+    throwIfCancelled(): void;
+    /**
+     * Register a callback to run on cancellation.
+     * Deduplicated by reference — same function won't run twice.
+     * If already cancelled, callback fires immediately.
+     */
+    onCancel(callback: () => void): void;
+    /** Remove a previously registered callback. */
+    offCancel(callback: () => void): void;
+    /**
+     * Create a promise that resolves after `ms` but can be interrupted by cancellation.
+     * Returns true if sleep completed, false if cancelled.
+     */
+    sleep(ms: number): Promise<boolean>;
+}
+declare class CancellationError extends Error {
+    constructor(message: string);
+}
+
+interface OrchestratorEvents {
+    event: (event: EngineEvent) => void;
+}
+interface OrchestratorOptions {
+    registry: ModelRegistry;
+    db: Database.Database;
+    config: ProjectConfig;
+    workflowDir?: string;
+    projectDir?: string;
+}
+interface RunOptions {
+    mode?: ExecutionMode;
+    maxIterations?: number;
+    stream?: boolean;
+    workflowDir?: string;
+}
+interface PlanOptions {
+    maxRounds?: number;
+    stream?: boolean;
+    workflowDir?: string;
+    /** Score threshold (1-10) for auto-approving plans on 2nd+ iteration. Default: 8. */
+    autoApproveThreshold?: number;
+}
+interface SessionResult {
+    sessionId: string;
+    status: 'completed' | 'failed';
+    finalOutput: string;
+    totalCost: number;
+    totalTokens: number;
+    durationMs: number;
+    iterations: number;
+    error?: string;
+    lastStep?: string;
+}
+interface ReviewOptions {
+    criteria?: string[];
+    model?: string;
+    strict?: boolean;
+    timeout?: number;
+}
+interface DebateOptions {
+    modelAliases?: string[];
+    synthesize?: boolean;
+    timeout?: number;
+    maxConcurrency?: number;
+}
+declare class Orchestrator extends EventEmitter<OrchestratorEvents> {
+    private registry;
+    private config;
+    private sessionStore;
+    private artifactStore;
+    private costStore;
+    private memoryStore;
+    private roleManager;
+    private workflowEngine;
+    private eventBus;
+    private contextBuilder;
+    constructor(options: OrchestratorOptions);
+    run(task: string, options?: RunOptions): Promise<SessionResult>;
+    plan(task: string, options?: PlanOptions): Promise<SessionResult>;
+    /**
+     * Review content with a single model.
+     * DLP-sanitizes content first (strict mode by default).
+     */
+    review(content: string, options?: ReviewOptions, cancellationToken?: CancellationToken): Promise<ReviewResult>;
+    /**
+     * Debate a question across multiple models.
+     * DLP-sanitizes question first. Runs models concurrently with async semaphore.
+     */
+    debate(question: string, options?: DebateOptions, cancellationToken?: CancellationToken): Promise<DebateResult>;
+    /**
+     * Multi-round debate: models see and respond to each other's arguments.
+     * Uses proposal-critique pattern: proposer → critic → revise → critique → ...
+     * Models iterate until convergence (critic approves) or max rounds.
+     */
+    debateMultiRound(question: string, options?: {
+        modelAliases?: string[];
+        maxRounds?: number;
+        timeout?: number;
+    }): Promise<DebateEngineResult>;
+    /** Resolve the default reviewer model alias from roles config. */
+    private resolveReviewerAlias;
+    /** Resolve debate aliases — all configured model aliases. */
+    private resolveDebateAliases;
+    /**
+     * Save a memory only if no similar entry already exists (content-prefix dedup).
+     * Uses SQL LIKE prefix match instead of FTS5 for reliable exact matching.
+     */
+    private saveMemoryIfNew;
+    /**
+     * Shared session lifecycle for run() and plan().
+     * Extracts common session creation, workflow loading, cost tracking, and completion.
+     */
+    private executeSession;
+}
+
+/**
+ * Loads workflow YAML files, validates them, and resolves step dependencies
+ * into a topologically sorted execution order.
+ */
+declare class WorkflowEngine {
+    private workflowDir;
+    constructor(workflowDir: string);
+    /**
+     * Load a workflow YAML file by name, validate it, and resolve into a DAG.
+     */
+    load(workflowName: string): ResolvedWorkflow;
+    /**
+     * Returns the topologically sorted steps (already computed during load).
+     */
+    getExecutionOrder(workflow: ResolvedWorkflow): ResolvedStep[];
+    private validateDefinition;
+    private validateStep;
+    /**
+     * Resolve steps into topological order, validating input references and loops.
+     */
+    private resolveSteps;
+}
+
+type PolicyMode = 'warn' | 'enforce';
+type PolicyDecision = 'allow' | 'warn' | 'block';
+interface PolicyRule {
+    id: string;
+    when: string;
+    predicate: string;
+    threshold?: number;
+    action: 'warn' | 'block';
+    message: string;
+}
+interface PolicyContext {
+    criticalCount: number;
+    warningCount: number;
+    verdict: string;
+    stepsCompleted: Record<string, 'passed' | 'failed' | 'skipped'>;
+    cleanupHighCount: number;
+}
+interface PolicyResult {
+    decision: PolicyDecision;
+    violations: {
+        ruleId: string;
+        action: 'warn' | 'block';
+        message: string;
+    }[];
+}
+declare const DEFAULT_RULES: PolicyRule[];
+declare function evaluatePolicy(event: string, context: PolicyContext, rules: PolicyRule[], mode?: PolicyMode): PolicyResult;
+
+/** Token budget tiers for context assembly. */
+interface ContextBudget {
+    /** Max tokens for tier 1: task + memories. Default 2000 */
+    tier1: number;
+    /** Max tokens for tier 2: file tree + snippets. Default 4000 */
+    tier2: number;
+    /** Max total tokens for assembled context. Default 8000 */
+    total: number;
+}
+interface ContextBuilderOptions {
+    projectDir?: string;
+    projectId?: string;
+    memoryStore?: MemoryStore;
+    budget?: Partial<ContextBudget>;
+    /** Max depth for file tree traversal. Default 3 */
+    maxTreeDepth?: number;
+    /** Max number of files to include in tree. Default 200 */
+    maxFiles?: number;
+    /** File extensions to include in tree. Default: common code extensions */
+    includeExtensions?: string[];
+}
+interface AssembledContext {
+    /** The enriched prompt with context prepended */
+    prompt: string;
+    /** Memories that were injected */
+    memories: MemoryRecord[];
+    /** File tree summary (if generated) */
+    fileTree: string;
+    /** Estimated token count of the assembled context */
+    estimatedTokens: number;
+}
+/**
+ * Builds enriched prompts by assembling relevant context from:
+ * - Tier 1: Task framing + relevant memories from SQLite FTS
+ * - Tier 2: Project file tree + relevant code snippets
+ * - Tier 3: (Future) On-demand expansion when model requests more context
+ */
+declare class ContextBuilder {
+    private projectDir;
+    private projectId;
+    private memoryStore;
+    private budget;
+    private maxTreeDepth;
+    private maxFiles;
+    private includeExtensions;
+    constructor(options: ContextBuilderOptions);
+    /**
+     * Assemble enriched context for a model call.
+     * @param taskPrompt The original prompt/task
+     * @param taskType Context about what kind of task (review, debate, plan)
+     */
+    assemble(taskPrompt: string, taskType?: string): AssembledContext;
+    /** Query relevant memories using FTS5 search. */
+    private queryMemories;
+    /** Extract meaningful search terms from a prompt. */
+    private extractSearchTerms;
+    /** Format memories for injection into prompt. */
+    private formatMemories;
+    /** Build a compact file tree of the project, capped at maxFiles entries. */
+    buildFileTree(): string;
+    private walkDir;
+    private shouldIncludeFile;
+    /**
+     * Read a specific file's content within token budget.
+     * Useful for tier 3 on-demand context expansion.
+     */
+    readFileContent(filePath: string, maxChars?: number): string | null;
+}
+/** Command types with pre-defined output contracts. */
+type HandoffCommand = 'review' | 'debate' | 'build-review' | 'cleanup' | 'adjudicate' | 'custom';
+interface HandoffEnvelopeOptions {
+    /** The command being executed */
+    command: HandoffCommand;
+    /** The core task/instruction for GPT */
+    task: string;
+    /** Focus area or constraints */
+    constraints?: string[];
+    /** Whether this is a resumed session (GPT already has prior context) */
+    resumed: boolean;
+    /** Brief summary of what happened in prior turns (from session events) */
+    priorContext?: string;
+    /** Scope restriction (glob pattern) */
+    scope?: string;
+}
+/**
+ * Build a structured handoff envelope for Claude→GPT communication.
+ *
+ * Wraps any command's raw prompt with:
+ * 1. Codebase access preamble
+ * 2. Resume primer (when continuing a thread)
+ * 3. The core task
+ * 4. Constraints & scope
+ * 5. Output contract
+ */
+declare function buildHandoffEnvelope(options: HandoffEnvelopeOptions): string;
+
+declare function scanUnusedDeps(projectDir: string, ig?: Ignore): CleanupFinding[];
+declare function scanUnusedExports(projectDir: string, ig?: Ignore): CleanupFinding[];
+declare function scanHardcoded(projectDir: string, ig?: Ignore): CleanupFinding[];
+declare function scanDuplicates(projectDir: string, ig?: Ignore): CleanupFinding[];
+declare function scanDeadCode(projectDir: string, ig?: Ignore): CleanupFinding[];
+declare function scanSecurity(projectDir: string, ig?: Ignore): CleanupFinding[];
+declare function scanNearDuplicates(projectDir: string, ig?: Ignore): CleanupFinding[];
+declare function scanAntiPatterns(projectDir: string, ig?: Ignore): CleanupFinding[];
+declare function runAllScanners(projectDir: string, scopes: CleanupScope[], ig?: Ignore): CleanupFinding[];
+
+/**
+ * Merge findings from up to 3 sources: deterministic, semantic (codex), and host (Claude).
+ * Agreement rules:
+ * - All 3 agree → confidence: high
+ * - 2 of 3 agree → confidence: high (majority)
+ * - Only 1 found → original confidence preserved, disputed: true
+ */
+declare function mergeThreeWay(deterministic: CleanupFinding[], semantic: CleanupFinding[], host: CleanupFinding[]): CleanupFinding[];
+/**
+ * Compute stats from merged findings with 3-source tracking.
+ */
+declare function computeThreeWayStats(deterministic: CleanupFinding[], semantic: CleanupFinding[], host: CleanupFinding[], merged: CleanupFinding[]): CleanupReport['stats'];
+/**
+ * Legacy 2-way merge (deterministic + semantic only). Wraps mergeThreeWay with empty host.
+ */
+declare function mergeTwoWay(deterministic: CleanupFinding[], semantic: CleanupFinding[]): CleanupFinding[];
+/**
+ * Legacy 2-way stats. Wraps computeThreeWayStats with empty host.
+ */
+declare function computeTwoWayStats(deterministic: CleanupFinding[], semantic: CleanupFinding[], merged: CleanupFinding[]): CleanupReport['stats'];
+/**
+ * Recalculate stats after adjudication modifies findings in place.
+ * Note: `stats.adjudicated` is managed by the caller (incremented per adjudication).
+ */
+declare function recalculateConfidenceStats(findings: CleanupFinding[], stats: CleanupReport['stats']): void;
+
+declare const hostFindingSchema: z.ZodEffects<z.ZodObject<{
+    scope: z.ZodEnum<["deps", "unused-exports", "hardcoded", "duplicates", "deadcode"]>;
+    confidence: z.ZodEnum<["high", "medium", "low"]>;
+    file: z.ZodString;
+    line: z.ZodOptional<z.ZodNumber>;
+    symbol: z.ZodString;
+    description: z.ZodString;
+    recommendation: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    symbol: string;
+    scope: "deps" | "unused-exports" | "hardcoded" | "duplicates" | "deadcode";
+    description: string;
+    confidence: "high" | "medium" | "low";
+    file: string;
+    recommendation: string;
+    line?: number | undefined;
+}, {
+    symbol: string;
+    scope: "deps" | "unused-exports" | "hardcoded" | "duplicates" | "deadcode";
+    description: string;
+    confidence: "high" | "medium" | "low";
+    file: string;
+    recommendation: string;
+    line?: number | undefined;
+}>, {
+    symbol: string;
+    scope: "deps" | "unused-exports" | "hardcoded" | "duplicates" | "deadcode";
+    description: string;
+    confidence: "high" | "medium" | "low";
+    file: string;
+    recommendation: string;
+    line?: number | undefined;
+}, {
+    symbol: string;
+    scope: "deps" | "unused-exports" | "hardcoded" | "duplicates" | "deadcode";
+    description: string;
+    confidence: "high" | "medium" | "low";
+    file: string;
+    recommendation: string;
+    line?: number | undefined;
+}>;
+declare const hostFindingsSchema: z.ZodArray<z.ZodEffects<z.ZodObject<{
+    scope: z.ZodEnum<["deps", "unused-exports", "hardcoded", "duplicates", "deadcode"]>;
+    confidence: z.ZodEnum<["high", "medium", "low"]>;
+    file: z.ZodString;
+    line: z.ZodOptional<z.ZodNumber>;
+    symbol: z.ZodString;
+    description: z.ZodString;
+    recommendation: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    symbol: string;
+    scope: "deps" | "unused-exports" | "hardcoded" | "duplicates" | "deadcode";
+    description: string;
+    confidence: "high" | "medium" | "low";
+    file: string;
+    recommendation: string;
+    line?: number | undefined;
+}, {
+    symbol: string;
+    scope: "deps" | "unused-exports" | "hardcoded" | "duplicates" | "deadcode";
+    description: string;
+    confidence: "high" | "medium" | "low";
+    file: string;
+    recommendation: string;
+    line?: number | undefined;
+}>, {
+    symbol: string;
+    scope: "deps" | "unused-exports" | "hardcoded" | "duplicates" | "deadcode";
+    description: string;
+    confidence: "high" | "medium" | "low";
+    file: string;
+    recommendation: string;
+    line?: number | undefined;
+}, {
+    symbol: string;
+    scope: "deps" | "unused-exports" | "hardcoded" | "duplicates" | "deadcode";
+    description: string;
+    confidence: "high" | "medium" | "low";
+    file: string;
+    recommendation: string;
+    line?: number | undefined;
+}>, "many">;
+type HostFindingInput = z.infer<typeof hostFindingSchema>;
+
+interface RetryConfig {
+    maxRetries: number;
+    totalAttempts: number;
+    toolTimeoutMs: number;
+    onRetry?: (attempt: number, error: unknown, delayMs: number) => void;
+}
+interface AttemptResult<T> {
+    result?: T;
+    error?: Error;
+    attempts: number;
+    totalElapsedMs: number;
+}
+/**
+ * Check if an error represents an HTTP 5xx or retryable network error.
+ */
+declare function isRetryable(error: unknown): boolean;
+/**
+ * Check if an error represents an HTTP 429 rate limit.
+ */
+declare function isRateLimit(error: unknown): boolean;
+/**
+ * Execute fn with canonical retry policy:
+ * - totalAttempts <= 5 (absolute ceiling)
+ * - 5xx -> retry (up to maxRetries)
+ * - 429 -> wait-and-resume (parse Retry-After, clamp to 60s, progressive wait if missing)
+ * - 4xx (except 429) -> fail immediately
+ * - ETIMEDOUT, ECONNRESET, ECONNREFUSED -> retry
+ * - Backoff: min(1000 * 2^retryCount, 30000) + random jitter [0, 1000]ms
+ * - Timeout budget: if remaining < 5s, fail immediately
+ */
+declare function withCanonicalRetry<T>(fn: () => Promise<T>, config?: Partial<RetryConfig>): Promise<AttemptResult<T>>;
+
+type DlpMode = 'strict' | 'open';
+interface DlpRedaction {
+    stage: number;
+    reasonCode: DlpReasonCode;
+    original: string;
+    replacement: string;
+}
+interface DlpAuditEntry {
+    stage: number;
+    action: string;
+    detail: string;
+    timestamp: string;
+}
+interface DlpResult {
+    sanitized: string;
+    redactions: DlpRedaction[];
+    truncated: boolean;
+    auditLog: DlpAuditEntry[];
+}
+interface DlpConfig {
+    mode: DlpMode;
+    maxInputBytes: number;
+    maxProcessingMs: number;
+    maxRegexOps: number;
+    maxTokens: number;
+}
+declare const DEFAULT_DLP_CONFIG: DlpConfig;
+/**
+ * Sanitize input through the 6-stage DLP pipeline.
+ *
+ * Stages:
+ *   0: Decode — detect and skip base64/hex (budget-limited)
+ *   1: Secrets — regex scan for common secret patterns
+ *   2: Entropy — Shannon entropy check on long tokens (strict mode only)
+ *   3: Paths — convert absolute paths to relative
+ *   4: Context — truncate if exceeding token limit
+ *   5: Audit — finalize audit log
+ *
+ * Risk-tiered defaults:
+ *   review/debate tools -> strict mode (external content)
+ *   memory/cost tools -> open mode (local data, skip stages 1-2)
+ */
+declare function sanitize(input: string, config?: Partial<DlpConfig>): DlpResult;
+
+interface MuleProject {
+    name: string;
+    path: string;
+    relativePath: string;
+    muleVersion: string | null;
+    runtimeEdition: 'CE' | 'EE' | 'unknown';
+    hasMuleMavenPlugin: boolean;
+    connectors: ConnectorInfo[];
+    hasDataWeave: boolean;
+    hasMunitTests: boolean;
+    flowFiles: string[];
+    dataweaveFiles: string[];
+    propertiesFiles: string[];
+}
+interface ConnectorInfo {
+    groupId: string;
+    artifactId: string;
+    version: string;
+    type: string;
+}
+interface WorkspaceConfig {
+    name?: string;
+    projects?: Array<{
+        path: string;
+        name?: string;
+    }>;
+    shared?: {
+        properties?: string;
+        dataweave?: string;
+    };
+    ignore?: string[];
+}
+interface ProjectRegistry {
+    workspaceRoot: string;
+    projects: MuleProject[];
+    discoveredAt: string;
+    totalProjects: number;
+    totalFlowFiles: number;
+    totalDataweaveFiles: number;
+}
+declare class WorkspaceScanner {
+    private workspaceRoot;
+    private ignorePatterns;
+    constructor(workspaceRoot: string, ignorePatterns?: string[]);
+    scan(): ProjectRegistry;
+    private discoverProjects;
+    private scanDirectory;
+    private analyzeMuleProject;
+    private extractProjectName;
+    private extractMuleVersion;
+    private detectRuntimeEdition;
+    private extractConnectors;
+    private classifyConnector;
+    private findFiles;
+    private collectFiles;
+    private shouldIgnore;
+}
+
+interface ProjectMetadata {
+    projectName: string;
+    projectPath: string;
+    muleVersion: string | null;
+    runtimeEdition: string;
+    connectorCount: number;
+    flowCount: number;
+    dataweaveCount: number;
+    hasMunitTests: boolean;
+}
+declare class ProjectContext {
+    private project;
+    constructor(project: MuleProject);
+    getMetadata(): ProjectMetadata;
+    getConnectorSummary(): string;
+    toHandoffContext(): string;
+}
+
+interface DataWeaveFinding {
+    file: string;
+    line: number;
+    column: number;
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    rule: string;
+    message: string;
+    suggestion?: string;
+    codeSnippet?: string;
+}
+interface DataWeaveReport {
+    file: string;
+    findings: DataWeaveFinding[];
+    metrics: {
+        lineCount: number;
+        functionCount: number;
+        complexityScore: number;
+        hasNullSafetyIssues: boolean;
+        hasHardcodedValues: boolean;
+    };
+}
+declare class DataWeaveAnalyzer {
+    analyze(filePath: string): DataWeaveReport;
+    analyzeContent(filePath: string, content: string): DataWeaveReport;
+    private checkNullSafety;
+    private checkHardcodedValues;
+    private checkPerformancePatterns;
+    private checkErrorHandling;
+    private checkTypeAnnotations;
+    private countFunctions;
+    private calculateComplexity;
+}
+
+interface FlowStep {
+    type: string;
+    name?: string;
+    connectorType?: string;
+    hasErrorHandler: boolean;
+    children: FlowStep[];
+    attributes: Record<string, string>;
+    lineNumber: number;
+}
+interface FlowStructure {
+    name: string;
+    type: 'flow' | 'sub-flow' | 'error-handler';
+    steps: FlowStep[];
+    errorHandlers: FlowStep[];
+    connectorRefs: string[];
+    variableOps: string[];
+    lineNumber: number;
+}
+interface FlowComplexity {
+    file: string;
+    flows: FlowStructure[];
+    metrics: {
+        totalFlows: number;
+        totalSubFlows: number;
+        totalSteps: number;
+        maxNestingDepth: number;
+        averageStepsPerFlow: number;
+        errorHandlerCoverage: number;
+        connectorDiversity: number;
+        complexityScore: number;
+    };
+    findings: FlowFinding[];
+}
+interface FlowFinding {
+    file: string;
+    flowName: string;
+    line: number;
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    rule: string;
+    message: string;
+    suggestion?: string;
+}
+declare class FlowParser {
+    parse(filePath: string): FlowComplexity;
+    parseContent(filePath: string, content: string): FlowComplexity;
+    generateMermaid(complexity: FlowComplexity): string;
+    private analyzeFlow;
+    private calculateFlowComplexity;
+}
+
+interface ConnectorFinding {
+    project: string;
+    connector: string;
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    rule: string;
+    message: string;
+    suggestion?: string;
+}
+interface ConnectorAuditResult {
+    projects: string[];
+    findings: ConnectorFinding[];
+    versionMatrix: Map<string, Map<string, string>>;
+    metrics: {
+        totalConnectors: number;
+        uniqueConnectors: number;
+        versionConflicts: number;
+        securityIssues: number;
+        missingConfigs: number;
+    };
+}
+declare class ConnectorAuditor {
+    audit(projects: MuleProject[]): ConnectorAuditResult;
+    private checkConnectorConfigs;
+    private checkSecuritySettings;
+    private checkMissingTimeouts;
+}
+
+interface ScenarioStep {
+    name: string;
+    flow?: string;
+    input?: Record<string, unknown>;
+    expectedOutput?: Record<string, unknown>;
+    expectedStatus?: number;
+    connectors?: string[];
+    description?: string;
+}
+interface ScenarioDefinition {
+    name: string;
+    description: string;
+    project?: string;
+    steps: ScenarioStep[];
+    dependencies?: string[];
+    successCriteria?: string[];
+    errorConditions?: string[];
+}
+type ValidationTier = 'spec-compliance' | 'documentation' | 'feasibility';
+interface TierResult {
+    tier: ValidationTier;
+    status: 'pass' | 'partial' | 'blocked';
+    findings: TierFinding[];
+}
+interface TierFinding {
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    message: string;
+    suggestion?: string;
+    reference?: string;
+}
+interface ValidationResult {
+    scenario: string;
+    verdict: 'PASS' | 'PARTIAL' | 'BLOCKED';
+    tiers: TierResult[];
+    summary: string;
+    actionItems: string[];
+}
+declare class ScenarioValidator {
+    private projects;
+    constructor(projects: MuleProject[]);
+    validate(scenario: ScenarioDefinition): ValidationResult;
+    validateTier(scenario: ScenarioDefinition, tier: ValidationTier): TierResult;
+    private validateSpecCompliance;
+    private validateDocumentationCoverage;
+    private validateFeasibility;
+    private findProject;
+    private checkFlowExists;
+    private calculateVerdict;
+    private generateActionItems;
+    private generateSummary;
+}
+
+declare const VERSION = "0.2.14";
+
+export { type ArtifactRecord, ArtifactStore, type ArtifactType, type AssembledContext, type AttemptResult, BINARY_SNIFF_BYTES, type BridgeCapabilities, type BridgeOptions, type BridgeResumeOptions, type BudgetConfig, type BuildPhase, type BuildRun, BuildStore, type BuildSummary, type BuiltInRole, CLEANUP_TIMEOUT_SEC, CONTEXT_ACTIVE, CONTEXT_BUFFER, CONTEXT_RETRIEVED, CURRENT_VERSION, type CacheEntry, CacheStore, type CallModelOptions, CancellationError, CancellationToken, type ChatMessage, type CleanupConfidence, type CleanupFinding, type CleanupReport, type CleanupScope, type CleanupSource, CliAdapter, type CliAdapterConfig, type CliBridge, type CliCallOptions, type CliDetectionResult, ConfigError, type ConnectorAuditResult, ConnectorAuditor, type ConnectorFinding, type ConnectorInfo, type ContextBudget, ContextBuilder, type ContextBuilderOptions, type CostInput, type CostLogEntry, CostStore, type CostSummary, CostTracker, type CostUpdateEvent, DAYS_PER_YEAR, DEFAULT_CONFIG, DEFAULT_DLP_CONFIG, DEFAULT_MAX_TOKENS, DEFAULT_RULES, DEFAULT_TIMEOUT_SEC, DLP_MAX_CONTENT, DLP_MAX_PROCESSING_MS, DataWeaveAnalyzer, type DataWeaveFinding, type DataWeaveReport, DatabaseError, type DebateConfig, type DebateEngineState, type DebateInput, type DebateMessageRow, type DebateOptions, type DebatePattern, type DebateResponse, type DebateResult, DebateStore, type DebateTurnRow, type DebateTurnStatus, type DlpAuditEntry, type DlpConfig, type DlpMode, DlpReasonCode, type DlpRedaction, type DlpResult, type EngineEvent, type EnqueueOptions, ErrorCode, EventBus, type ExecutionMode, type FallbackConfig, type FlowComplexity, type FlowFinding, FlowParser, type FlowStep, type FlowStructure, HTTP_TOO_MANY_REQUESTS, type HandoffCommand, type HandoffEnvelopeOptions, type HostFindingInput, IMPLEMENTER_MAX_TOKENS, type JobLogRecord, type JobRecord, type JobStatus, JobStore, type JobType, type LogLevel, type Logger, type LoopConfig, LoopController, type LoopIterationEvent, type LoopResult, MCP_CONTENT_MAX_LENGTH, MCP_TASK_MAX_LENGTH, MCP_TIMEOUT_MAX, type MemoryCategory, type MemoryConfig, type MemoryInput, type MemoryRecord, MemoryStore, type MessageStatus, MessageStore, type MeteringSource, type ModelAdapter, type ModelCallResult, type ModelConfig, ModelError, type ModelPricing, type ModelProvider, ModelRegistry, type MuleProject, Orchestrator, type OrchestratorOptions, type OutputConfig, type ParsedVerdict, type PlanInput, type PlanOptions, type PolicyContext, type PolicyDecision, type PolicyMode, type PolicyResult, type PolicyRule, type PresetName, type ProgressCallbacks, type ProjectConfig, type ProjectConfigInput, ProjectContext, type ProjectMetadata, type ProjectRegistry, type PromptType, type PromptVariables, REVIEW_DIFF_MAX_CHARS, REVIEW_PRESETS, REVIEW_TEXT_MAX_CHARS, type ResolvedStep, type ResolvedWorkflow, type ResultStatus, type RetryConfig, type RetryOptions, type ReviewInput, type ReviewOptions, type ReviewPreset, type ReviewResult, type Role, type RoleConfig, RoleManager, type RunOptions, type ScenarioDefinition, type ScenarioStep, ScenarioValidator, type Session, type SessionCompletedEvent, type SessionEvent, type SessionFailedEvent, SessionManager, type SessionResult, type SessionStartedEvent, type SessionStatus, SessionStore, type StepCompletedEvent, type StepDefinition, type StepFailedEvent, type StepResult, StepRunner, type StepStartedEvent, type StepType, TerminalReason, type TextDeltaEmitter, type TextDeltaEvent, type TextDoneEvent, type TierFinding, type TierResult, type TokenUsage, type TranscriptEntry, type UnifiedSession, VERSION, type ValidationResult, type ValidationTier, type VerdictResult, type WorkflowDefinition, WorkflowEngine, WorkflowError, type WorkspaceConfig, WorkspaceScanner, buildHandoffEnvelope, buildReconstructionPrompt, calculateCost, calculateDebateTokens, callModel, clearDetectionCache, computeThreeWayStats, computeTwoWayStats, costInputSchema, createIgnoreFilter, createLogger, debateInputSchema, debateOutputSchema, detectCli, estimateTokens, evaluatePolicy, generateId, generateSessionId, getModelPricing, getReviewPreset, getSchemaVersion, getTokenBudgetStatus, hashConfig, hashContent, hostFindingsSchema, isRateLimit, isRetryable, listPresetNames, listPresets, loadConfig, loadIgnorePatterns, loadPreset, memoryInputSchema, mergeThreeWay, mergeTwoWay, migrateConfig, openDatabase, parseDebateVerdict, parseVerdict, planInputSchema, preflightTokenCheck, projectConfigSchema, recalculateConfidenceStats, renderPrompt, reviewInputSchema, reviewOutputSchema, runAllScanners, runMigrations, sanitize, scanAntiPatterns, scanDeadCode, scanDuplicates, scanHardcoded, scanNearDuplicates, scanSecurity, scanUnusedDeps, scanUnusedExports, shouldIgnore, sleep, streamModel, validateConfig, withCanonicalRetry, withFallback, withRetry, writeConfig };