@open-agent-toolkit/cli 0.2.51 → 0.2.53

package/dist/providers/identity/oat-dispatch-record.d.ts

@@ -0,0 +1,1964 @@
+import { z } from 'zod';
+import { type GenericDispatchRecord } from './generic-dispatch-record.js';
+/**
+ * A pre-start native-selection rejection is a closed event set. It is proof
+ * that the native launch surface refused the exact target before any child
+ * started, and it is the only category that can authorize one canonical
+ * fallback. It is deliberately disjoint from terminal child-outcome codes.
+ */
+export declare const QUALIFYING_PRE_START_REJECTION_CODES: readonly ['native-role-unavailable', 'native-target-unavailable', 'native-selector-unsupported', 'native-catalog-unsatisfying', 'capability-unresolved-or-unsupported', 'wrapper-payload-rejected', 'wrapper-launch-refused'];
+export type QualifyingPreStartRejectionCode = (typeof QUALIFYING_PRE_START_REJECTION_CODES)[number];
+/**
+ * Immutable configured controls across a fallback link.
+ *
+ * The rule, so a newly added generic field has a default: a field is immutable
+ * when it describes the configured selection, the authorization for that
+ * selection, or the evidence that justified it. A field is mutable when it
+ * describes this record's own identity, how the work is briefed to its own
+ * child, its own launch lifecycle, or its own child's observed behaviour. When
+ * a new field is ambiguous, treat it as immutable — a false "controls
+ * preserved" claim is worse than a false mismatch.
+ *
+ * All 46 generic fields are accounted for. The 31 immutable ones are listed
+ * below. The 15 mutable ones, each with its reason:
+ * - `request_id`: the fallback is a distinct request and must have its own ID.
+ * - `caller`: the adapter layer that launches the fallback may differ.
+ * - `objective`: a canonical-instruction fallback necessarily rebriefs the work
+ *   for a generic child rather than a resolved role.
+ * - `role_name`, `role_selector`: the fallback deliberately targets a generic
+ *   worker; substituting the role is the whole point of the approximation, and
+ *   the resolved role identity is bound separately through `roleInstructions`.
+ * - `candidates_considered`: the fallback evaluated a different candidate set.
+ * - `selection_reason`: constrained separately — a fallback must declare
+ *   `pre-start-rejection`, which by definition differs from the trigger's.
+ * - `launch_status`, `child_outcome`: each record's own lifecycle state.
+ * - `runtime_confirmation`: observation of that record's own child. The
+ *   fallback is a different child, so equality would be a false assertion.
+ * - `diagnostics`: per-record narration. A fallback legitimately explains why
+ *   it exists.
+ * - `continuation_events`: continuation linkage belongs to the record that
+ *   owns the handle.
+ * - `expected_output`, `verification_evidence`, `escalate_when`: the brief
+ *   given to this record's own child, in the same class as `objective`.
+ *
+ * Included even though they are evidence rather than controls, because they
+ * record why the preserved selection was allowed:
+ * - `configured_invocation_evidence`: names the configuration that authorized
+ *   the preserved route.
+ * - `catalog_snapshot`: names the catalog the selection was made against.
+ * - `guidance_reference`, `guidance_version`, `guidance_verified_at`,
+ *   `guidance_status`: name the dated model guidance behind the selection and
+ *   how fresh it was; a fallback restating `stale` as `fresh` would misstate
+ *   provenance for a preserved target.
+ * - `classification_reason`: the rationale for `task_class`, which is itself a
+ *   compared authorization control.
+ */
+export declare const IMMUTABLE_FALLBACK_CONTROL_FIELDS: readonly ["provider", "selection_source", "model_selector", "model_selector_granularity", "effort_selector", "reasoning_mode_selector", "service_tier_selector", "selected_route", "authority", "authorization_scope", "deadline_seconds", "retry_limit", "payload", "fallback", "catalog_snapshot", "configured_invocation_evidence", "guidance_reference", "guidance_version", "guidance_verified_at", "guidance_status", "dispatch_context", "dispatch_policy", "dispatch_ceiling", "scope", "action", "role_class", "task_class", "model_class_floor", "classification_source", "classification_reason", "floor_satisfaction"];
+/**
+ * The mutable complement, kept executable rather than only described above so a
+ * newly added generic field fails `covers every generic dispatch field` until
+ * somebody records a decision for it.
+ */
+export declare const MUTABLE_FALLBACK_CONTROL_FIELDS: readonly ["request_id", "caller", "objective", "role_name", "role_selector", "candidates_considered", "selection_reason", "launch_status", "child_outcome", "runtime_confirmation", "diagnostics", "continuation_events", "expected_output", "verification_evidence", "escalate_when"];
+export declare function canonicalEvidenceJson(value: unknown): string;
+export declare function configuredControlDigest(record: GenericDispatchRecord): string;
+declare const exactTargetSchema: z.ZodObject<{
+    provider: z.ZodString;
+    modelSelector: z.ZodNullable<z.ZodString>;
+    effortSelector: z.ZodNullable<z.ZodString>;
+    reasoningModeSelector: z.ZodNullable<z.ZodString>;
+    serviceTierSelector: z.ZodNullable<z.ZodString>;
+    selectedRoute: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    provider: string;
+    modelSelector: string | null;
+    effortSelector: string | null;
+    reasoningModeSelector: string | null;
+    serviceTierSelector: string | null;
+    selectedRoute: string;
+}, {
+    provider: string;
+    modelSelector: string | null;
+    effortSelector: string | null;
+    reasoningModeSelector: string | null;
+    serviceTierSelector: string | null;
+    selectedRoute: string;
+}>;
+export type ExactTargetRef = z.infer<typeof exactTargetSchema>;
+declare const fallbackSchema: z.ZodDiscriminatedUnion<"status", [z.ZodObject<{
+    status: z.ZodLiteral<"not-applicable">;
+    reason: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    status: "not-applicable";
+    reason: string;
+}, {
+    status: "not-applicable";
+    reason: string;
+}>, z.ZodObject<{
+    status: z.ZodLiteral<"fallback-dispatch">;
+    triggerRequestId: z.ZodString;
+    fallbackRequestId: z.ZodString;
+    trigger: z.ZodLiteral<"pre-start-rejection">;
+    fallbackReason: z.ZodString;
+    kind: z.ZodLiteral<"canonical-instruction-fresh-child">;
+    approximation: z.ZodLiteral<true>;
+    preservedTarget: z.ZodObject<{
+        provider: z.ZodString;
+        modelSelector: z.ZodNullable<z.ZodString>;
+        effortSelector: z.ZodNullable<z.ZodString>;
+        reasoningModeSelector: z.ZodNullable<z.ZodString>;
+        serviceTierSelector: z.ZodNullable<z.ZodString>;
+        selectedRoute: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        provider: string;
+        modelSelector: string | null;
+        effortSelector: string | null;
+        reasoningModeSelector: string | null;
+        serviceTierSelector: string | null;
+        selectedRoute: string;
+    }, {
+        provider: string;
+        modelSelector: string | null;
+        effortSelector: string | null;
+        reasoningModeSelector: string | null;
+        serviceTierSelector: string | null;
+        selectedRoute: string;
+    }>;
+    rejection: z.ZodObject<{
+        code: z.ZodEffects<z.ZodString, string, string>;
+        rejectedAt: z.ZodString;
+        provesNoChildStarted: z.ZodLiteral<true>;
+    } & {
+        source: z.ZodLiteral<"provider-wrapper">;
+    }, "strict", z.ZodTypeAny, {
+        code: string;
+        rejectedAt: string;
+        provesNoChildStarted: true;
+        source: "provider-wrapper";
+    }, {
+        code: string;
+        rejectedAt: string;
+        provesNoChildStarted: true;
+        source: "provider-wrapper";
+    }>;
+    roleInstructions: z.ZodObject<{
+        status: z.ZodLiteral<"resolved">;
+        dependency: z.ZodString;
+        canonicalRole: z.ZodString;
+        tier: z.ZodEnum<["loaded", "user", "project"]>;
+        validation: z.ZodEnum<["direct-canonical", "exact-canonical-symlink"]>;
+        canonicalPath: z.ZodString;
+        selectedPath: z.ZodString;
+        roleVersion: z.ZodString;
+        contentDigest: z.ZodString;
+        candidateMisses: z.ZodArray<z.ZodObject<{
+            tier: z.ZodEnum<["loaded", "user", "project"]>;
+            candidate: z.ZodString;
+            outcome: z.ZodEnum<["missing", "broken-symlink", "escaping-symlink", "noncanonical-copy", "wrong-target", "invalid-role"]>;
+        }, "strict", z.ZodTypeAny, {
+            tier: "loaded" | "project" | "user";
+            candidate: string;
+            outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+        }, {
+            tier: "loaded" | "project" | "user";
+            candidate: string;
+            outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+        }>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        status: "resolved";
+        dependency: string;
+        canonicalRole: string;
+        tier: "loaded" | "project" | "user";
+        validation: "direct-canonical" | "exact-canonical-symlink";
+        canonicalPath: string;
+        selectedPath: string;
+        roleVersion: string;
+        contentDigest: string;
+        candidateMisses: {
+            tier: "loaded" | "project" | "user";
+            candidate: string;
+            outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+        }[];
+    }, {
+        status: "resolved";
+        dependency: string;
+        canonicalRole: string;
+        tier: "loaded" | "project" | "user";
+        validation: "direct-canonical" | "exact-canonical-symlink";
+        canonicalPath: string;
+        selectedPath: string;
+        roleVersion: string;
+        contentDigest: string;
+        candidateMisses: {
+            tier: "loaded" | "project" | "user";
+            candidate: string;
+            outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+        }[];
+    }>;
+}, "strict", z.ZodTypeAny, {
+    status: "fallback-dispatch";
+    triggerRequestId: string;
+    fallbackRequestId: string;
+    trigger: "pre-start-rejection";
+    fallbackReason: string;
+    kind: "canonical-instruction-fresh-child";
+    approximation: true;
+    preservedTarget: {
+        provider: string;
+        modelSelector: string | null;
+        effortSelector: string | null;
+        reasoningModeSelector: string | null;
+        serviceTierSelector: string | null;
+        selectedRoute: string;
+    };
+    rejection: {
+        code: string;
+        rejectedAt: string;
+        provesNoChildStarted: true;
+        source: "provider-wrapper";
+    };
+    roleInstructions: {
+        status: "resolved";
+        dependency: string;
+        canonicalRole: string;
+        tier: "loaded" | "project" | "user";
+        validation: "direct-canonical" | "exact-canonical-symlink";
+        canonicalPath: string;
+        selectedPath: string;
+        roleVersion: string;
+        contentDigest: string;
+        candidateMisses: {
+            tier: "loaded" | "project" | "user";
+            candidate: string;
+            outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+        }[];
+    };
+}, {
+    status: "fallback-dispatch";
+    triggerRequestId: string;
+    fallbackRequestId: string;
+    trigger: "pre-start-rejection";
+    fallbackReason: string;
+    kind: "canonical-instruction-fresh-child";
+    approximation: true;
+    preservedTarget: {
+        provider: string;
+        modelSelector: string | null;
+        effortSelector: string | null;
+        reasoningModeSelector: string | null;
+        serviceTierSelector: string | null;
+        selectedRoute: string;
+    };
+    rejection: {
+        code: string;
+        rejectedAt: string;
+        provesNoChildStarted: true;
+        source: "provider-wrapper";
+    };
+    roleInstructions: {
+        status: "resolved";
+        dependency: string;
+        canonicalRole: string;
+        tier: "loaded" | "project" | "user";
+        validation: "direct-canonical" | "exact-canonical-symlink";
+        canonicalPath: string;
+        selectedPath: string;
+        roleVersion: string;
+        contentDigest: string;
+        candidateMisses: {
+            tier: "loaded" | "project" | "user";
+            candidate: string;
+            outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+        }[];
+    };
+}>]>;
+/**
+ * The single canonical observation-value validator. Both the metadata path and
+ * a caller-supplied observation resolve through it, so a value can never be
+ * stored on one path that would be refused on the other.
+ */
+export declare function observationIdentifier(value: unknown): string | null;
+declare const runtimeObservationSchema: z.ZodDiscriminatedUnion<"status", [z.ZodObject<{
+    status: z.ZodLiteral<"not-reported">;
+}, "strict", z.ZodTypeAny, {
+    status: "not-reported";
+}, {
+    status: "not-reported";
+}>, z.ZodObject<{
+    status: z.ZodLiteral<"reported">;
+    provider: z.ZodString;
+    childLineage: z.ZodOptional<z.ZodString>;
+    role: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    effort: z.ZodOptional<z.ZodString>;
+    serviceTier: z.ZodOptional<z.ZodString>;
+    source: z.ZodString;
+    observedAt: z.ZodString;
+    match: z.ZodEnum<["matching", "mismatching", "not-comparable"]>;
+    /**
+     * The axes the verdict actually rests on. Optional so a record written
+     * before this field existed still parses, but always written now: a
+     * `matching` that rests on one incidental axis is a materially weaker
+     * claim than one resting on model and role, and a consumer reading only
+     * the scalar `match` cannot tell them apart.
+     */
+    comparedAxes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    status: "reported";
+    provider: string;
+    childLineage?: string | undefined;
+    role?: string | undefined;
+    model?: string | undefined;
+    effort?: string | undefined;
+    serviceTier?: string | undefined;
+    source: string;
+    observedAt: string;
+    match: "matching" | "mismatching" | "not-comparable";
+    comparedAxes?: string[] | undefined;
+}, {
+    status: "reported";
+    provider: string;
+    childLineage?: string | undefined;
+    role?: string | undefined;
+    model?: string | undefined;
+    effort?: string | undefined;
+    serviceTier?: string | undefined;
+    source: string;
+    observedAt: string;
+    match: "matching" | "mismatching" | "not-comparable";
+    comparedAxes?: string[] | undefined;
+}>]>;
+/**
+ * The comparable axes a provider may report about its own child. Every field is
+ * optional: a provider that does not expose an axis reports nothing for it, and
+ * an axis a provider genuinely does not have reports the literal `not-exposed`.
+ * That value is reserved for a truly absent axis: an axis that simply went
+ * unreported on a given run is left absent instead, so the two cases stay
+ * distinguishable.
+ * Nothing here is ever populated from the configured invocation.
+ */
+export interface ObservedRuntimeMetadata {
+    childLineage?: string | null;
+    role?: string | null;
+    model?: string | null;
+    effort?: string | null;
+    serviceTier?: string | null;
+}
+/**
+ * The immutable configured invocation an observation is compared against. It is
+ * read-only input to the comparison and is never written into an observation.
+ *
+ * An axis may carry several equally authoritative configured spellings — a
+ * canonical role name and the materialized native selector that expresses it,
+ * for example. Observing any one of them is agreement; treating the alternate
+ * spelling as disagreement would manufacture a false mismatch.
+ */
+export type ConfiguredObservationAxis = string | readonly string[] | null | undefined;
+export interface ConfiguredInvocationForObservation {
+    role?: ConfiguredObservationAxis;
+    model?: ConfiguredObservationAxis;
+    effort?: ConfiguredObservationAxis;
+    serviceTier?: ConfiguredObservationAxis;
+}
+/** The literal an axis carries when the provider exposes no selectable value. */
+export declare const NOT_EXPOSED_OBSERVATION_VALUE = "not-exposed";
+/**
+ * Project the record's immutable configured selection axes for comparison.
+ *
+ * This is a read-only projection: it never mutates the record, and its output
+ * is only ever compared against, never copied into, an observation.
+ */
+export declare function configuredInvocationForObservation(record: GenericDispatchRecord): ConfiguredInvocationForObservation;
+export type RuntimeObservationMatch = 'matching' | 'mismatching' | 'not-comparable';
+/**
+ * Compare observed metadata with the configured invocation.
+ *
+ * Only axes both sides report are compared. With no comparable axis the result
+ * is `not-comparable` rather than `matching`: silence is never agreement. A
+ * mismatch is evidence only — it never authorizes replacement, retry, or
+ * fallback.
+ */
+export declare function comparedObservationAxes(metadata: ObservedRuntimeMetadata, configured: ConfiguredInvocationForObservation | null | undefined): string[];
+export declare function compareObservedRuntimeMetadata(metadata: ObservedRuntimeMetadata, configured: ConfiguredInvocationForObservation | null | undefined): RuntimeObservationMatch;
+/**
+ * Build one source-qualified runtime observation.
+ *
+ * Absent, empty, or schema-invalid metadata yields `not-reported`. The
+ * configured invocation is only ever read for the comparison, so a parse
+ * failure cannot copy a requested value into observed state.
+ */
+export declare function buildRuntimeObservation(input: {
+    provider: string;
+    source: string;
+    observedAt: string;
+    metadata: ObservedRuntimeMetadata | null;
+    configured?: ConfiguredInvocationForObservation | null;
+}): RuntimeObservation;
+/**
+ * The rejected trigger owns the single-fallback right. Publishing a fallback
+ * record requires this durable claim on the trigger first, so two concurrent
+ * callers cannot each observe "no fallback yet" and then create their own.
+ */
+declare const fallbackClaimSchema: z.ZodObject<{
+    fallbackRequestId: z.ZodString;
+    claimedAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    fallbackRequestId: string;
+    claimedAt: string;
+}, {
+    fallbackRequestId: string;
+    claimedAt: string;
+}>;
+export type FallbackClaim = z.infer<typeof fallbackClaimSchema>;
+export declare const persistedOatDispatchRecordSchema: z.ZodObject<{
+    request_id: z.ZodString;
+    caller: z.ZodString;
+    scope: z.ZodString;
+    objective: z.ZodString;
+    action: z.ZodString;
+    role_name: z.ZodString;
+    role_class: z.ZodString;
+    provider: z.ZodString;
+    dispatch_context: z.ZodString;
+    dispatch_policy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    dispatch_ceiling: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    catalog_snapshot: z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodString;
+        observed_at: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        source: string;
+        observed_at: string;
+    }, {
+        id: string;
+        source: string;
+        observed_at: string;
+    }>;
+    authority: z.ZodString;
+    role_selector: z.ZodNullable<z.ZodString>;
+    model_selector: z.ZodNullable<z.ZodString>;
+    model_selector_granularity: z.ZodNullable<z.ZodString>;
+    effort_selector: z.ZodNullable<z.ZodString>;
+    reasoning_mode_selector: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    service_tier_selector: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    guidance_reference: z.ZodOptional<z.ZodString>;
+    guidance_version: z.ZodOptional<z.ZodString>;
+    guidance_verified_at: z.ZodOptional<z.ZodString>;
+    guidance_status: z.ZodOptional<z.ZodEnum<["fresh", "review-required", "stale"]>>;
+    selection_source: z.ZodEnum<["native-default", "policy-resolved", "explicit-user"]>;
+    candidates_considered: z.ZodArray<z.ZodString, "many">;
+    selection_reason: z.ZodEnum<["native-catalog", "native-catalog-unsatisfying", "pre-start-rejection", "inherit", "gate-target"]>;
+    selected_route: z.ZodString;
+    deadline_seconds: z.ZodNumber;
+    retry_limit: z.ZodNumber;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    launch_status: z.ZodEnum<["planned", "accepted", "blocked-before-start"]>;
+    child_outcome: z.ZodNullable<z.ZodString>;
+    configured_invocation_evidence: z.ZodArray<z.ZodUnknown, "many">;
+    runtime_confirmation: z.ZodString;
+    diagnostics: z.ZodArray<z.ZodString, "many">;
+    continuation_events: z.ZodArray<z.ZodUnknown, "many">;
+    fallback: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodString;
+        target: z.ZodOptional<z.ZodString>;
+        allow_below_task_class_floor: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        mode: string;
+        target?: string | undefined;
+        allow_below_task_class_floor?: boolean | undefined;
+    }, {
+        mode: string;
+        target?: string | undefined;
+        allow_below_task_class_floor?: boolean | undefined;
+    }>>;
+    task_class: z.ZodOptional<z.ZodEnum<["mechanical-recon", "intelligent-recon", "default-implementation", "hard-reasoning", "consequential"]>>;
+    model_class_floor: z.ZodOptional<z.ZodString>;
+    classification_source: z.ZodOptional<z.ZodLiteral<"caller">>;
+    classification_reason: z.ZodOptional<z.ZodString>;
+    floor_satisfaction: z.ZodOptional<z.ZodEnum<["satisfied", "unsatisfied"]>>;
+    authorization_scope: z.ZodOptional<z.ZodString>;
+    expected_output: z.ZodOptional<z.ZodString>;
+    verification_evidence: z.ZodOptional<z.ZodString>;
+    escalate_when: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+} & {
+    oat: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        canonicalRole: z.ZodNullable<z.ZodDiscriminatedUnion<"status", [z.ZodObject<{
+            status: z.ZodLiteral<"resolved">;
+            dependency: z.ZodString;
+            canonicalRole: z.ZodString;
+            tier: z.ZodEnum<["loaded", "user", "project"]>;
+            validation: z.ZodEnum<["direct-canonical", "exact-canonical-symlink"]>;
+            canonicalPath: z.ZodString;
+            selectedPath: z.ZodString;
+            roleVersion: z.ZodString;
+            contentDigest: z.ZodString;
+            candidateMisses: z.ZodArray<z.ZodObject<{
+                tier: z.ZodEnum<["loaded", "user", "project"]>;
+                candidate: z.ZodString;
+                outcome: z.ZodEnum<["missing", "broken-symlink", "escaping-symlink", "noncanonical-copy", "wrong-target", "invalid-role"]>;
+            }, "strict", z.ZodTypeAny, {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }, {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }>, "many">;
+        }, "strict", z.ZodTypeAny, {
+            status: "resolved";
+            dependency: string;
+            canonicalRole: string;
+            tier: "loaded" | "project" | "user";
+            validation: "direct-canonical" | "exact-canonical-symlink";
+            canonicalPath: string;
+            selectedPath: string;
+            roleVersion: string;
+            contentDigest: string;
+            candidateMisses: {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }[];
+        }, {
+            status: "resolved";
+            dependency: string;
+            canonicalRole: string;
+            tier: "loaded" | "project" | "user";
+            validation: "direct-canonical" | "exact-canonical-symlink";
+            canonicalPath: string;
+            selectedPath: string;
+            roleVersion: string;
+            contentDigest: string;
+            candidateMisses: {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }[];
+        }>, z.ZodObject<{
+            status: z.ZodLiteral<"missing">;
+            dependency: z.ZodString;
+            canonicalRole: z.ZodString;
+            candidateMisses: z.ZodArray<z.ZodObject<{
+                tier: z.ZodEnum<["loaded", "user", "project"]>;
+                candidate: z.ZodString;
+                outcome: z.ZodEnum<["missing", "broken-symlink", "escaping-symlink", "noncanonical-copy", "wrong-target", "invalid-role"]>;
+            }, "strict", z.ZodTypeAny, {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }, {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }>, "many">;
+            recovery: z.ZodArray<z.ZodObject<{
+                command: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                command: string;
+            }, {
+                command: string;
+            }>, "many">;
+        }, "strict", z.ZodTypeAny, {
+            status: "missing";
+            dependency: string;
+            canonicalRole: string;
+            candidateMisses: {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }[];
+            recovery: {
+                command: string;
+            }[];
+        }, {
+            status: "missing";
+            dependency: string;
+            canonicalRole: string;
+            candidateMisses: {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }[];
+            recovery: {
+                command: string;
+            }[];
+        }>]>>;
+        preStartRejection: z.ZodNullable<z.ZodObject<{
+            code: z.ZodEffects<z.ZodString, string, string>;
+            rejectedAt: z.ZodString;
+            provesNoChildStarted: z.ZodLiteral<true>;
+        }, "strict", z.ZodTypeAny, {
+            code: string;
+            rejectedAt: string;
+            provesNoChildStarted: true;
+        }, {
+            code: string;
+            rejectedAt: string;
+            provesNoChildStarted: true;
+        }>>;
+        fallbackClaim: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            fallbackRequestId: z.ZodString;
+            claimedAt: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            fallbackRequestId: string;
+            claimedAt: string;
+        }, {
+            fallbackRequestId: string;
+            claimedAt: string;
+        }>>>;
+        fallback: z.ZodDiscriminatedUnion<"status", [z.ZodObject<{
+            status: z.ZodLiteral<"not-applicable">;
+            reason: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            status: "not-applicable";
+            reason: string;
+        }, {
+            status: "not-applicable";
+            reason: string;
+        }>, z.ZodObject<{
+            status: z.ZodLiteral<"fallback-dispatch">;
+            triggerRequestId: z.ZodString;
+            fallbackRequestId: z.ZodString;
+            trigger: z.ZodLiteral<"pre-start-rejection">;
+            fallbackReason: z.ZodString;
+            kind: z.ZodLiteral<"canonical-instruction-fresh-child">;
+            approximation: z.ZodLiteral<true>;
+            preservedTarget: z.ZodObject<{
+                provider: z.ZodString;
+                modelSelector: z.ZodNullable<z.ZodString>;
+                effortSelector: z.ZodNullable<z.ZodString>;
+                reasoningModeSelector: z.ZodNullable<z.ZodString>;
+                serviceTierSelector: z.ZodNullable<z.ZodString>;
+                selectedRoute: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                provider: string;
+                modelSelector: string | null;
+                effortSelector: string | null;
+                reasoningModeSelector: string | null;
+                serviceTierSelector: string | null;
+                selectedRoute: string;
+            }, {
+                provider: string;
+                modelSelector: string | null;
+                effortSelector: string | null;
+                reasoningModeSelector: string | null;
+                serviceTierSelector: string | null;
+                selectedRoute: string;
+            }>;
+            rejection: z.ZodObject<{
+                code: z.ZodEffects<z.ZodString, string, string>;
+                rejectedAt: z.ZodString;
+                provesNoChildStarted: z.ZodLiteral<true>;
+            } & {
+                source: z.ZodLiteral<"provider-wrapper">;
+            }, "strict", z.ZodTypeAny, {
+                code: string;
+                rejectedAt: string;
+                provesNoChildStarted: true;
+                source: "provider-wrapper";
+            }, {
+                code: string;
+                rejectedAt: string;
+                provesNoChildStarted: true;
+                source: "provider-wrapper";
+            }>;
+            roleInstructions: z.ZodObject<{
+                status: z.ZodLiteral<"resolved">;
+                dependency: z.ZodString;
+                canonicalRole: z.ZodString;
+                tier: z.ZodEnum<["loaded", "user", "project"]>;
+                validation: z.ZodEnum<["direct-canonical", "exact-canonical-symlink"]>;
+                canonicalPath: z.ZodString;
+                selectedPath: z.ZodString;
+                roleVersion: z.ZodString;
+                contentDigest: z.ZodString;
+                candidateMisses: z.ZodArray<z.ZodObject<{
+                    tier: z.ZodEnum<["loaded", "user", "project"]>;
+                    candidate: z.ZodString;
+                    outcome: z.ZodEnum<["missing", "broken-symlink", "escaping-symlink", "noncanonical-copy", "wrong-target", "invalid-role"]>;
+                }, "strict", z.ZodTypeAny, {
+                    tier: "loaded" | "project" | "user";
+                    candidate: string;
+                    outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+                }, {
+                    tier: "loaded" | "project" | "user";
+                    candidate: string;
+                    outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+                }>, "many">;
+            }, "strict", z.ZodTypeAny, {
+                status: "resolved";
+                dependency: string;
+                canonicalRole: string;
+                tier: "loaded" | "project" | "user";
+                validation: "direct-canonical" | "exact-canonical-symlink";
+                canonicalPath: string;
+                selectedPath: string;
+                roleVersion: string;
+                contentDigest: string;
+                candidateMisses: {
+                    tier: "loaded" | "project" | "user";
+                    candidate: string;
+                    outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+                }[];
+            }, {
+                status: "resolved";
+                dependency: string;
+                canonicalRole: string;
+                tier: "loaded" | "project" | "user";
+                validation: "direct-canonical" | "exact-canonical-symlink";
+                canonicalPath: string;
+                selectedPath: string;
+                roleVersion: string;
+                contentDigest: string;
+                candidateMisses: {
+                    tier: "loaded" | "project" | "user";
+                    candidate: string;
+                    outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+                }[];
+            }>;
+        }, "strict", z.ZodTypeAny, {
+            status: "fallback-dispatch";
+            triggerRequestId: string;
+            fallbackRequestId: string;
+            trigger: "pre-start-rejection";
+            fallbackReason: string;
+            kind: "canonical-instruction-fresh-child";
+            approximation: true;
+            preservedTarget: {
+                provider: string;
+                modelSelector: string | null;
+                effortSelector: string | null;
+                reasoningModeSelector: string | null;
+                serviceTierSelector: string | null;
+                selectedRoute: string;
+            };
+            rejection: {
+                code: string;
+                rejectedAt: string;
+                provesNoChildStarted: true;
+                source: "provider-wrapper";
+            };
+            roleInstructions: {
+                status: "resolved";
+                dependency: string;
+                canonicalRole: string;
+                tier: "loaded" | "project" | "user";
+                validation: "direct-canonical" | "exact-canonical-symlink";
+                canonicalPath: string;
+                selectedPath: string;
+                roleVersion: string;
+                contentDigest: string;
+                candidateMisses: {
+                    tier: "loaded" | "project" | "user";
+                    candidate: string;
+                    outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+                }[];
+            };
+        }, {
+            status: "fallback-dispatch";
+            triggerRequestId: string;
+            fallbackRequestId: string;
+            trigger: "pre-start-rejection";
+            fallbackReason: string;
+            kind: "canonical-instruction-fresh-child";
+            approximation: true;
+            preservedTarget: {
+                provider: string;
+                modelSelector: string | null;
+                effortSelector: string | null;
+                reasoningModeSelector: string | null;
+                serviceTierSelector: string | null;
+                selectedRoute: string;
+            };
+            rejection: {
+                code: string;
+                rejectedAt: string;
+                provesNoChildStarted: true;
+                source: "provider-wrapper";
+            };
+            roleInstructions: {
+                status: "resolved";
+                dependency: string;
+                canonicalRole: string;
+                tier: "loaded" | "project" | "user";
+                validation: "direct-canonical" | "exact-canonical-symlink";
+                canonicalPath: string;
+                selectedPath: string;
+                roleVersion: string;
+                contentDigest: string;
+                candidateMisses: {
+                    tier: "loaded" | "project" | "user";
+                    candidate: string;
+                    outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+                }[];
+            };
+        }>]>;
+        runtimeObservation: z.ZodDiscriminatedUnion<"status", [z.ZodObject<{
+            status: z.ZodLiteral<"not-reported">;
+        }, "strict", z.ZodTypeAny, {
+            status: "not-reported";
+        }, {
+            status: "not-reported";
+        }>, z.ZodObject<{
+            status: z.ZodLiteral<"reported">;
+            provider: z.ZodString;
+            childLineage: z.ZodOptional<z.ZodString>;
+            role: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+            effort: z.ZodOptional<z.ZodString>;
+            serviceTier: z.ZodOptional<z.ZodString>;
+            source: z.ZodString;
+            observedAt: z.ZodString;
+            match: z.ZodEnum<["matching", "mismatching", "not-comparable"]>;
+            /**
+             * The axes the verdict actually rests on. Optional so a record written
+             * before this field existed still parses, but always written now: a
+             * `matching` that rests on one incidental axis is a materially weaker
+             * claim than one resting on model and role, and a consumer reading only
+             * the scalar `match` cannot tell them apart.
+             */
+            comparedAxes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strict", z.ZodTypeAny, {
+            status: "reported";
+            provider: string;
+            childLineage?: string | undefined;
+            role?: string | undefined;
+            model?: string | undefined;
+            effort?: string | undefined;
+            serviceTier?: string | undefined;
+            source: string;
+            observedAt: string;
+            match: "matching" | "mismatching" | "not-comparable";
+            comparedAxes?: string[] | undefined;
+        }, {
+            status: "reported";
+            provider: string;
+            childLineage?: string | undefined;
+            role?: string | undefined;
+            model?: string | undefined;
+            effort?: string | undefined;
+            serviceTier?: string | undefined;
+            source: string;
+            observedAt: string;
+            match: "matching" | "mismatching" | "not-comparable";
+            comparedAxes?: string[] | undefined;
+        }>]>;
+    }, "strict", z.ZodTypeAny, {
+        schemaVersion: 1;
+        canonicalRole: {
+            status: "resolved";
+            dependency: string;
+            canonicalRole: string;
+            tier: "loaded" | "project" | "user";
+            validation: "direct-canonical" | "exact-canonical-symlink";
+            canonicalPath: string;
+            selectedPath: string;
+            roleVersion: string;
+            contentDigest: string;
+            candidateMisses: {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }[];
+        } | {
+            status: "missing";
+            dependency: string;
+            canonicalRole: string;
+            candidateMisses: {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }[];
+            recovery: {
+                command: string;
+            }[];
+        } | null;
+        preStartRejection: {
+            code: string;
+            rejectedAt: string;
+            provesNoChildStarted: true;
+        } | null;
+        fallbackClaim: {
+            fallbackRequestId: string;
+            claimedAt: string;
+        } | null;
+        fallback: {
+            status: "fallback-dispatch";
+            triggerRequestId: string;
+            fallbackRequestId: string;
+            trigger: "pre-start-rejection";
+            fallbackReason: string;
+            kind: "canonical-instruction-fresh-child";
+            approximation: true;
+            preservedTarget: {
+                provider: string;
+                modelSelector: string | null;
+                effortSelector: string | null;
+                reasoningModeSelector: string | null;
+                serviceTierSelector: string | null;
+                selectedRoute: string;
+            };
+            rejection: {
+                code: string;
+                rejectedAt: string;
+                provesNoChildStarted: true;
+                source: "provider-wrapper";
+            };
+            roleInstructions: {
+                status: "resolved";
+                dependency: string;
+                canonicalRole: string;
+                tier: "loaded" | "project" | "user";
+                validation: "direct-canonical" | "exact-canonical-symlink";
+                canonicalPath: string;
+                selectedPath: string;
+                roleVersion: string;
+                contentDigest: string;
+                candidateMisses: {
+                    tier: "loaded" | "project" | "user";
+                    candidate: string;
+                    outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+                }[];
+            };
+        } | {
+            status: "not-applicable";
+            reason: string;
+        };
+        runtimeObservation: {
+            status: "not-reported";
+        } | {
+            status: "reported";
+            provider: string;
+            childLineage?: string | undefined;
+            role?: string | undefined;
+            model?: string | undefined;
+            effort?: string | undefined;
+            serviceTier?: string | undefined;
+            source: string;
+            observedAt: string;
+            match: "matching" | "mismatching" | "not-comparable";
+            comparedAxes?: string[] | undefined;
+        };
+    }, {
+        schemaVersion: 1;
+        canonicalRole: {
+            status: "resolved";
+            dependency: string;
+            canonicalRole: string;
+            tier: "loaded" | "project" | "user";
+            validation: "direct-canonical" | "exact-canonical-symlink";
+            canonicalPath: string;
+            selectedPath: string;
+            roleVersion: string;
+            contentDigest: string;
+            candidateMisses: {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }[];
+        } | {
+            status: "missing";
+            dependency: string;
+            canonicalRole: string;
+            candidateMisses: {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }[];
+            recovery: {
+                command: string;
+            }[];
+        } | null;
+        preStartRejection: {
+            code: string;
+            rejectedAt: string;
+            provesNoChildStarted: true;
+        } | null;
+        fallbackClaim?: {
+            fallbackRequestId: string;
+            claimedAt: string;
+        } | null | undefined;
+        fallback: {
+            status: "fallback-dispatch";
+            triggerRequestId: string;
+            fallbackRequestId: string;
+            trigger: "pre-start-rejection";
+            fallbackReason: string;
+            kind: "canonical-instruction-fresh-child";
+            approximation: true;
+            preservedTarget: {
+                provider: string;
+                modelSelector: string | null;
+                effortSelector: string | null;
+                reasoningModeSelector: string | null;
+                serviceTierSelector: string | null;
+                selectedRoute: string;
+            };
+            rejection: {
+                code: string;
+                rejectedAt: string;
+                provesNoChildStarted: true;
+                source: "provider-wrapper";
+            };
+            roleInstructions: {
+                status: "resolved";
+                dependency: string;
+                canonicalRole: string;
+                tier: "loaded" | "project" | "user";
+                validation: "direct-canonical" | "exact-canonical-symlink";
+                canonicalPath: string;
+                selectedPath: string;
+                roleVersion: string;
+                contentDigest: string;
+                candidateMisses: {
+                    tier: "loaded" | "project" | "user";
+                    candidate: string;
+                    outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+                }[];
+            };
+        } | {
+            status: "not-applicable";
+            reason: string;
+        };
+        runtimeObservation: {
+            status: "not-reported";
+        } | {
+            status: "reported";
+            provider: string;
+            childLineage?: string | undefined;
+            role?: string | undefined;
+            model?: string | undefined;
+            effort?: string | undefined;
+            serviceTier?: string | undefined;
+            source: string;
+            observedAt: string;
+            match: "matching" | "mismatching" | "not-comparable";
+            comparedAxes?: string[] | undefined;
+        };
+    }>;
+}, "strict", z.ZodTypeAny, {
+    request_id: string;
+    caller: string;
+    scope: string;
+    objective: string;
+    action: string;
+    role_name: string;
+    role_class: string;
+    provider: string;
+    dispatch_context: string;
+    dispatch_policy?: string | null | undefined;
+    dispatch_ceiling?: string | null | undefined;
+    catalog_snapshot: {
+        id: string;
+        source: string;
+        observed_at: string;
+    };
+    authority: string;
+    role_selector: string | null;
+    model_selector: string | null;
+    model_selector_granularity: string | null;
+    effort_selector: string | null;
+    reasoning_mode_selector?: string | null | undefined;
+    service_tier_selector?: string | null | undefined;
+    guidance_reference?: string | undefined;
+    guidance_version?: string | undefined;
+    guidance_verified_at?: string | undefined;
+    guidance_status?: "fresh" | "review-required" | "stale" | undefined;
+    selection_source: "explicit-user" | "native-default" | "policy-resolved";
+    candidates_considered: string[];
+    selection_reason: "gate-target" | "inherit" | "native-catalog" | "native-catalog-unsatisfying" | "pre-start-rejection";
+    selected_route: string;
+    deadline_seconds: number;
+    retry_limit: number;
+    payload: Record<string, unknown>;
+    launch_status: "accepted" | "blocked-before-start" | "planned";
+    child_outcome: string | null;
+    configured_invocation_evidence: unknown[];
+    runtime_confirmation: string;
+    diagnostics: string[];
+    continuation_events: unknown[];
+    fallback?: {
+        mode: string;
+        target?: string | undefined;
+        allow_below_task_class_floor?: boolean | undefined;
+    } | undefined;
+    task_class?: "consequential" | "default-implementation" | "hard-reasoning" | "intelligent-recon" | "mechanical-recon" | undefined;
+    model_class_floor?: string | undefined;
+    classification_source?: "caller" | undefined;
+    classification_reason?: string | undefined;
+    floor_satisfaction?: "satisfied" | "unsatisfied" | undefined;
+    authorization_scope?: string | undefined;
+    expected_output?: string | undefined;
+    verification_evidence?: string | undefined;
+    escalate_when?: string[] | undefined;
+    oat: {
+        schemaVersion: 1;
+        canonicalRole: {
+            status: "resolved";
+            dependency: string;
+            canonicalRole: string;
+            tier: "loaded" | "project" | "user";
+            validation: "direct-canonical" | "exact-canonical-symlink";
+            canonicalPath: string;
+            selectedPath: string;
+            roleVersion: string;
+            contentDigest: string;
+            candidateMisses: {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }[];
+        } | {
+            status: "missing";
+            dependency: string;
+            canonicalRole: string;
+            candidateMisses: {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }[];
+            recovery: {
+                command: string;
+            }[];
+        } | null;
+        preStartRejection: {
+            code: string;
+            rejectedAt: string;
+            provesNoChildStarted: true;
+        } | null;
+        fallbackClaim: {
+            fallbackRequestId: string;
+            claimedAt: string;
+        } | null;
+        fallback: {
+            status: "fallback-dispatch";
+            triggerRequestId: string;
+            fallbackRequestId: string;
+            trigger: "pre-start-rejection";
+            fallbackReason: string;
+            kind: "canonical-instruction-fresh-child";
+            approximation: true;
+            preservedTarget: {
+                provider: string;
+                modelSelector: string | null;
+                effortSelector: string | null;
+                reasoningModeSelector: string | null;
+                serviceTierSelector: string | null;
+                selectedRoute: string;
+            };
+            rejection: {
+                code: string;
+                rejectedAt: string;
+                provesNoChildStarted: true;
+                source: "provider-wrapper";
+            };
+            roleInstructions: {
+                status: "resolved";
+                dependency: string;
+                canonicalRole: string;
+                tier: "loaded" | "project" | "user";
+                validation: "direct-canonical" | "exact-canonical-symlink";
+                canonicalPath: string;
+                selectedPath: string;
+                roleVersion: string;
+                contentDigest: string;
+                candidateMisses: {
+                    tier: "loaded" | "project" | "user";
+                    candidate: string;
+                    outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+                }[];
+            };
+        } | {
+            status: "not-applicable";
+            reason: string;
+        };
+        runtimeObservation: {
+            status: "not-reported";
+        } | {
+            status: "reported";
+            provider: string;
+            childLineage?: string | undefined;
+            role?: string | undefined;
+            model?: string | undefined;
+            effort?: string | undefined;
+            serviceTier?: string | undefined;
+            source: string;
+            observedAt: string;
+            match: "matching" | "mismatching" | "not-comparable";
+            comparedAxes?: string[] | undefined;
+        };
+    };
+}, {
+    request_id: string;
+    caller: string;
+    scope: string;
+    objective: string;
+    action: string;
+    role_name: string;
+    role_class: string;
+    provider: string;
+    dispatch_context: string;
+    dispatch_policy?: string | null | undefined;
+    dispatch_ceiling?: string | null | undefined;
+    catalog_snapshot: {
+        id: string;
+        source: string;
+        observed_at: string;
+    };
+    authority: string;
+    role_selector: string | null;
+    model_selector: string | null;
+    model_selector_granularity: string | null;
+    effort_selector: string | null;
+    reasoning_mode_selector?: string | null | undefined;
+    service_tier_selector?: string | null | undefined;
+    guidance_reference?: string | undefined;
+    guidance_version?: string | undefined;
+    guidance_verified_at?: string | undefined;
+    guidance_status?: "fresh" | "review-required" | "stale" | undefined;
+    selection_source: "explicit-user" | "native-default" | "policy-resolved";
+    candidates_considered: string[];
+    selection_reason: "gate-target" | "inherit" | "native-catalog" | "native-catalog-unsatisfying" | "pre-start-rejection";
+    selected_route: string;
+    deadline_seconds: number;
+    retry_limit: number;
+    payload: Record<string, unknown>;
+    launch_status: "accepted" | "blocked-before-start" | "planned";
+    child_outcome: string | null;
+    configured_invocation_evidence: unknown[];
+    runtime_confirmation: string;
+    diagnostics: string[];
+    continuation_events: unknown[];
+    fallback?: {
+        mode: string;
+        target?: string | undefined;
+        allow_below_task_class_floor?: boolean | undefined;
+    } | undefined;
+    task_class?: "consequential" | "default-implementation" | "hard-reasoning" | "intelligent-recon" | "mechanical-recon" | undefined;
+    model_class_floor?: string | undefined;
+    classification_source?: "caller" | undefined;
+    classification_reason?: string | undefined;
+    floor_satisfaction?: "satisfied" | "unsatisfied" | undefined;
+    authorization_scope?: string | undefined;
+    expected_output?: string | undefined;
+    verification_evidence?: string | undefined;
+    escalate_when?: string[] | undefined;
+    oat: {
+        schemaVersion: 1;
+        canonicalRole: {
+            status: "resolved";
+            dependency: string;
+            canonicalRole: string;
+            tier: "loaded" | "project" | "user";
+            validation: "direct-canonical" | "exact-canonical-symlink";
+            canonicalPath: string;
+            selectedPath: string;
+            roleVersion: string;
+            contentDigest: string;
+            candidateMisses: {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }[];
+        } | {
+            status: "missing";
+            dependency: string;
+            canonicalRole: string;
+            candidateMisses: {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }[];
+            recovery: {
+                command: string;
+            }[];
+        } | null;
+        preStartRejection: {
+            code: string;
+            rejectedAt: string;
+            provesNoChildStarted: true;
+        } | null;
+        fallbackClaim?: {
+            fallbackRequestId: string;
+            claimedAt: string;
+        } | null | undefined;
+        fallback: {
+            status: "fallback-dispatch";
+            triggerRequestId: string;
+            fallbackRequestId: string;
+            trigger: "pre-start-rejection";
+            fallbackReason: string;
+            kind: "canonical-instruction-fresh-child";
+            approximation: true;
+            preservedTarget: {
+                provider: string;
+                modelSelector: string | null;
+                effortSelector: string | null;
+                reasoningModeSelector: string | null;
+                serviceTierSelector: string | null;
+                selectedRoute: string;
+            };
+            rejection: {
+                code: string;
+                rejectedAt: string;
+                provesNoChildStarted: true;
+                source: "provider-wrapper";
+            };
+            roleInstructions: {
+                status: "resolved";
+                dependency: string;
+                canonicalRole: string;
+                tier: "loaded" | "project" | "user";
+                validation: "direct-canonical" | "exact-canonical-symlink";
+                canonicalPath: string;
+                selectedPath: string;
+                roleVersion: string;
+                contentDigest: string;
+                candidateMisses: {
+                    tier: "loaded" | "project" | "user";
+                    candidate: string;
+                    outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+                }[];
+            };
+        } | {
+            status: "not-applicable";
+            reason: string;
+        };
+        runtimeObservation: {
+            status: "not-reported";
+        } | {
+            status: "reported";
+            provider: string;
+            childLineage?: string | undefined;
+            role?: string | undefined;
+            model?: string | undefined;
+            effort?: string | undefined;
+            serviceTier?: string | undefined;
+            source: string;
+            observedAt: string;
+            match: "matching" | "mismatching" | "not-comparable";
+            comparedAxes?: string[] | undefined;
+        };
+    };
+}>;
+/**
+ * Strict observation parse. Used where a caller supplied the observation
+ * directly, so a malformed value is refused rather than quietly degraded to
+ * `not-reported` — absent evidence and a bad claim are different facts.
+ */
+export declare function parseRuntimeObservation(value: unknown): RuntimeObservation;
+export type CanonicalFallbackEvidence = z.infer<typeof fallbackSchema>;
+export type RuntimeObservation = z.infer<typeof runtimeObservationSchema>;
+export type PersistedOatDispatchRecordV1 = z.infer<typeof persistedOatDispatchRecordSchema>;
+declare const oatDispatchEvidenceEventSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"canonical-role-resolution">;
+    requestId: z.ZodString;
+    source: z.ZodLiteral<"canonical-role-resolver">;
+    evidence: z.ZodDiscriminatedUnion<"status", [z.ZodObject<{
+        status: z.ZodLiteral<"resolved">;
+        dependency: z.ZodString;
+        canonicalRole: z.ZodString;
+        tier: z.ZodEnum<["loaded", "user", "project"]>;
+        validation: z.ZodEnum<["direct-canonical", "exact-canonical-symlink"]>;
+        canonicalPath: z.ZodString;
+        selectedPath: z.ZodString;
+        roleVersion: z.ZodString;
+        contentDigest: z.ZodString;
+        candidateMisses: z.ZodArray<z.ZodObject<{
+            tier: z.ZodEnum<["loaded", "user", "project"]>;
+            candidate: z.ZodString;
+            outcome: z.ZodEnum<["missing", "broken-symlink", "escaping-symlink", "noncanonical-copy", "wrong-target", "invalid-role"]>;
+        }, "strict", z.ZodTypeAny, {
+            tier: "loaded" | "project" | "user";
+            candidate: string;
+            outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+        }, {
+            tier: "loaded" | "project" | "user";
+            candidate: string;
+            outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+        }>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        status: "resolved";
+        dependency: string;
+        canonicalRole: string;
+        tier: "loaded" | "project" | "user";
+        validation: "direct-canonical" | "exact-canonical-symlink";
+        canonicalPath: string;
+        selectedPath: string;
+        roleVersion: string;
+        contentDigest: string;
+        candidateMisses: {
+            tier: "loaded" | "project" | "user";
+            candidate: string;
+            outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+        }[];
+    }, {
+        status: "resolved";
+        dependency: string;
+        canonicalRole: string;
+        tier: "loaded" | "project" | "user";
+        validation: "direct-canonical" | "exact-canonical-symlink";
+        canonicalPath: string;
+        selectedPath: string;
+        roleVersion: string;
+        contentDigest: string;
+        candidateMisses: {
+            tier: "loaded" | "project" | "user";
+            candidate: string;
+            outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+        }[];
+    }>, z.ZodObject<{
+        status: z.ZodLiteral<"missing">;
+        dependency: z.ZodString;
+        canonicalRole: z.ZodString;
+        candidateMisses: z.ZodArray<z.ZodObject<{
+            tier: z.ZodEnum<["loaded", "user", "project"]>;
+            candidate: z.ZodString;
+            outcome: z.ZodEnum<["missing", "broken-symlink", "escaping-symlink", "noncanonical-copy", "wrong-target", "invalid-role"]>;
+        }, "strict", z.ZodTypeAny, {
+            tier: "loaded" | "project" | "user";
+            candidate: string;
+            outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+        }, {
+            tier: "loaded" | "project" | "user";
+            candidate: string;
+            outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+        }>, "many">;
+        recovery: z.ZodArray<z.ZodObject<{
+            command: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            command: string;
+        }, {
+            command: string;
+        }>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        status: "missing";
+        dependency: string;
+        canonicalRole: string;
+        candidateMisses: {
+            tier: "loaded" | "project" | "user";
+            candidate: string;
+            outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+        }[];
+        recovery: {
+            command: string;
+        }[];
+    }, {
+        status: "missing";
+        dependency: string;
+        canonicalRole: string;
+        candidateMisses: {
+            tier: "loaded" | "project" | "user";
+            candidate: string;
+            outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+        }[];
+        recovery: {
+            command: string;
+        }[];
+    }>]>;
+}, "strict", z.ZodTypeAny, {
+    kind: "canonical-role-resolution";
+    requestId: string;
+    source: "canonical-role-resolver";
+    evidence: {
+        status: "resolved";
+        dependency: string;
+        canonicalRole: string;
+        tier: "loaded" | "project" | "user";
+        validation: "direct-canonical" | "exact-canonical-symlink";
+        canonicalPath: string;
+        selectedPath: string;
+        roleVersion: string;
+        contentDigest: string;
+        candidateMisses: {
+            tier: "loaded" | "project" | "user";
+            candidate: string;
+            outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+        }[];
+    } | {
+        status: "missing";
+        dependency: string;
+        canonicalRole: string;
+        candidateMisses: {
+            tier: "loaded" | "project" | "user";
+            candidate: string;
+            outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+        }[];
+        recovery: {
+            command: string;
+        }[];
+    };
+}, {
+    kind: "canonical-role-resolution";
+    requestId: string;
+    source: "canonical-role-resolver";
+    evidence: {
+        status: "resolved";
+        dependency: string;
+        canonicalRole: string;
+        tier: "loaded" | "project" | "user";
+        validation: "direct-canonical" | "exact-canonical-symlink";
+        canonicalPath: string;
+        selectedPath: string;
+        roleVersion: string;
+        contentDigest: string;
+        candidateMisses: {
+            tier: "loaded" | "project" | "user";
+            candidate: string;
+            outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+        }[];
+    } | {
+        status: "missing";
+        dependency: string;
+        canonicalRole: string;
+        candidateMisses: {
+            tier: "loaded" | "project" | "user";
+            candidate: string;
+            outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+        }[];
+        recovery: {
+            command: string;
+        }[];
+    };
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"pre-start-rejection-attestation">;
+    requestId: z.ZodString;
+    source: z.ZodLiteral<"provider-wrapper">;
+    expectedLaunchStatus: z.ZodLiteral<"blocked-before-start">;
+    rejection: z.ZodObject<{
+        code: z.ZodEffects<z.ZodString, string, string>;
+        rejectedAt: z.ZodString;
+        provesNoChildStarted: z.ZodLiteral<true>;
+    }, "strict", z.ZodTypeAny, {
+        code: string;
+        rejectedAt: string;
+        provesNoChildStarted: true;
+    }, {
+        code: string;
+        rejectedAt: string;
+        provesNoChildStarted: true;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    kind: "pre-start-rejection-attestation";
+    requestId: string;
+    source: "provider-wrapper";
+    expectedLaunchStatus: "blocked-before-start";
+    rejection: {
+        code: string;
+        rejectedAt: string;
+        provesNoChildStarted: true;
+    };
+}, {
+    kind: "pre-start-rejection-attestation";
+    requestId: string;
+    source: "provider-wrapper";
+    expectedLaunchStatus: "blocked-before-start";
+    rejection: {
+        code: string;
+        rejectedAt: string;
+        provesNoChildStarted: true;
+    };
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"fallback-claim">;
+    requestId: z.ZodString;
+    source: z.ZodLiteral<"provider-wrapper">;
+    claim: z.ZodObject<{
+        fallbackRequestId: z.ZodString;
+        claimedAt: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        fallbackRequestId: string;
+        claimedAt: string;
+    }, {
+        fallbackRequestId: string;
+        claimedAt: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    kind: "fallback-claim";
+    requestId: string;
+    source: "provider-wrapper";
+    claim: {
+        fallbackRequestId: string;
+        claimedAt: string;
+    };
+}, {
+    kind: "fallback-claim";
+    requestId: string;
+    source: "provider-wrapper";
+    claim: {
+        fallbackRequestId: string;
+        claimedAt: string;
+    };
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"fallback-link">;
+    requestId: z.ZodString;
+    source: z.ZodLiteral<"provider-wrapper">;
+    evidence: z.ZodObject<{
+        status: z.ZodLiteral<"fallback-dispatch">;
+        triggerRequestId: z.ZodString;
+        fallbackRequestId: z.ZodString;
+        trigger: z.ZodLiteral<"pre-start-rejection">;
+        fallbackReason: z.ZodString;
+        kind: z.ZodLiteral<"canonical-instruction-fresh-child">;
+        approximation: z.ZodLiteral<true>;
+        preservedTarget: z.ZodObject<{
+            provider: z.ZodString;
+            modelSelector: z.ZodNullable<z.ZodString>;
+            effortSelector: z.ZodNullable<z.ZodString>;
+            reasoningModeSelector: z.ZodNullable<z.ZodString>;
+            serviceTierSelector: z.ZodNullable<z.ZodString>;
+            selectedRoute: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            provider: string;
+            modelSelector: string | null;
+            effortSelector: string | null;
+            reasoningModeSelector: string | null;
+            serviceTierSelector: string | null;
+            selectedRoute: string;
+        }, {
+            provider: string;
+            modelSelector: string | null;
+            effortSelector: string | null;
+            reasoningModeSelector: string | null;
+            serviceTierSelector: string | null;
+            selectedRoute: string;
+        }>;
+        rejection: z.ZodObject<{
+            code: z.ZodEffects<z.ZodString, string, string>;
+            rejectedAt: z.ZodString;
+            provesNoChildStarted: z.ZodLiteral<true>;
+        } & {
+            source: z.ZodLiteral<"provider-wrapper">;
+        }, "strict", z.ZodTypeAny, {
+            code: string;
+            rejectedAt: string;
+            provesNoChildStarted: true;
+            source: "provider-wrapper";
+        }, {
+            code: string;
+            rejectedAt: string;
+            provesNoChildStarted: true;
+            source: "provider-wrapper";
+        }>;
+        roleInstructions: z.ZodObject<{
+            status: z.ZodLiteral<"resolved">;
+            dependency: z.ZodString;
+            canonicalRole: z.ZodString;
+            tier: z.ZodEnum<["loaded", "user", "project"]>;
+            validation: z.ZodEnum<["direct-canonical", "exact-canonical-symlink"]>;
+            canonicalPath: z.ZodString;
+            selectedPath: z.ZodString;
+            roleVersion: z.ZodString;
+            contentDigest: z.ZodString;
+            candidateMisses: z.ZodArray<z.ZodObject<{
+                tier: z.ZodEnum<["loaded", "user", "project"]>;
+                candidate: z.ZodString;
+                outcome: z.ZodEnum<["missing", "broken-symlink", "escaping-symlink", "noncanonical-copy", "wrong-target", "invalid-role"]>;
+            }, "strict", z.ZodTypeAny, {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }, {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }>, "many">;
+        }, "strict", z.ZodTypeAny, {
+            status: "resolved";
+            dependency: string;
+            canonicalRole: string;
+            tier: "loaded" | "project" | "user";
+            validation: "direct-canonical" | "exact-canonical-symlink";
+            canonicalPath: string;
+            selectedPath: string;
+            roleVersion: string;
+            contentDigest: string;
+            candidateMisses: {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }[];
+        }, {
+            status: "resolved";
+            dependency: string;
+            canonicalRole: string;
+            tier: "loaded" | "project" | "user";
+            validation: "direct-canonical" | "exact-canonical-symlink";
+            canonicalPath: string;
+            selectedPath: string;
+            roleVersion: string;
+            contentDigest: string;
+            candidateMisses: {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }[];
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        status: "fallback-dispatch";
+        triggerRequestId: string;
+        fallbackRequestId: string;
+        trigger: "pre-start-rejection";
+        fallbackReason: string;
+        kind: "canonical-instruction-fresh-child";
+        approximation: true;
+        preservedTarget: {
+            provider: string;
+            modelSelector: string | null;
+            effortSelector: string | null;
+            reasoningModeSelector: string | null;
+            serviceTierSelector: string | null;
+            selectedRoute: string;
+        };
+        rejection: {
+            code: string;
+            rejectedAt: string;
+            provesNoChildStarted: true;
+            source: "provider-wrapper";
+        };
+        roleInstructions: {
+            status: "resolved";
+            dependency: string;
+            canonicalRole: string;
+            tier: "loaded" | "project" | "user";
+            validation: "direct-canonical" | "exact-canonical-symlink";
+            canonicalPath: string;
+            selectedPath: string;
+            roleVersion: string;
+            contentDigest: string;
+            candidateMisses: {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }[];
+        };
+    }, {
+        status: "fallback-dispatch";
+        triggerRequestId: string;
+        fallbackRequestId: string;
+        trigger: "pre-start-rejection";
+        fallbackReason: string;
+        kind: "canonical-instruction-fresh-child";
+        approximation: true;
+        preservedTarget: {
+            provider: string;
+            modelSelector: string | null;
+            effortSelector: string | null;
+            reasoningModeSelector: string | null;
+            serviceTierSelector: string | null;
+            selectedRoute: string;
+        };
+        rejection: {
+            code: string;
+            rejectedAt: string;
+            provesNoChildStarted: true;
+            source: "provider-wrapper";
+        };
+        roleInstructions: {
+            status: "resolved";
+            dependency: string;
+            canonicalRole: string;
+            tier: "loaded" | "project" | "user";
+            validation: "direct-canonical" | "exact-canonical-symlink";
+            canonicalPath: string;
+            selectedPath: string;
+            roleVersion: string;
+            contentDigest: string;
+            candidateMisses: {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }[];
+        };
+    }>;
+}, "strict", z.ZodTypeAny, {
+    kind: "fallback-link";
+    requestId: string;
+    source: "provider-wrapper";
+    evidence: {
+        status: "fallback-dispatch";
+        triggerRequestId: string;
+        fallbackRequestId: string;
+        trigger: "pre-start-rejection";
+        fallbackReason: string;
+        kind: "canonical-instruction-fresh-child";
+        approximation: true;
+        preservedTarget: {
+            provider: string;
+            modelSelector: string | null;
+            effortSelector: string | null;
+            reasoningModeSelector: string | null;
+            serviceTierSelector: string | null;
+            selectedRoute: string;
+        };
+        rejection: {
+            code: string;
+            rejectedAt: string;
+            provesNoChildStarted: true;
+            source: "provider-wrapper";
+        };
+        roleInstructions: {
+            status: "resolved";
+            dependency: string;
+            canonicalRole: string;
+            tier: "loaded" | "project" | "user";
+            validation: "direct-canonical" | "exact-canonical-symlink";
+            canonicalPath: string;
+            selectedPath: string;
+            roleVersion: string;
+            contentDigest: string;
+            candidateMisses: {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }[];
+        };
+    };
+}, {
+    kind: "fallback-link";
+    requestId: string;
+    source: "provider-wrapper";
+    evidence: {
+        status: "fallback-dispatch";
+        triggerRequestId: string;
+        fallbackRequestId: string;
+        trigger: "pre-start-rejection";
+        fallbackReason: string;
+        kind: "canonical-instruction-fresh-child";
+        approximation: true;
+        preservedTarget: {
+            provider: string;
+            modelSelector: string | null;
+            effortSelector: string | null;
+            reasoningModeSelector: string | null;
+            serviceTierSelector: string | null;
+            selectedRoute: string;
+        };
+        rejection: {
+            code: string;
+            rejectedAt: string;
+            provesNoChildStarted: true;
+            source: "provider-wrapper";
+        };
+        roleInstructions: {
+            status: "resolved";
+            dependency: string;
+            canonicalRole: string;
+            tier: "loaded" | "project" | "user";
+            validation: "direct-canonical" | "exact-canonical-symlink";
+            canonicalPath: string;
+            selectedPath: string;
+            roleVersion: string;
+            contentDigest: string;
+            candidateMisses: {
+                tier: "loaded" | "project" | "user";
+                candidate: string;
+                outcome: "broken-symlink" | "escaping-symlink" | "invalid-role" | "missing" | "noncanonical-copy" | "wrong-target";
+            }[];
+        };
+    };
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"runtime-observation">;
+    requestId: z.ZodString;
+    source: z.ZodLiteral<"runtime-observer">;
+    observation: z.ZodDiscriminatedUnion<"status", [z.ZodObject<{
+        status: z.ZodLiteral<"not-reported">;
+    }, "strict", z.ZodTypeAny, {
+        status: "not-reported";
+    }, {
+        status: "not-reported";
+    }>, z.ZodObject<{
+        status: z.ZodLiteral<"reported">;
+        provider: z.ZodString;
+        childLineage: z.ZodOptional<z.ZodString>;
+        role: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        effort: z.ZodOptional<z.ZodString>;
+        serviceTier: z.ZodOptional<z.ZodString>;
+        source: z.ZodString;
+        observedAt: z.ZodString;
+        match: z.ZodEnum<["matching", "mismatching", "not-comparable"]>;
+        /**
+         * The axes the verdict actually rests on. Optional so a record written
+         * before this field existed still parses, but always written now: a
+         * `matching` that rests on one incidental axis is a materially weaker
+         * claim than one resting on model and role, and a consumer reading only
+         * the scalar `match` cannot tell them apart.
+         */
+        comparedAxes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        status: "reported";
+        provider: string;
+        childLineage?: string | undefined;
+        role?: string | undefined;
+        model?: string | undefined;
+        effort?: string | undefined;
+        serviceTier?: string | undefined;
+        source: string;
+        observedAt: string;
+        match: "matching" | "mismatching" | "not-comparable";
+        comparedAxes?: string[] | undefined;
+    }, {
+        status: "reported";
+        provider: string;
+        childLineage?: string | undefined;
+        role?: string | undefined;
+        model?: string | undefined;
+        effort?: string | undefined;
+        serviceTier?: string | undefined;
+        source: string;
+        observedAt: string;
+        match: "matching" | "mismatching" | "not-comparable";
+        comparedAxes?: string[] | undefined;
+    }>]>;
+}, "strict", z.ZodTypeAny, {
+    kind: "runtime-observation";
+    requestId: string;
+    source: "runtime-observer";
+    observation: {
+        status: "not-reported";
+    } | {
+        status: "reported";
+        provider: string;
+        childLineage?: string | undefined;
+        role?: string | undefined;
+        model?: string | undefined;
+        effort?: string | undefined;
+        serviceTier?: string | undefined;
+        source: string;
+        observedAt: string;
+        match: "matching" | "mismatching" | "not-comparable";
+        comparedAxes?: string[] | undefined;
+    };
+}, {
+    kind: "runtime-observation";
+    requestId: string;
+    source: "runtime-observer";
+    observation: {
+        status: "not-reported";
+    } | {
+        status: "reported";
+        provider: string;
+        childLineage?: string | undefined;
+        role?: string | undefined;
+        model?: string | undefined;
+        effort?: string | undefined;
+        serviceTier?: string | undefined;
+        source: string;
+        observedAt: string;
+        match: "matching" | "mismatching" | "not-comparable";
+        comparedAxes?: string[] | undefined;
+    };
+}>]>;
+export type OatDispatchEvidenceEvent = z.infer<typeof oatDispatchEvidenceEventSchema>;
+export declare function parsePersistedOatDispatchRecord(value: unknown): PersistedOatDispatchRecordV1;
+export declare function augmentDispatchRecord(input: {
+    record: GenericDispatchRecord | PersistedOatDispatchRecordV1;
+    event: OatDispatchEvidenceEvent;
+    triggerRecord?: PersistedOatDispatchRecordV1;
+    relatedRecords?: readonly PersistedOatDispatchRecordV1[];
+}): PersistedOatDispatchRecordV1;
+export {};
+//# sourceMappingURL=oat-dispatch-record.d.ts.map