/**
 * Run-artifact contract for the grounded single-run ledger (mmnto-ai/totem#2100,
 * strategy#474 slice 1).
 *
 * The artifact is the immutable bridge between the deterministic substrate and
 * non-deterministic LLM execution: a verifiable, offline record of exactly what
 * was sent (post-DLP — the MASKED prompt, never raw) and what came back.
 * Everything downstream (post-checks #2103, panel synthesis #2104, the Phase-2
 * disposition ledger) consumes this shape, so it stays minimal but versioned.
 *
 * Schema-evolution policy (strategy review F1 on the #2100 design, 0253Z
 * dispatch): the reader is version-tolerant WITHIN the major —
 *   - `schemaVersion` validates as `1.x` (never a literal pin),
 *   - every post-1.0.0 field must be additive-optional,
 *   - a MAJOR bump requires a migration entry in the loader before the writer
 *     ships (`loadRunArtifact`'s migration-on-read registry).
 * Hard-reject only unknown majors. Rationale: an append-only ledger whose
 * reader rejects its own history isn't append-only in practice — a literal pin
 * would orphan the accumulated eval-fixture corpus at #2101's first bump.
 *
 * Zod here is a system boundary (persisted JSON read back from disk), per the
 * repo's Zod-at-boundaries-only rule.
 */
import { z } from 'zod';
/**
 * The schemaVersion WRITTEN by this code. Readers accept any 1.x (F1).
 * 1.1.0 (mmnto-ai/totem#2101): `grounding` gained the optional per-item
 * `bundle`, and `grounding.hash` semantics changed from hash-of-raw-context
 * to hash-of-bundle — the minor is the observable marker for that meaning
 * change; the registry stays empty because the tolerant reader parses both.
 */
export declare const RUN_ARTIFACT_SCHEMA_VERSION = "1.1.0";
/** The major this reader understands; other majors need a migration entry. */
export declare const RUN_ARTIFACT_KNOWN_MAJOR = 1;
/**
 * Canonical provenance classes (mmnto-ai/totem#2101, strategy#474 items 1+7).
 * `similarity-only` is the honest class for today's retrieval; the others are
 * reserved for graduation — `structurally-verified` lands via mmnto-ai/totem#344/#375
 * resolvers, `spec-contract`/`compiled-rule` via their respective delivery
 * paths. Schema-level validation stays an open string (extensible without a
 * major — the same reasoning that kept slice 1's `provenanceSummary` free).
 *
 * Fail-safe-down rider (strategy review F2 on mmnto-ai/totem#2101): every consumer
 * (summaries, eval thresholds, future conformance sensing) must treat a
 * non-canonical class string as NOT-upgraded — lowest trust — so an invented
 * class can never confer trust absent code-side graduation. Safe today
 * because classes are builder-emitted constants, never model-supplied; the
 * enforcement test rides mmnto-ai/totem#2103.
 */
export declare const PROVENANCE_SIMILARITY_ONLY = "similarity-only";
export declare const PROVENANCE_STRUCTURALLY_VERIFIED = "structurally-verified";
export declare const PROVENANCE_SPEC_CONTRACT = "spec-contract";
export declare const PROVENANCE_COMPILED_RULE = "compiled-rule";
export declare const PROVENANCE_CLASSES: readonly ["similarity-only", "structurally-verified", "spec-contract", "compiled-rule"];
/**
 * `provenanceSummary` for a bundle with zero items: the run was UNGROUNDED —
 * abstention named epistemically (what the absence means), not mechanically
 * ("empty"). Honest-absent: a degraded run says so in its own record.
 */
export declare const PROVENANCE_UNGROUNDED = "ungrounded";
/**
 * Slice-1 admission class for both migrated callers (spec + review): factually
 * completion-only today. #2102 (backend admission contract) changes who
 * supplies the value, not the field. Day-one self-description, same retrofit
 * argument as provenance.
 */
export declare const ADMISSION_COMPLETION_ONLY: "completion_only";
/**
 * Elevated admission class (mmnto-ai/totem#2102, strategy#474 slice 3): the
 * backend is admitted to ground itself (agentic retrieval/tool use) rather
 * than complete over caller-delivered context. Requestable only when declared
 * in `orchestrator.capabilities.admissionClasses` — the admission gate in
 * `runOrchestrator` fails loud pre-invoke otherwise.
 */
export declare const ADMISSION_SELF_GROUNDING_AGENT: "self_grounding_agent";
/**
 * Closed two-value enum this slice — single source of truth for both
 * `BackendSchema.admissionClass` and the config-side capability declaration
 * (`orchestrator.capabilities.admissionClasses`); a parallel definition is
 * the drift vector the #1429 model-validation review named.
 */
export declare const ADMISSION_CLASSES: readonly ["completion_only", "self_grounding_agent"];
/**
 * The assembled prompt inputs, POST-DLP. `maskedPrompt`/`maskedSystemPrompt`
 * are what actually crossed the wire (`maskSecrets` output) — recording the
 * raw prompt would persist secrets to disk.
 */
export declare const InputBundleSchema: z.ZodObject<{
    maskedPrompt: z.ZodString;
    maskedSystemPrompt: z.ZodOptional<z.ZodString>;
    /** Deterministic diff input when the caller ran with a forced scope (#2098). */
    diffScope: z.ZodOptional<z.ZodString>;
    /** The grounded spec contract, when present (review sensing against a spec doc). */
    specContract: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    maskedPrompt: string;
    maskedSystemPrompt?: string | undefined;
    diffScope?: string | undefined;
    specContract?: string | undefined;
}, {
    maskedPrompt: string;
    maskedSystemPrompt?: string | undefined;
    diffScope?: string | undefined;
    specContract?: string | undefined;
}>;
/**
 * One delivered evidence item (mmnto-ai/totem#2101): identity + content hash
 * + provenance class. NO content bytes — `inputBundle.maskedPrompt` already
 * carries the bytes once; duplicating them bloats every artifact and creates
 * a second DLP surface. Identity fields are required: fabricated or absent
 * identity is the illusion-of-grounding trap the bundle exists to close.
 */
export declare const GroundingItemSchema: z.ZodObject<{
    /** Provenance class — open vocabulary, canonical values in {@link PROVENANCE_CLASSES}; consumers fail-safe-down on unknown strings (F2). */
    provenance: z.ZodString;
    /** Deterministic hash of the delivered snippet content (identity, not bytes). */
    contentHash: z.ZodString;
    /** Retrieval partition the item entered the prompt under (`spec` | `session_log` | `code` | `lesson`). */
    sourceType: z.ZodString;
    /** Path relative to the owning repo root — display + structural-resolution identity. */
    filePath: z.ZodString;
    /** Linked-index name for cross-repo hits; ABSENT = the run's own repo (F1) — post-checks resolve `filePath` against the run's config root when absent. */
    sourceRepo: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    filePath: string;
    contentHash: string;
    provenance: string;
    sourceType: string;
    sourceRepo?: string | undefined;
}, {
    filePath: string;
    contentHash: string;
    provenance: string;
    sourceType: string;
    sourceRepo?: string | undefined;
}>;
/**
 * The per-item grounding record. No stored summary/count fields — counts are
 * derived by `summarizeProvenance` (derive-or-couple: a stored mirror can
 * drift from `items`).
 */
export declare const GroundingBundleSchema: z.ZodObject<{
    items: z.ZodArray<z.ZodObject<{
        /** Provenance class — open vocabulary, canonical values in {@link PROVENANCE_CLASSES}; consumers fail-safe-down on unknown strings (F2). */
        provenance: z.ZodString;
        /** Deterministic hash of the delivered snippet content (identity, not bytes). */
        contentHash: z.ZodString;
        /** Retrieval partition the item entered the prompt under (`spec` | `session_log` | `code` | `lesson`). */
        sourceType: z.ZodString;
        /** Path relative to the owning repo root — display + structural-resolution identity. */
        filePath: z.ZodString;
        /** Linked-index name for cross-repo hits; ABSENT = the run's own repo (F1) — post-checks resolve `filePath` against the run's config root when absent. */
        sourceRepo: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        filePath: string;
        contentHash: string;
        provenance: string;
        sourceType: string;
        sourceRepo?: string | undefined;
    }, {
        filePath: string;
        contentHash: string;
        provenance: string;
        sourceType: string;
        sourceRepo?: string | undefined;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    items: {
        filePath: string;
        contentHash: string;
        provenance: string;
        sourceType: string;
        sourceRepo?: string | undefined;
    }[];
}, {
    items: {
        filePath: string;
        contentHash: string;
        provenance: string;
        sourceType: string;
        sourceRepo?: string | undefined;
    }[];
}>;
/** What KIND of grounding the run had — day-one field, never retrofittable. */
export declare const GroundingSchema: z.ZodObject<{
    /**
     * Deterministic hash of the grounding surface. From 1.1.0 this is
     * `calculateDeterministicHash(bundle)` — the verifier recomputes it from
     * the artifact surface ALONE (one enumeration, two readers). Slice-1
     * artifacts (no `bundle`) carry their original hash-of-raw-context, which
     * is self-consistent but not recomputable offline.
     */
    hash: z.ZodString;
    /** Derived from the bundle since 1.1.0 (sorted class counts, or `ungrounded`); wholesale string in slice-1 artifacts. */
    provenanceSummary: z.ZodString;
    /** Per-item provenance record (mmnto-ai/totem#2101). Optional: slice-1 artifacts predate it and cannot be re-classed. */
    bundle: z.ZodOptional<z.ZodObject<{
        items: z.ZodArray<z.ZodObject<{
            /** Provenance class — open vocabulary, canonical values in {@link PROVENANCE_CLASSES}; consumers fail-safe-down on unknown strings (F2). */
            provenance: z.ZodString;
            /** Deterministic hash of the delivered snippet content (identity, not bytes). */
            contentHash: z.ZodString;
            /** Retrieval partition the item entered the prompt under (`spec` | `session_log` | `code` | `lesson`). */
            sourceType: z.ZodString;
            /** Path relative to the owning repo root — display + structural-resolution identity. */
            filePath: z.ZodString;
            /** Linked-index name for cross-repo hits; ABSENT = the run's own repo (F1) — post-checks resolve `filePath` against the run's config root when absent. */
            sourceRepo: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            filePath: string;
            contentHash: string;
            provenance: string;
            sourceType: string;
            sourceRepo?: string | undefined;
        }, {
            filePath: string;
            contentHash: string;
            provenance: string;
            sourceType: string;
            sourceRepo?: string | undefined;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        items: {
            filePath: string;
            contentHash: string;
            provenance: string;
            sourceType: string;
            sourceRepo?: string | undefined;
        }[];
    }, {
        items: {
            filePath: string;
            contentHash: string;
            provenance: string;
            sourceType: string;
            sourceRepo?: string | undefined;
        }[];
    }>>;
}, "strip", z.ZodTypeAny, {
    hash: string;
    provenanceSummary: string;
    bundle?: {
        items: {
            filePath: string;
            contentHash: string;
            provenance: string;
            sourceType: string;
            sourceRepo?: string | undefined;
        }[];
    } | undefined;
}, {
    hash: string;
    provenanceSummary: string;
    bundle?: {
        items: {
            filePath: string;
            contentHash: string;
            provenance: string;
            sourceType: string;
            sourceRepo?: string | undefined;
        }[];
    } | undefined;
}>;
/** Backend identity as RESOLVED (post quota-fallback), not as requested. */
export declare const BackendSchema: z.ZodObject<{
    provider: z.ZodString;
    model: z.ZodString;
    /** The full provider-qualified string telemetry/cache key on (`provider:model`). */
    qualifiedModel: z.ZodString;
    admissionClass: z.ZodEnum<["completion_only", "self_grounding_agent"]>;
    /** The command tag the run served (`Spec`, `Review`, ...) — the task profile. */
    taskProfile: z.ZodString;
    temperature: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    provider: string;
    model: string;
    qualifiedModel: string;
    admissionClass: "completion_only" | "self_grounding_agent";
    taskProfile: string;
    temperature?: number | undefined;
}, {
    provider: string;
    model: string;
    qualifiedModel: string;
    admissionClass: "completion_only" | "self_grounding_agent";
    taskProfile: string;
    temperature?: number | undefined;
}>;
/**
 * Caller-declared output contract (mmnto-ai/totem#2102): the citations-or-
 * `VERIFY:` declaration. Callers write; #2103 post-checks read; providers
 * transport, never enforce (Totem is not zero-user — backend cooperation is
 * never assumed, enforcement is caller-side post-invocation). Closed object:
 * extensible by additive optional fields, not an index signature.
 */
export declare const OutputContractSchema: z.ZodObject<{
    /** Response claims must carry citations into the delivered grounding. */
    citationsRequired: z.ZodOptional<z.ZodBoolean>;
    /** Whether an explicit `VERIFY:` escalation is an acceptable fallback for an uncitable claim. */
    verifyFallback: z.ZodOptional<z.ZodBoolean>;
    /** JSON-Schema definition for structured output. */
    schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    citationsRequired?: boolean | undefined;
    verifyFallback?: boolean | undefined;
    schema?: Record<string, unknown> | undefined;
}, {
    citationsRequired?: boolean | undefined;
    verifyFallback?: boolean | undefined;
    schema?: Record<string, unknown> | undefined;
}>;
/**
 * Caller-declared context policy (mmnto-ai/totem#2102). Advisory this slice —
 * recorded for honesty, enforced by nothing yet — but validated so
 * declared-not-enforced never means accepting nonsense.
 */
export declare const ContextPolicySchema: z.ZodObject<{
    /** Advisory context budget. Unit: INPUT TOKENS. */
    budget: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    budget?: number | undefined;
}, {
    budget?: number | undefined;
}>;
/**
 * Caller identity metadata (mmnto-ai/totem#2102, the #2100 runMetadata
 * target) — recorded verbatim into the artifact.
 */
export declare const RunMetadataSchema: z.ZodObject<{
    /** The command/module that issued the run (e.g. `spec`, `review`). */
    caller: z.ZodOptional<z.ZodString>;
    /** The CLI command identity the run served, when distinct from `caller`. */
    command: z.ZodOptional<z.ZodString>;
    /**
     * Whether the code-blind grounding guard fired for this run (mmnto-ai/totem#2106):
     * zero code chunks were retrieved, so the prompt carried the suppression
     * directive and the output is degraded/caveated. Recorded so run artifacts
     * (eval fixtures, #2100) are filterable by guard activation without
     * recomputing `code.length === 0` from the grounding bundle.
     */
    codeBlind: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    caller?: string | undefined;
    command?: string | undefined;
    codeBlind?: boolean | undefined;
}, {
    caller?: string | undefined;
    command?: string | undefined;
    codeBlind?: boolean | undefined;
}>;
/**
 * Token counts mirror `OrchestratorResult`: `null` means the provider did not
 * report (honest-absent), distinct from the field being absent entirely.
 */
export declare const RunMetricsSchema: z.ZodObject<{
    inputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    outputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    cacheReadInputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    durationMs: z.ZodNumber;
    finishReason: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    durationMs: number;
    inputTokens?: number | null | undefined;
    outputTokens?: number | null | undefined;
    cacheReadInputTokens?: number | null | undefined;
    finishReason?: string | undefined;
}, {
    durationMs: number;
    inputTokens?: number | null | undefined;
    outputTokens?: number | null | undefined;
    cacheReadInputTokens?: number | null | undefined;
    finishReason?: string | undefined;
}>;
export declare const RunArtifactSchema: z.ZodObject<{
    schemaVersion: z.ZodEffects<z.ZodString, string, string>;
    inputBundle: z.ZodObject<{
        maskedPrompt: z.ZodString;
        maskedSystemPrompt: z.ZodOptional<z.ZodString>;
        /** Deterministic diff input when the caller ran with a forced scope (#2098). */
        diffScope: z.ZodOptional<z.ZodString>;
        /** The grounded spec contract, when present (review sensing against a spec doc). */
        specContract: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        maskedPrompt: string;
        maskedSystemPrompt?: string | undefined;
        diffScope?: string | undefined;
        specContract?: string | undefined;
    }, {
        maskedPrompt: string;
        maskedSystemPrompt?: string | undefined;
        diffScope?: string | undefined;
        specContract?: string | undefined;
    }>;
    /** Deterministic hash of `inputBundle` alone — the rerun identity. */
    inputHash: z.ZodString;
    grounding: z.ZodObject<{
        /**
         * Deterministic hash of the grounding surface. From 1.1.0 this is
         * `calculateDeterministicHash(bundle)` — the verifier recomputes it from
         * the artifact surface ALONE (one enumeration, two readers). Slice-1
         * artifacts (no `bundle`) carry their original hash-of-raw-context, which
         * is self-consistent but not recomputable offline.
         */
        hash: z.ZodString;
        /** Derived from the bundle since 1.1.0 (sorted class counts, or `ungrounded`); wholesale string in slice-1 artifacts. */
        provenanceSummary: z.ZodString;
        /** Per-item provenance record (mmnto-ai/totem#2101). Optional: slice-1 artifacts predate it and cannot be re-classed. */
        bundle: z.ZodOptional<z.ZodObject<{
            items: z.ZodArray<z.ZodObject<{
                /** Provenance class — open vocabulary, canonical values in {@link PROVENANCE_CLASSES}; consumers fail-safe-down on unknown strings (F2). */
                provenance: z.ZodString;
                /** Deterministic hash of the delivered snippet content (identity, not bytes). */
                contentHash: z.ZodString;
                /** Retrieval partition the item entered the prompt under (`spec` | `session_log` | `code` | `lesson`). */
                sourceType: z.ZodString;
                /** Path relative to the owning repo root — display + structural-resolution identity. */
                filePath: z.ZodString;
                /** Linked-index name for cross-repo hits; ABSENT = the run's own repo (F1) — post-checks resolve `filePath` against the run's config root when absent. */
                sourceRepo: z.ZodOptional<z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                filePath: string;
                contentHash: string;
                provenance: string;
                sourceType: string;
                sourceRepo?: string | undefined;
            }, {
                filePath: string;
                contentHash: string;
                provenance: string;
                sourceType: string;
                sourceRepo?: string | undefined;
            }>, "many">;
        }, "strip", z.ZodTypeAny, {
            items: {
                filePath: string;
                contentHash: string;
                provenance: string;
                sourceType: string;
                sourceRepo?: string | undefined;
            }[];
        }, {
            items: {
                filePath: string;
                contentHash: string;
                provenance: string;
                sourceType: string;
                sourceRepo?: string | undefined;
            }[];
        }>>;
    }, "strip", z.ZodTypeAny, {
        hash: string;
        provenanceSummary: string;
        bundle?: {
            items: {
                filePath: string;
                contentHash: string;
                provenance: string;
                sourceType: string;
                sourceRepo?: string | undefined;
            }[];
        } | undefined;
    }, {
        hash: string;
        provenanceSummary: string;
        bundle?: {
            items: {
                filePath: string;
                contentHash: string;
                provenance: string;
                sourceType: string;
                sourceRepo?: string | undefined;
            }[];
        } | undefined;
    }>;
    backend: z.ZodObject<{
        provider: z.ZodString;
        model: z.ZodString;
        /** The full provider-qualified string telemetry/cache key on (`provider:model`). */
        qualifiedModel: z.ZodString;
        admissionClass: z.ZodEnum<["completion_only", "self_grounding_agent"]>;
        /** The command tag the run served (`Spec`, `Review`, ...) — the task profile. */
        taskProfile: z.ZodString;
        temperature: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        provider: string;
        model: string;
        qualifiedModel: string;
        admissionClass: "completion_only" | "self_grounding_agent";
        taskProfile: string;
        temperature?: number | undefined;
    }, {
        provider: string;
        model: string;
        qualifiedModel: string;
        admissionClass: "completion_only" | "self_grounding_agent";
        taskProfile: string;
        temperature?: number | undefined;
    }>;
    output: z.ZodObject<{
        content: z.ZodString;
        metrics: z.ZodObject<{
            inputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
            outputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
            cacheReadInputTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
            durationMs: z.ZodNumber;
            finishReason: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            durationMs: number;
            inputTokens?: number | null | undefined;
            outputTokens?: number | null | undefined;
            cacheReadInputTokens?: number | null | undefined;
            finishReason?: string | undefined;
        }, {
            durationMs: number;
            inputTokens?: number | null | undefined;
            outputTokens?: number | null | undefined;
            cacheReadInputTokens?: number | null | undefined;
            finishReason?: string | undefined;
        }>;
    }, "strip", z.ZodTypeAny, {
        content: string;
        metrics: {
            durationMs: number;
            inputTokens?: number | null | undefined;
            outputTokens?: number | null | undefined;
            cacheReadInputTokens?: number | null | undefined;
            finishReason?: string | undefined;
        };
    }, {
        content: string;
        metrics: {
            durationMs: number;
            inputTokens?: number | null | undefined;
            outputTokens?: number | null | undefined;
            cacheReadInputTokens?: number | null | undefined;
            finishReason?: string | undefined;
        };
    }>;
    /** Admitted contract group (mmnto-ai/totem#2102) — additive 1.x optional; slice-1/2 artifacts predate it. */
    admission: z.ZodOptional<z.ZodObject<{
        outputContract: z.ZodOptional<z.ZodObject<{
            /** Response claims must carry citations into the delivered grounding. */
            citationsRequired: z.ZodOptional<z.ZodBoolean>;
            /** Whether an explicit `VERIFY:` escalation is an acceptable fallback for an uncitable claim. */
            verifyFallback: z.ZodOptional<z.ZodBoolean>;
            /** JSON-Schema definition for structured output. */
            schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, "strip", z.ZodTypeAny, {
            citationsRequired?: boolean | undefined;
            verifyFallback?: boolean | undefined;
            schema?: Record<string, unknown> | undefined;
        }, {
            citationsRequired?: boolean | undefined;
            verifyFallback?: boolean | undefined;
            schema?: Record<string, unknown> | undefined;
        }>>;
        contextPolicy: z.ZodOptional<z.ZodObject<{
            /** Advisory context budget. Unit: INPUT TOKENS. */
            budget: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            budget?: number | undefined;
        }, {
            budget?: number | undefined;
        }>>;
        runMetadata: z.ZodOptional<z.ZodObject<{
            /** The command/module that issued the run (e.g. `spec`, `review`). */
            caller: z.ZodOptional<z.ZodString>;
            /** The CLI command identity the run served, when distinct from `caller`. */
            command: z.ZodOptional<z.ZodString>;
            /**
             * Whether the code-blind grounding guard fired for this run (mmnto-ai/totem#2106):
             * zero code chunks were retrieved, so the prompt carried the suppression
             * directive and the output is degraded/caveated. Recorded so run artifacts
             * (eval fixtures, #2100) are filterable by guard activation without
             * recomputing `code.length === 0` from the grounding bundle.
             */
            codeBlind: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            caller?: string | undefined;
            command?: string | undefined;
            codeBlind?: boolean | undefined;
        }, {
            caller?: string | undefined;
            command?: string | undefined;
            codeBlind?: boolean | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        outputContract?: {
            citationsRequired?: boolean | undefined;
            verifyFallback?: boolean | undefined;
            schema?: Record<string, unknown> | undefined;
        } | undefined;
        contextPolicy?: {
            budget?: number | undefined;
        } | undefined;
        runMetadata?: {
            caller?: string | undefined;
            command?: string | undefined;
            codeBlind?: boolean | undefined;
        } | undefined;
    }, {
        outputContract?: {
            citationsRequired?: boolean | undefined;
            verifyFallback?: boolean | undefined;
            schema?: Record<string, unknown> | undefined;
        } | undefined;
        contextPolicy?: {
            budget?: number | undefined;
        } | undefined;
        runMetadata?: {
            caller?: string | undefined;
            command?: string | undefined;
            codeBlind?: boolean | undefined;
        } | undefined;
    }>>;
    /**
     * ISO-8601 emission time. EXCLUDED from the content address (identical runs
     * dedup to one artifact regardless of when they ran) — observability only.
     */
    createdAt: z.ZodString;
}, "strip", z.ZodTypeAny, {
    createdAt: string;
    schemaVersion: string;
    inputBundle: {
        maskedPrompt: string;
        maskedSystemPrompt?: string | undefined;
        diffScope?: string | undefined;
        specContract?: string | undefined;
    };
    inputHash: string;
    grounding: {
        hash: string;
        provenanceSummary: string;
        bundle?: {
            items: {
                filePath: string;
                contentHash: string;
                provenance: string;
                sourceType: string;
                sourceRepo?: string | undefined;
            }[];
        } | undefined;
    };
    backend: {
        provider: string;
        model: string;
        qualifiedModel: string;
        admissionClass: "completion_only" | "self_grounding_agent";
        taskProfile: string;
        temperature?: number | undefined;
    };
    output: {
        content: string;
        metrics: {
            durationMs: number;
            inputTokens?: number | null | undefined;
            outputTokens?: number | null | undefined;
            cacheReadInputTokens?: number | null | undefined;
            finishReason?: string | undefined;
        };
    };
    admission?: {
        outputContract?: {
            citationsRequired?: boolean | undefined;
            verifyFallback?: boolean | undefined;
            schema?: Record<string, unknown> | undefined;
        } | undefined;
        contextPolicy?: {
            budget?: number | undefined;
        } | undefined;
        runMetadata?: {
            caller?: string | undefined;
            command?: string | undefined;
            codeBlind?: boolean | undefined;
        } | undefined;
    } | undefined;
}, {
    createdAt: string;
    schemaVersion: string;
    inputBundle: {
        maskedPrompt: string;
        maskedSystemPrompt?: string | undefined;
        diffScope?: string | undefined;
        specContract?: string | undefined;
    };
    inputHash: string;
    grounding: {
        hash: string;
        provenanceSummary: string;
        bundle?: {
            items: {
                filePath: string;
                contentHash: string;
                provenance: string;
                sourceType: string;
                sourceRepo?: string | undefined;
            }[];
        } | undefined;
    };
    backend: {
        provider: string;
        model: string;
        qualifiedModel: string;
        admissionClass: "completion_only" | "self_grounding_agent";
        taskProfile: string;
        temperature?: number | undefined;
    };
    output: {
        content: string;
        metrics: {
            durationMs: number;
            inputTokens?: number | null | undefined;
            outputTokens?: number | null | undefined;
            cacheReadInputTokens?: number | null | undefined;
            finishReason?: string | undefined;
        };
    };
    admission?: {
        outputContract?: {
            citationsRequired?: boolean | undefined;
            verifyFallback?: boolean | undefined;
            schema?: Record<string, unknown> | undefined;
        } | undefined;
        contextPolicy?: {
            budget?: number | undefined;
        } | undefined;
        runMetadata?: {
            caller?: string | undefined;
            command?: string | undefined;
            codeBlind?: boolean | undefined;
        } | undefined;
    } | undefined;
}>;
export type RunArtifact = z.infer<typeof RunArtifactSchema>;
export type InputBundle = z.infer<typeof InputBundleSchema>;
export type GroundingItem = z.infer<typeof GroundingItemSchema>;
export type GroundingBundle = z.infer<typeof GroundingBundleSchema>;
export type OutputContract = z.infer<typeof OutputContractSchema>;
export type ContextPolicy = z.infer<typeof ContextPolicySchema>;
export type RunMetadata = z.infer<typeof RunMetadataSchema>;
/** Inferred from the `BackendSchema` enum — the canonical admission-class union (mmnto-ai/totem#2102). */
export type BackendAdmissionClass = z.infer<typeof BackendSchema>['admissionClass'];
//# sourceMappingURL=schema.d.ts.map