@interf/compiler 0.7.3 → 0.9.3

package/dist/packages/execution/lib/schema.d.ts

@@ -0,0 +1,1551 @@
+import { z } from "zod";
+export declare const MethodTraceRunStatusSchema: z.ZodEnum<{
+    failed: "failed";
+    running: "running";
+    pending: "pending";
+    completed: "completed";
+    cancelled: "cancelled";
+}>;
+export declare const MethodTraceEventTypeSchema: z.ZodEnum<{
+    run_created: "run_created";
+    run_started: "run_started";
+    run_completed: "run_completed";
+    run_failed: "run_failed";
+    run_cancelled: "run_cancelled";
+    step_created: "step_created";
+    step_started: "step_started";
+    step_completed: "step_completed";
+    step_failed: "step_failed";
+    step_retrying: "step_retrying";
+    hook_created: "hook_created";
+    hook_received: "hook_received";
+    hook_disposed: "hook_disposed";
+    hook_conflict: "hook_conflict";
+    wait_created: "wait_created";
+    wait_completed: "wait_completed";
+}>;
+export declare const MethodTraceStructuredErrorSchema: z.ZodObject<{
+    message: z.ZodString;
+    stack: z.ZodOptional<z.ZodString>;
+    code: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const MethodTraceRunSchema: z.ZodObject<{
+    runId: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        running: "running";
+        pending: "pending";
+        completed: "completed";
+        cancelled: "cancelled";
+    }>;
+    deploymentId: z.ZodString;
+    methodName: z.ZodString;
+    specVersion: z.ZodLiteral<1>;
+    executionContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    input: z.ZodUnknown;
+    output: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        stack: z.ZodOptional<z.ZodString>;
+        code: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    expiredAt: z.ZodOptional<z.ZodString>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    completedAt: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strict>;
+export declare const MethodTraceEventSchema: z.ZodObject<{
+    runId: z.ZodString;
+    eventId: z.ZodString;
+    eventType: z.ZodEnum<{
+        run_created: "run_created";
+        run_started: "run_started";
+        run_completed: "run_completed";
+        run_failed: "run_failed";
+        run_cancelled: "run_cancelled";
+        step_created: "step_created";
+        step_started: "step_started";
+        step_completed: "step_completed";
+        step_failed: "step_failed";
+        step_retrying: "step_retrying";
+        hook_created: "hook_created";
+        hook_received: "hook_received";
+        hook_disposed: "hook_disposed";
+        hook_conflict: "hook_conflict";
+        wait_created: "wait_created";
+        wait_completed: "wait_completed";
+    }>;
+    correlationId: z.ZodOptional<z.ZodString>;
+    specVersion: z.ZodLiteral<1>;
+    createdAt: z.ZodString;
+    eventData: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>;
+export declare const MethodTraceStreamChunkSchema: z.ZodObject<{
+    streamId: z.ZodString;
+    chunkId: z.ZodString;
+    index: z.ZodNumber;
+    createdAt: z.ZodString;
+    text: z.ZodString;
+    data: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>;
+export declare const MethodTraceSchema: z.ZodObject<{
+    run: z.ZodObject<{
+        runId: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            running: "running";
+            pending: "pending";
+            completed: "completed";
+            cancelled: "cancelled";
+        }>;
+        deploymentId: z.ZodString;
+        methodName: z.ZodString;
+        specVersion: z.ZodLiteral<1>;
+        executionContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        input: z.ZodUnknown;
+        output: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodObject<{
+            message: z.ZodString;
+            stack: z.ZodOptional<z.ZodString>;
+            code: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        expiredAt: z.ZodOptional<z.ZodString>;
+        startedAt: z.ZodOptional<z.ZodString>;
+        completedAt: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>;
+    events: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        runId: z.ZodString;
+        eventId: z.ZodString;
+        eventType: z.ZodEnum<{
+            run_created: "run_created";
+            run_started: "run_started";
+            run_completed: "run_completed";
+            run_failed: "run_failed";
+            run_cancelled: "run_cancelled";
+            step_created: "step_created";
+            step_started: "step_started";
+            step_completed: "step_completed";
+            step_failed: "step_failed";
+            step_retrying: "step_retrying";
+            hook_created: "hook_created";
+            hook_received: "hook_received";
+            hook_disposed: "hook_disposed";
+            hook_conflict: "hook_conflict";
+            wait_created: "wait_created";
+            wait_completed: "wait_completed";
+        }>;
+        correlationId: z.ZodOptional<z.ZodString>;
+        specVersion: z.ZodLiteral<1>;
+        createdAt: z.ZodString;
+        eventData: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>>>;
+    streams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        streamId: z.ZodString;
+        chunkId: z.ZodString;
+        index: z.ZodNumber;
+        createdAt: z.ZodString;
+        text: z.ZodString;
+        data: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const ObservableRunTypeSchema: z.ZodEnum<{
+    compile: "compile";
+    "method-authoring": "method-authoring";
+    "method-improvement": "method-improvement";
+    "preparation-setup": "preparation-setup";
+    test: "test";
+    "readiness-check-draft": "readiness-check-draft";
+    job: "job";
+}>;
+export declare const ObservableRunStatusSchema: z.ZodEnum<{
+    failed: "failed";
+    running: "running";
+    succeeded: "succeeded";
+    cancelled: "cancelled";
+    queued: "queued";
+}>;
+export declare const ObservableRunMetricSchema: z.ZodObject<{
+    label: z.ZodString;
+    value: z.ZodString;
+    detail: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const ExecutionBackendKindSchema: z.ZodEnum<{
+    native: "native";
+    "workflow-sdk": "workflow-sdk";
+}>;
+export declare const CompileRunStatusSchema: z.ZodEnum<{
+    failed: "failed";
+    running: "running";
+    succeeded: "succeeded";
+    cancelled: "cancelled";
+    queued: "queued";
+}>;
+export declare const StageRunStatusSchema: z.ZodEnum<{
+    failed: "failed";
+    running: "running";
+    succeeded: "succeeded";
+    queued: "queued";
+}>;
+export declare const ArtifactRoleSchema: z.ZodEnum<{
+    output: "output";
+    runtime: "runtime";
+    source: "source";
+    test: "test";
+    proof: "proof";
+}>;
+export declare const ArtifactRefSchema: z.ZodObject<{
+    path: z.ZodString;
+    role: z.ZodEnum<{
+        output: "output";
+        runtime: "runtime";
+        source: "source";
+        test: "test";
+        proof: "proof";
+    }>;
+    stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    label: z.ZodOptional<z.ZodString>;
+    sha256: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const ProofCheckSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    ok: z.ZodBoolean;
+    detail: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const RunObservabilitySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-run-observability">;
+    version: z.ZodLiteral<1>;
+    run_id: z.ZodString;
+    run_type: z.ZodEnum<{
+        compile: "compile";
+        "method-authoring": "method-authoring";
+        "method-improvement": "method-improvement";
+        "preparation-setup": "preparation-setup";
+        test: "test";
+        "readiness-check-draft": "readiness-check-draft";
+        job: "job";
+    }>;
+    title: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        running: "running";
+        succeeded: "succeeded";
+        cancelled: "cancelled";
+        queued: "queued";
+    }>;
+    preparation: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    method: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    source_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    output_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    executor: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            "local-agent": "local-agent";
+            "connected-provider": "connected-provider";
+            managed: "managed";
+        }>;
+        name: z.ZodString;
+        display_name: z.ZodString;
+        command: z.ZodNullable<z.ZodString>;
+        model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        effort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        profile: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        timeout_ms: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>>>;
+    agent_label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    created_at: z.ZodString;
+    started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    finished_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    metrics: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodString;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        role: z.ZodEnum<{
+            output: "output";
+            runtime: "runtime";
+            source: "source";
+            test: "test";
+            proof: "proof";
+        }>;
+        stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        label: z.ZodOptional<z.ZodString>;
+        sha256: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    proof: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        ok: z.ZodBoolean;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    readiness: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        kind: z.ZodLiteral<"interf-readiness-state">;
+        version: z.ZodLiteral<1>;
+        generated_at: z.ZodString;
+        preparation: z.ZodString;
+        status: z.ZodEnum<{
+            "not-configured": "not-configured";
+            "not-built": "not-built";
+            building: "building";
+            built: "built";
+            checking: "checking";
+            ready: "ready";
+            "not-ready": "not-ready";
+            stale: "stale";
+            failed: "failed";
+        }>;
+        ready: z.ZodBoolean;
+        summary: z.ZodString;
+        portable_context_path: z.ZodNullable<z.ZodString>;
+        latest_compile_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        latest_test_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        compile: z.ZodNullable<z.ZodObject<{
+            gate: z.ZodEnum<{
+                "preparation-config": "preparation-config";
+                "portable-context": "portable-context";
+                "compile-run": "compile-run";
+                "readiness-checks": "readiness-checks";
+                "source-baseline": "source-baseline";
+                "portable-context-check": "portable-context-check";
+                "checks-current": "checks-current";
+            }>;
+            ok: z.ZodBoolean;
+            status: z.ZodOptional<z.ZodEnum<{
+                "not-configured": "not-configured";
+                "not-built": "not-built";
+                building: "building";
+                built: "built";
+                checking: "checking";
+                ready: "ready";
+                "not-ready": "not-ready";
+                stale: "stale";
+                failed: "failed";
+            }>>;
+            summary: z.ZodString;
+            detail: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            artifact_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>;
+        check_results: z.ZodObject<{
+            configured: z.ZodNumber;
+            fingerprint: z.ZodNullable<z.ZodString>;
+            source_files: z.ZodNullable<z.ZodObject<{
+                passed: z.ZodNumber;
+                total: z.ZodNumber;
+                pass_rate: z.ZodNullable<z.ZodNumber>;
+                checks_fingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                stale: z.ZodDefault<z.ZodBoolean>;
+                run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>>;
+            portable_context: z.ZodNullable<z.ZodObject<{
+                passed: z.ZodNumber;
+                total: z.ZodNumber;
+                pass_rate: z.ZodNullable<z.ZodNumber>;
+                checks_fingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                stale: z.ZodDefault<z.ZodBoolean>;
+                run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>>;
+            delta: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+        checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            gate: z.ZodEnum<{
+                "preparation-config": "preparation-config";
+                "portable-context": "portable-context";
+                "compile-run": "compile-run";
+                "readiness-checks": "readiness-checks";
+                "source-baseline": "source-baseline";
+                "portable-context-check": "portable-context-check";
+                "checks-current": "checks-current";
+            }>;
+            ok: z.ZodBoolean;
+            status: z.ZodOptional<z.ZodEnum<{
+                "not-configured": "not-configured";
+                "not-built": "not-built";
+                building: "building";
+                built: "built";
+                checking: "checking";
+                ready: "ready";
+                "not-ready": "not-ready";
+                stale: "stale";
+                failed: "failed";
+            }>>;
+            summary: z.ZodString;
+            detail: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            artifact_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+    trace: z.ZodObject<{
+        run: z.ZodObject<{
+            runId: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                running: "running";
+                pending: "pending";
+                completed: "completed";
+                cancelled: "cancelled";
+            }>;
+            deploymentId: z.ZodString;
+            methodName: z.ZodString;
+            specVersion: z.ZodLiteral<1>;
+            executionContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            input: z.ZodUnknown;
+            output: z.ZodOptional<z.ZodUnknown>;
+            error: z.ZodOptional<z.ZodObject<{
+                message: z.ZodString;
+                stack: z.ZodOptional<z.ZodString>;
+                code: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            expiredAt: z.ZodOptional<z.ZodString>;
+            startedAt: z.ZodOptional<z.ZodString>;
+            completedAt: z.ZodOptional<z.ZodString>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+        }, z.core.$strict>;
+        events: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            runId: z.ZodString;
+            eventId: z.ZodString;
+            eventType: z.ZodEnum<{
+                run_created: "run_created";
+                run_started: "run_started";
+                run_completed: "run_completed";
+                run_failed: "run_failed";
+                run_cancelled: "run_cancelled";
+                step_created: "step_created";
+                step_started: "step_started";
+                step_completed: "step_completed";
+                step_failed: "step_failed";
+                step_retrying: "step_retrying";
+                hook_created: "hook_created";
+                hook_received: "hook_received";
+                hook_disposed: "hook_disposed";
+                hook_conflict: "hook_conflict";
+                wait_created: "wait_created";
+                wait_completed: "wait_completed";
+            }>;
+            correlationId: z.ZodOptional<z.ZodString>;
+            specVersion: z.ZodLiteral<1>;
+            createdAt: z.ZodString;
+            eventData: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strict>>>;
+        streams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            streamId: z.ZodString;
+            chunkId: z.ZodString;
+            index: z.ZodNumber;
+            createdAt: z.ZodString;
+            text: z.ZodString;
+            data: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ProofRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    run_id: z.ZodString;
+    stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    generated_at: z.ZodString;
+    summary: z.ZodString;
+    files_processed: z.ZodOptional<z.ZodNumber>;
+    artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        role: z.ZodEnum<{
+            output: "output";
+            runtime: "runtime";
+            source: "source";
+            test: "test";
+            proof: "proof";
+        }>;
+        stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        label: z.ZodOptional<z.ZodString>;
+        sha256: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        ok: z.ZodBoolean;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const StageRunContractSchema: z.ZodObject<{
+    stage_label: z.ZodOptional<z.ZodString>;
+    stage_index: z.ZodOptional<z.ZodNumber>;
+    stage_total: z.ZodOptional<z.ZodNumber>;
+    reads: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    writes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    acceptance: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export declare const StageRunLogsSchema: z.ZodObject<{
+    prompt_path: z.ZodOptional<z.ZodString>;
+    event_stream_path: z.ZodOptional<z.ZodString>;
+    status_path: z.ZodOptional<z.ZodString>;
+    contract_path: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const RunStartedEventSchema: z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"run.started">;
+    preparation: z.ZodString;
+    method: z.ZodString;
+    portable_context_path: z.ZodString;
+    backend: z.ZodEnum<{
+        native: "native";
+        "workflow-sdk": "workflow-sdk";
+    }>;
+}, z.core.$strict>;
+export declare const StageStartedEventSchema: z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"stage.started">;
+    stage_id: z.ZodString;
+    stage_index: z.ZodOptional<z.ZodNumber>;
+    stage_total: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const FileProcessedEventSchema: z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"file.processed">;
+    stage_id: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strict>;
+export declare const ArtifactWrittenEventSchema: z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"artifact.written">;
+    stage_id: z.ZodString;
+    artifact: z.ZodObject<{
+        path: z.ZodString;
+        role: z.ZodEnum<{
+            output: "output";
+            runtime: "runtime";
+            source: "source";
+            test: "test";
+            proof: "proof";
+        }>;
+        stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        label: z.ZodOptional<z.ZodString>;
+        sha256: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ProofUpdatedEventSchema: z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"proof.updated">;
+    stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    proof: z.ZodObject<{
+        id: z.ZodString;
+        run_id: z.ZodString;
+        stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        generated_at: z.ZodString;
+        summary: z.ZodString;
+        files_processed: z.ZodOptional<z.ZodNumber>;
+        artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            role: z.ZodEnum<{
+                output: "output";
+                runtime: "runtime";
+                source: "source";
+                test: "test";
+                proof: "proof";
+            }>;
+            stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            label: z.ZodOptional<z.ZodString>;
+            sha256: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            ok: z.ZodBoolean;
+            detail: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const LogAppendedEventSchema: z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"log.appended">;
+    stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    stream: z.ZodEnum<{
+        status: "status";
+        trace: "trace";
+        system: "system";
+    }>;
+    message: z.ZodString;
+}, z.core.$strict>;
+export declare const StagePassedEventSchema: z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"stage.passed">;
+    stage_id: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const StageFailedEventSchema: z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"stage.failed">;
+    stage_id: z.ZodString;
+    error: z.ZodString;
+}, z.core.$strict>;
+export declare const RunCompletedEventSchema: z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"run.completed">;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const RunFailedEventSchema: z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"run.failed">;
+    error: z.ZodString;
+}, z.core.$strict>;
+export declare const ChecksEvaluatedEventSchema: z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"checks.evaluated">;
+    passed: z.ZodNumber;
+    total: z.ZodNumber;
+    target: z.ZodOptional<z.ZodEnum<{
+        compiled: "compiled";
+        raw: "raw";
+    }>>;
+    checks_fingerprint: z.ZodOptional<z.ZodString>;
+    stale: z.ZodOptional<z.ZodBoolean>;
+    test_run_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const ReadinessUpdatedEventSchema: z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"readiness.updated">;
+    preparation: z.ZodString;
+    readiness: z.ZodObject<{
+        kind: z.ZodLiteral<"interf-readiness-state">;
+        version: z.ZodLiteral<1>;
+        generated_at: z.ZodString;
+        preparation: z.ZodString;
+        status: z.ZodEnum<{
+            "not-configured": "not-configured";
+            "not-built": "not-built";
+            building: "building";
+            built: "built";
+            checking: "checking";
+            ready: "ready";
+            "not-ready": "not-ready";
+            stale: "stale";
+            failed: "failed";
+        }>;
+        ready: z.ZodBoolean;
+        summary: z.ZodString;
+        portable_context_path: z.ZodNullable<z.ZodString>;
+        latest_compile_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        latest_test_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        compile: z.ZodNullable<z.ZodObject<{
+            gate: z.ZodEnum<{
+                "preparation-config": "preparation-config";
+                "portable-context": "portable-context";
+                "compile-run": "compile-run";
+                "readiness-checks": "readiness-checks";
+                "source-baseline": "source-baseline";
+                "portable-context-check": "portable-context-check";
+                "checks-current": "checks-current";
+            }>;
+            ok: z.ZodBoolean;
+            status: z.ZodOptional<z.ZodEnum<{
+                "not-configured": "not-configured";
+                "not-built": "not-built";
+                building: "building";
+                built: "built";
+                checking: "checking";
+                ready: "ready";
+                "not-ready": "not-ready";
+                stale: "stale";
+                failed: "failed";
+            }>>;
+            summary: z.ZodString;
+            detail: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            artifact_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>;
+        check_results: z.ZodObject<{
+            configured: z.ZodNumber;
+            fingerprint: z.ZodNullable<z.ZodString>;
+            source_files: z.ZodNullable<z.ZodObject<{
+                passed: z.ZodNumber;
+                total: z.ZodNumber;
+                pass_rate: z.ZodNullable<z.ZodNumber>;
+                checks_fingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                stale: z.ZodDefault<z.ZodBoolean>;
+                run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>>;
+            portable_context: z.ZodNullable<z.ZodObject<{
+                passed: z.ZodNumber;
+                total: z.ZodNumber;
+                pass_rate: z.ZodNullable<z.ZodNumber>;
+                checks_fingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                stale: z.ZodDefault<z.ZodBoolean>;
+                run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>>;
+            delta: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+        checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            gate: z.ZodEnum<{
+                "preparation-config": "preparation-config";
+                "portable-context": "portable-context";
+                "compile-run": "compile-run";
+                "readiness-checks": "readiness-checks";
+                "source-baseline": "source-baseline";
+                "portable-context-check": "portable-context-check";
+                "checks-current": "checks-current";
+            }>;
+            ok: z.ZodBoolean;
+            status: z.ZodOptional<z.ZodEnum<{
+                "not-configured": "not-configured";
+                "not-built": "not-built";
+                building: "building";
+                built: "built";
+                checking: "checking";
+                ready: "ready";
+                "not-ready": "not-ready";
+                stale: "stale";
+                failed: "failed";
+            }>>;
+            summary: z.ZodString;
+            detail: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            artifact_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const InterfRunEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"run.started">;
+    preparation: z.ZodString;
+    method: z.ZodString;
+    portable_context_path: z.ZodString;
+    backend: z.ZodEnum<{
+        native: "native";
+        "workflow-sdk": "workflow-sdk";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"stage.started">;
+    stage_id: z.ZodString;
+    stage_index: z.ZodOptional<z.ZodNumber>;
+    stage_total: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"file.processed">;
+    stage_id: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"artifact.written">;
+    stage_id: z.ZodString;
+    artifact: z.ZodObject<{
+        path: z.ZodString;
+        role: z.ZodEnum<{
+            output: "output";
+            runtime: "runtime";
+            source: "source";
+            test: "test";
+            proof: "proof";
+        }>;
+        stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        label: z.ZodOptional<z.ZodString>;
+        sha256: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"proof.updated">;
+    stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    proof: z.ZodObject<{
+        id: z.ZodString;
+        run_id: z.ZodString;
+        stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        generated_at: z.ZodString;
+        summary: z.ZodString;
+        files_processed: z.ZodOptional<z.ZodNumber>;
+        artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            role: z.ZodEnum<{
+                output: "output";
+                runtime: "runtime";
+                source: "source";
+                test: "test";
+                proof: "proof";
+            }>;
+            stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            label: z.ZodOptional<z.ZodString>;
+            sha256: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            ok: z.ZodBoolean;
+            detail: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"log.appended">;
+    stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    stream: z.ZodEnum<{
+        status: "status";
+        trace: "trace";
+        system: "system";
+    }>;
+    message: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"stage.passed">;
+    stage_id: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"stage.failed">;
+    stage_id: z.ZodString;
+    error: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"run.completed">;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"run.failed">;
+    error: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"checks.evaluated">;
+    passed: z.ZodNumber;
+    total: z.ZodNumber;
+    target: z.ZodOptional<z.ZodEnum<{
+        compiled: "compiled";
+        raw: "raw";
+    }>>;
+    checks_fingerprint: z.ZodOptional<z.ZodString>;
+    stale: z.ZodOptional<z.ZodBoolean>;
+    test_run_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    event_id: z.ZodString;
+    run_id: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodLiteral<"readiness.updated">;
+    preparation: z.ZodString;
+    readiness: z.ZodObject<{
+        kind: z.ZodLiteral<"interf-readiness-state">;
+        version: z.ZodLiteral<1>;
+        generated_at: z.ZodString;
+        preparation: z.ZodString;
+        status: z.ZodEnum<{
+            "not-configured": "not-configured";
+            "not-built": "not-built";
+            building: "building";
+            built: "built";
+            checking: "checking";
+            ready: "ready";
+            "not-ready": "not-ready";
+            stale: "stale";
+            failed: "failed";
+        }>;
+        ready: z.ZodBoolean;
+        summary: z.ZodString;
+        portable_context_path: z.ZodNullable<z.ZodString>;
+        latest_compile_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        latest_test_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        compile: z.ZodNullable<z.ZodObject<{
+            gate: z.ZodEnum<{
+                "preparation-config": "preparation-config";
+                "portable-context": "portable-context";
+                "compile-run": "compile-run";
+                "readiness-checks": "readiness-checks";
+                "source-baseline": "source-baseline";
+                "portable-context-check": "portable-context-check";
+                "checks-current": "checks-current";
+            }>;
+            ok: z.ZodBoolean;
+            status: z.ZodOptional<z.ZodEnum<{
+                "not-configured": "not-configured";
+                "not-built": "not-built";
+                building: "building";
+                built: "built";
+                checking: "checking";
+                ready: "ready";
+                "not-ready": "not-ready";
+                stale: "stale";
+                failed: "failed";
+            }>>;
+            summary: z.ZodString;
+            detail: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            artifact_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>;
+        check_results: z.ZodObject<{
+            configured: z.ZodNumber;
+            fingerprint: z.ZodNullable<z.ZodString>;
+            source_files: z.ZodNullable<z.ZodObject<{
+                passed: z.ZodNumber;
+                total: z.ZodNumber;
+                pass_rate: z.ZodNullable<z.ZodNumber>;
+                checks_fingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                stale: z.ZodDefault<z.ZodBoolean>;
+                run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>>;
+            portable_context: z.ZodNullable<z.ZodObject<{
+                passed: z.ZodNumber;
+                total: z.ZodNumber;
+                pass_rate: z.ZodNullable<z.ZodNumber>;
+                checks_fingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                stale: z.ZodDefault<z.ZodBoolean>;
+                run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>>;
+            delta: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+        checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            gate: z.ZodEnum<{
+                "preparation-config": "preparation-config";
+                "portable-context": "portable-context";
+                "compile-run": "compile-run";
+                "readiness-checks": "readiness-checks";
+                "source-baseline": "source-baseline";
+                "portable-context-check": "portable-context-check";
+                "checks-current": "checks-current";
+            }>;
+            ok: z.ZodBoolean;
+            status: z.ZodOptional<z.ZodEnum<{
+                "not-configured": "not-configured";
+                "not-built": "not-built";
+                building: "building";
+                built: "built";
+                checking: "checking";
+                ready: "ready";
+                "not-ready": "not-ready";
+                stale: "stale";
+                failed: "failed";
+            }>>;
+            summary: z.ZodString;
+            detail: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            artifact_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "type">;
+export declare const StageRunSchema: z.ZodObject<{
+    run_id: z.ZodString;
+    stage_id: z.ZodString;
+    stage_label: z.ZodOptional<z.ZodString>;
+    stage_index: z.ZodOptional<z.ZodNumber>;
+    stage_total: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodEnum<{
+        failed: "failed";
+        running: "running";
+        succeeded: "succeeded";
+        queued: "queued";
+    }>;
+    started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    finished_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    summary: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    contract: z.ZodOptional<z.ZodObject<{
+        stage_label: z.ZodOptional<z.ZodString>;
+        stage_index: z.ZodOptional<z.ZodNumber>;
+        stage_total: z.ZodOptional<z.ZodNumber>;
+        reads: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        writes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        acceptance: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+    executor: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            "local-agent": "local-agent";
+            "connected-provider": "connected-provider";
+            managed: "managed";
+        }>;
+        name: z.ZodString;
+        display_name: z.ZodString;
+        command: z.ZodNullable<z.ZodString>;
+        model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        effort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        profile: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        timeout_ms: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>>>;
+    artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        role: z.ZodEnum<{
+            output: "output";
+            runtime: "runtime";
+            source: "source";
+            test: "test";
+            proof: "proof";
+        }>;
+        stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        label: z.ZodOptional<z.ZodString>;
+        sha256: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    logs: z.ZodOptional<z.ZodObject<{
+        prompt_path: z.ZodOptional<z.ZodString>;
+        event_stream_path: z.ZodOptional<z.ZodString>;
+        status_path: z.ZodOptional<z.ZodString>;
+        contract_path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    latest_proof: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        run_id: z.ZodString;
+        stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        generated_at: z.ZodString;
+        summary: z.ZodString;
+        files_processed: z.ZodOptional<z.ZodNumber>;
+        artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            role: z.ZodEnum<{
+                output: "output";
+                runtime: "runtime";
+                source: "source";
+                test: "test";
+                proof: "proof";
+            }>;
+            stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            label: z.ZodOptional<z.ZodString>;
+            sha256: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            ok: z.ZodBoolean;
+            detail: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+    failure: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export declare const CompileRunSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-compile-run">;
+    version: z.ZodLiteral<1>;
+    run_id: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        running: "running";
+        succeeded: "succeeded";
+        cancelled: "cancelled";
+        queued: "queued";
+    }>;
+    preparation: z.ZodString;
+    method: z.ZodString;
+    backend: z.ZodEnum<{
+        native: "native";
+        "workflow-sdk": "workflow-sdk";
+    }>;
+    source_path: z.ZodString;
+    portable_context_path: z.ZodString;
+    created_at: z.ZodString;
+    started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    finished_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    stages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        run_id: z.ZodString;
+        stage_id: z.ZodString;
+        stage_label: z.ZodOptional<z.ZodString>;
+        stage_index: z.ZodOptional<z.ZodNumber>;
+        stage_total: z.ZodOptional<z.ZodNumber>;
+        status: z.ZodEnum<{
+            failed: "failed";
+            running: "running";
+            succeeded: "succeeded";
+            queued: "queued";
+        }>;
+        started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        finished_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        summary: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        contract: z.ZodOptional<z.ZodObject<{
+            stage_label: z.ZodOptional<z.ZodString>;
+            stage_index: z.ZodOptional<z.ZodNumber>;
+            stage_total: z.ZodOptional<z.ZodNumber>;
+            reads: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            writes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            acceptance: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>>;
+        executor: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                "local-agent": "local-agent";
+                "connected-provider": "connected-provider";
+                managed: "managed";
+            }>;
+            name: z.ZodString;
+            display_name: z.ZodString;
+            command: z.ZodNullable<z.ZodString>;
+            model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            effort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            profile: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            timeout_ms: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>>>;
+        artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            role: z.ZodEnum<{
+                output: "output";
+                runtime: "runtime";
+                source: "source";
+                test: "test";
+                proof: "proof";
+            }>;
+            stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            label: z.ZodOptional<z.ZodString>;
+            sha256: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        logs: z.ZodOptional<z.ZodObject<{
+            prompt_path: z.ZodOptional<z.ZodString>;
+            event_stream_path: z.ZodOptional<z.ZodString>;
+            status_path: z.ZodOptional<z.ZodString>;
+            contract_path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        latest_proof: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            run_id: z.ZodString;
+            stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            generated_at: z.ZodString;
+            summary: z.ZodString;
+            files_processed: z.ZodOptional<z.ZodNumber>;
+            artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                role: z.ZodEnum<{
+                    output: "output";
+                    runtime: "runtime";
+                    source: "source";
+                    test: "test";
+                    proof: "proof";
+                }>;
+                stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                label: z.ZodOptional<z.ZodString>;
+                sha256: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                ok: z.ZodBoolean;
+                detail: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>>;
+        failure: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>>;
+    events: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        event_id: z.ZodString;
+        run_id: z.ZodString;
+        timestamp: z.ZodString;
+        type: z.ZodLiteral<"run.started">;
+        preparation: z.ZodString;
+        method: z.ZodString;
+        portable_context_path: z.ZodString;
+        backend: z.ZodEnum<{
+            native: "native";
+            "workflow-sdk": "workflow-sdk";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        event_id: z.ZodString;
+        run_id: z.ZodString;
+        timestamp: z.ZodString;
+        type: z.ZodLiteral<"stage.started">;
+        stage_id: z.ZodString;
+        stage_index: z.ZodOptional<z.ZodNumber>;
+        stage_total: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        event_id: z.ZodString;
+        run_id: z.ZodString;
+        timestamp: z.ZodString;
+        type: z.ZodLiteral<"file.processed">;
+        stage_id: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        event_id: z.ZodString;
+        run_id: z.ZodString;
+        timestamp: z.ZodString;
+        type: z.ZodLiteral<"artifact.written">;
+        stage_id: z.ZodString;
+        artifact: z.ZodObject<{
+            path: z.ZodString;
+            role: z.ZodEnum<{
+                output: "output";
+                runtime: "runtime";
+                source: "source";
+                test: "test";
+                proof: "proof";
+            }>;
+            stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            label: z.ZodOptional<z.ZodString>;
+            sha256: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        event_id: z.ZodString;
+        run_id: z.ZodString;
+        timestamp: z.ZodString;
+        type: z.ZodLiteral<"proof.updated">;
+        stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        proof: z.ZodObject<{
+            id: z.ZodString;
+            run_id: z.ZodString;
+            stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            generated_at: z.ZodString;
+            summary: z.ZodString;
+            files_processed: z.ZodOptional<z.ZodNumber>;
+            artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                role: z.ZodEnum<{
+                    output: "output";
+                    runtime: "runtime";
+                    source: "source";
+                    test: "test";
+                    proof: "proof";
+                }>;
+                stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                label: z.ZodOptional<z.ZodString>;
+                sha256: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                ok: z.ZodBoolean;
+                detail: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        event_id: z.ZodString;
+        run_id: z.ZodString;
+        timestamp: z.ZodString;
+        type: z.ZodLiteral<"log.appended">;
+        stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        stream: z.ZodEnum<{
+            status: "status";
+            trace: "trace";
+            system: "system";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        event_id: z.ZodString;
+        run_id: z.ZodString;
+        timestamp: z.ZodString;
+        type: z.ZodLiteral<"stage.passed">;
+        stage_id: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        event_id: z.ZodString;
+        run_id: z.ZodString;
+        timestamp: z.ZodString;
+        type: z.ZodLiteral<"stage.failed">;
+        stage_id: z.ZodString;
+        error: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        event_id: z.ZodString;
+        run_id: z.ZodString;
+        timestamp: z.ZodString;
+        type: z.ZodLiteral<"run.completed">;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        event_id: z.ZodString;
+        run_id: z.ZodString;
+        timestamp: z.ZodString;
+        type: z.ZodLiteral<"run.failed">;
+        error: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        event_id: z.ZodString;
+        run_id: z.ZodString;
+        timestamp: z.ZodString;
+        type: z.ZodLiteral<"checks.evaluated">;
+        passed: z.ZodNumber;
+        total: z.ZodNumber;
+        target: z.ZodOptional<z.ZodEnum<{
+            compiled: "compiled";
+            raw: "raw";
+        }>>;
+        checks_fingerprint: z.ZodOptional<z.ZodString>;
+        stale: z.ZodOptional<z.ZodBoolean>;
+        test_run_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        event_id: z.ZodString;
+        run_id: z.ZodString;
+        timestamp: z.ZodString;
+        type: z.ZodLiteral<"readiness.updated">;
+        preparation: z.ZodString;
+        readiness: z.ZodObject<{
+            kind: z.ZodLiteral<"interf-readiness-state">;
+            version: z.ZodLiteral<1>;
+            generated_at: z.ZodString;
+            preparation: z.ZodString;
+            status: z.ZodEnum<{
+                "not-configured": "not-configured";
+                "not-built": "not-built";
+                building: "building";
+                built: "built";
+                checking: "checking";
+                ready: "ready";
+                "not-ready": "not-ready";
+                stale: "stale";
+                failed: "failed";
+            }>;
+            ready: z.ZodBoolean;
+            summary: z.ZodString;
+            portable_context_path: z.ZodNullable<z.ZodString>;
+            latest_compile_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            latest_test_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            compile: z.ZodNullable<z.ZodObject<{
+                gate: z.ZodEnum<{
+                    "preparation-config": "preparation-config";
+                    "portable-context": "portable-context";
+                    "compile-run": "compile-run";
+                    "readiness-checks": "readiness-checks";
+                    "source-baseline": "source-baseline";
+                    "portable-context-check": "portable-context-check";
+                    "checks-current": "checks-current";
+                }>;
+                ok: z.ZodBoolean;
+                status: z.ZodOptional<z.ZodEnum<{
+                    "not-configured": "not-configured";
+                    "not-built": "not-built";
+                    building: "building";
+                    built: "built";
+                    checking: "checking";
+                    ready: "ready";
+                    "not-ready": "not-ready";
+                    stale: "stale";
+                    failed: "failed";
+                }>>;
+                summary: z.ZodString;
+                detail: z.ZodOptional<z.ZodString>;
+                run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                artifact_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>>;
+            check_results: z.ZodObject<{
+                configured: z.ZodNumber;
+                fingerprint: z.ZodNullable<z.ZodString>;
+                source_files: z.ZodNullable<z.ZodObject<{
+                    passed: z.ZodNumber;
+                    total: z.ZodNumber;
+                    pass_rate: z.ZodNullable<z.ZodNumber>;
+                    checks_fingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    stale: z.ZodDefault<z.ZodBoolean>;
+                    run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                }, z.core.$strict>>;
+                portable_context: z.ZodNullable<z.ZodObject<{
+                    passed: z.ZodNumber;
+                    total: z.ZodNumber;
+                    pass_rate: z.ZodNullable<z.ZodNumber>;
+                    checks_fingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    stale: z.ZodDefault<z.ZodBoolean>;
+                    run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                }, z.core.$strict>>;
+                delta: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>;
+            checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                gate: z.ZodEnum<{
+                    "preparation-config": "preparation-config";
+                    "portable-context": "portable-context";
+                    "compile-run": "compile-run";
+                    "readiness-checks": "readiness-checks";
+                    "source-baseline": "source-baseline";
+                    "portable-context-check": "portable-context-check";
+                    "checks-current": "checks-current";
+                }>;
+                ok: z.ZodBoolean;
+                status: z.ZodOptional<z.ZodEnum<{
+                    "not-configured": "not-configured";
+                    "not-built": "not-built";
+                    building: "building";
+                    built: "built";
+                    checking: "checking";
+                    ready: "ready";
+                    "not-ready": "not-ready";
+                    stale: "stale";
+                    failed: "failed";
+                }>>;
+                summary: z.ZodString;
+                detail: z.ZodOptional<z.ZodString>;
+                run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                artifact_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "type">>>;
+    latest_proof: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        run_id: z.ZodString;
+        stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        generated_at: z.ZodString;
+        summary: z.ZodString;
+        files_processed: z.ZodOptional<z.ZodNumber>;
+        artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            role: z.ZodEnum<{
+                output: "output";
+                runtime: "runtime";
+                source: "source";
+                test: "test";
+                proof: "proof";
+            }>;
+            stage_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            label: z.ZodOptional<z.ZodString>;
+            sha256: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            ok: z.ZodBoolean;
+            detail: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+    readiness: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        kind: z.ZodLiteral<"interf-readiness-state">;
+        version: z.ZodLiteral<1>;
+        generated_at: z.ZodString;
+        preparation: z.ZodString;
+        status: z.ZodEnum<{
+            "not-configured": "not-configured";
+            "not-built": "not-built";
+            building: "building";
+            built: "built";
+            checking: "checking";
+            ready: "ready";
+            "not-ready": "not-ready";
+            stale: "stale";
+            failed: "failed";
+        }>;
+        ready: z.ZodBoolean;
+        summary: z.ZodString;
+        portable_context_path: z.ZodNullable<z.ZodString>;
+        latest_compile_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        latest_test_run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        compile: z.ZodNullable<z.ZodObject<{
+            gate: z.ZodEnum<{
+                "preparation-config": "preparation-config";
+                "portable-context": "portable-context";
+                "compile-run": "compile-run";
+                "readiness-checks": "readiness-checks";
+                "source-baseline": "source-baseline";
+                "portable-context-check": "portable-context-check";
+                "checks-current": "checks-current";
+            }>;
+            ok: z.ZodBoolean;
+            status: z.ZodOptional<z.ZodEnum<{
+                "not-configured": "not-configured";
+                "not-built": "not-built";
+                building: "building";
+                built: "built";
+                checking: "checking";
+                ready: "ready";
+                "not-ready": "not-ready";
+                stale: "stale";
+                failed: "failed";
+            }>>;
+            summary: z.ZodString;
+            detail: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            artifact_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>;
+        check_results: z.ZodObject<{
+            configured: z.ZodNumber;
+            fingerprint: z.ZodNullable<z.ZodString>;
+            source_files: z.ZodNullable<z.ZodObject<{
+                passed: z.ZodNumber;
+                total: z.ZodNumber;
+                pass_rate: z.ZodNullable<z.ZodNumber>;
+                checks_fingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                stale: z.ZodDefault<z.ZodBoolean>;
+                run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>>;
+            portable_context: z.ZodNullable<z.ZodObject<{
+                passed: z.ZodNumber;
+                total: z.ZodNumber;
+                pass_rate: z.ZodNullable<z.ZodNumber>;
+                checks_fingerprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                stale: z.ZodDefault<z.ZodBoolean>;
+                run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                run_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>>;
+            delta: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+        checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            gate: z.ZodEnum<{
+                "preparation-config": "preparation-config";
+                "portable-context": "portable-context";
+                "compile-run": "compile-run";
+                "readiness-checks": "readiness-checks";
+                "source-baseline": "source-baseline";
+                "portable-context-check": "portable-context-check";
+                "checks-current": "checks-current";
+            }>;
+            ok: z.ZodBoolean;
+            status: z.ZodOptional<z.ZodEnum<{
+                "not-configured": "not-configured";
+                "not-built": "not-built";
+                building: "building";
+                built: "built";
+                checking: "checking";
+                ready: "ready";
+                "not-ready": "not-ready";
+                stale: "stale";
+                failed: "failed";
+            }>>;
+            summary: z.ZodString;
+            detail: z.ZodOptional<z.ZodString>;
+            run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            artifact_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type ExecutionBackendKind = z.infer<typeof ExecutionBackendKindSchema>;
+export type MethodTraceRunStatus = z.infer<typeof MethodTraceRunStatusSchema>;
+export type MethodTraceEventType = z.infer<typeof MethodTraceEventTypeSchema>;
+export type MethodTraceStructuredError = z.infer<typeof MethodTraceStructuredErrorSchema>;
+export type MethodTraceRun = z.infer<typeof MethodTraceRunSchema>;
+export type MethodTraceEvent = z.infer<typeof MethodTraceEventSchema>;
+export type MethodTraceStreamChunk = z.infer<typeof MethodTraceStreamChunkSchema>;
+export type MethodTrace = z.infer<typeof MethodTraceSchema>;
+export type ObservableRunType = z.infer<typeof ObservableRunTypeSchema>;
+export type ObservableRunStatus = z.infer<typeof ObservableRunStatusSchema>;
+export type ObservableRunMetric = z.infer<typeof ObservableRunMetricSchema>;
+export type RunObservability = z.infer<typeof RunObservabilitySchema>;
+export type CompileRunStatus = z.infer<typeof CompileRunStatusSchema>;
+export type StageRunStatus = z.infer<typeof StageRunStatusSchema>;
+export type ArtifactRole = z.infer<typeof ArtifactRoleSchema>;
+export type ArtifactRef = z.infer<typeof ArtifactRefSchema>;
+export type ProofCheck = z.infer<typeof ProofCheckSchema>;
+export type ProofRecord = z.infer<typeof ProofRecordSchema>;
+export type StageRunContract = z.infer<typeof StageRunContractSchema>;
+export type StageRunLogs = z.infer<typeof StageRunLogsSchema>;
+export type InterfRunEvent = z.infer<typeof InterfRunEventSchema>;
+export type StageRun = z.infer<typeof StageRunSchema>;
+export type CompileRun = z.infer<typeof CompileRunSchema>;