audit-tools 0.34.21 → 0.34.22

package/dist/shared/dispatch/admissionLoop.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import type { ReservationLedger } from "../quota/reservationLedger.js";
+import type { ConstraintOutcome, ReservationLedger } from "../quota/reservationLedger.js";
 import type { DispatchCapacityPoolSummary } from "../quota/capacity.js";
 import type { DispatchModelTier } from "../types/stepContract.js";
 import type { WindowBudget } from "../quota/types.js";
@@ -119,81 +119,338 @@ export declare function deriveThroughputConcurrency(params: {
  * spec/dispatch-cost-speed-dial.md), and the context-window fit ceiling.
  */
 export declare function admissionPoolsFromSummaries(summaries: readonly DispatchCapacityPoolSummary[], confirmedCostPositions?: Map<string, number> | null): AdmissionPool[];
+/**
+ * One constraint's evaluation, serialized for the persisted explain artifact —
+ * the wire form of the ledger's {@link ConstraintOutcome} (legibility invariant,
+ * spec/audit/dispatch-admission-control.md Resolved decision 3).
+ *
+ * `headroom_before: null` means UNBOUNDED, not unknown — a cold-start pool with
+ * no real ceiling computes `headroomBefore = +Infinity`, which `JSON.stringify`
+ * (the artifact's actual emit path) collapses to `null`; `.number()` alone
+ * rejects that on read-back even though it accepts `Infinity` in memory, so
+ * `null` is the honest encoding of what the artifact actually contains on disk.
+ */
+export declare const ConstraintOutcomeRecordSchema: z.ZodObject<{
+    resource_key: z.ZodString;
+    headroom_before: z.ZodNullable<z.ZodNumber>;
+    outstanding_before: z.ZodNumber;
+    cost: z.ZodNumber;
+    /** Whether this constraint alone had room. Admission requires ALL true. */
+    cleared: z.ZodBoolean;
+}, "strict", z.ZodTypeAny, {
+    cost: number;
+    resource_key: string;
+    headroom_before: number | null;
+    outstanding_before: number;
+    cleared: boolean;
+}, {
+    cost: number;
+    resource_key: string;
+    headroom_before: number | null;
+    outstanding_before: number;
+    cleared: boolean;
+}>;
+export type ConstraintOutcomeRecord = z.infer<typeof ConstraintOutcomeRecordSchema>;
+/** Serialize ledger outcomes for the artifact (non-finite headroom → null). */
+export declare function toConstraintOutcomeRecords(outcomes: readonly ConstraintOutcome[]): ConstraintOutcomeRecord[];
+/**
+ * One NON-decisive pool consultation during a packet's admission walk — a pool
+ * that was tried and refused before the decision landed elsewhere (the decisive
+ * pool's data lives on the explain record itself, never duplicated here). The
+ * refusal vocabulary is shared with {@link AdmissionExplain.reason} so one
+ * parser covers both.
+ */
+export declare const AdmissionAttemptSchema: z.ZodObject<{
+    pool_id: z.ZodString;
+    reason: z.ZodEnum<["budget_exhausted", "cap_reached", "window_uncalibrated"]>;
+    /** Ledger outcomes when the attempt reached the ledger; [] otherwise. */
+    constraints: z.ZodArray<z.ZodObject<{
+        resource_key: z.ZodString;
+        headroom_before: z.ZodNullable<z.ZodNumber>;
+        outstanding_before: z.ZodNumber;
+        cost: z.ZodNumber;
+        /** Whether this constraint alone had room. Admission requires ALL true. */
+        cleared: z.ZodBoolean;
+    }, "strict", z.ZodTypeAny, {
+        cost: number;
+        resource_key: string;
+        headroom_before: number | null;
+        outstanding_before: number;
+        cleared: boolean;
+    }, {
+        cost: number;
+        resource_key: string;
+        headroom_before: number | null;
+        outstanding_before: number;
+        cleared: boolean;
+    }>, "many">;
+    /** cap_reached only: the in-flight count and cap that refused. */
+    in_flight_before: z.ZodOptional<z.ZodNumber>;
+    cap: z.ZodOptional<z.ZodNumber>;
+    /** window_uncalibrated only: labels of the windows that could not price. */
+    unpriced_windows: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    reason: "budget_exhausted" | "cap_reached" | "window_uncalibrated";
+    pool_id: string;
+    constraints: {
+        cost: number;
+        resource_key: string;
+        headroom_before: number | null;
+        outstanding_before: number;
+        cleared: boolean;
+    }[];
+    in_flight_before?: number | undefined;
+    cap?: number | undefined;
+    unpriced_windows?: string[] | undefined;
+}, {
+    reason: "budget_exhausted" | "cap_reached" | "window_uncalibrated";
+    pool_id: string;
+    constraints: {
+        cost: number;
+        resource_key: string;
+        headroom_before: number | null;
+        outstanding_before: number;
+        cleared: boolean;
+    }[];
+    in_flight_before?: number | undefined;
+    cap?: number | undefined;
+    unpriced_windows?: string[] | undefined;
+}>;
+export type AdmissionAttempt = z.infer<typeof AdmissionAttemptSchema>;
 /** A successful admission: one packet leased to one pool. */
 export interface AdmissionGrant {
     packet_id: string;
     pool_id: string;
     /**
-     * ⚠ DIAGNOSTIC PROVENANCE ONLY — not the reconcile key. `reconcile(leaseId)`
-     * sweeps every key the lease was recorded under, precisely so no caller has to
-     * know which keys those were. Once steps 3-4 supply multiple constraints this
-     * field records only ONE of N and will look authoritative while being partial
-     * ([[write-only-data-looks-authoritative]]); make it a key array or drop it then.
-     * Tracked in `docs/backlog.md`.
+     * EVERY resource key the lease was recorded under (deduped, in constraint
+     * order) — never one of N. Diagnostic provenance only: `reconcile(leaseId)`
+     * sweeps every key itself, so no caller needs this to release the lease.
      */
-    resource_key: string;
+    resource_keys: string[];
     lease_id: string;
     cost: number;
 }
 export declare const AdmissionGrantSchema: z.ZodObject<{
     packet_id: z.ZodString;
     pool_id: z.ZodString;
-    resource_key: z.ZodString;
+    resource_keys: z.ZodArray<z.ZodString, "many">;
     lease_id: z.ZodString;
     cost: z.ZodNumber;
 }, "strict", z.ZodTypeAny, {
     pool_id: string;
     cost: number;
     packet_id: string;
-    resource_key: string;
+    resource_keys: string[];
     lease_id: string;
 }, {
     pool_id: string;
     cost: number;
     packet_id: string;
-    resource_key: string;
+    resource_keys: string[];
     lease_id: string;
 }>;
-/** Why a packet was admitted or blocked — the per-admission explain record. */
+/**
+ * Why a packet was admitted or blocked — the per-admission explain record.
+ * Carries the FULL constraint-outcome array the decision was taken against
+ * (every key consulted, its headroom before, the packet's cost against it,
+ * which key refused) plus the non-decisive walk trail — never a one-of-N
+ * scalar that looks authoritative while being partial
+ * ([[write-only-data-looks-authoritative]]).
+ */
 export declare const AdmissionExplainSchema: z.ZodObject<{
     packet_id: z.ZodString;
-    /** null only when NO pool was capable of the packet at all. */
+    /** null when NO pool was capable, or on a plan-only (`planned`) grant. */
     pool_id: z.ZodNullable<z.ZodString>;
-    resource_key: z.ZodNullable<z.ZodString>;
     admitted: z.ZodBoolean;
-    reason: z.ZodEnum<["admitted", "no_capable_pool", "budget_exhausted", "cap_reached", "packet_oversized", "window_uncalibrated"]>;
+    reason: z.ZodEnum<["admitted", "planned", "no_capable_pool", "budget_exhausted", "cap_reached", "packet_oversized", "window_uncalibrated"]>;
     /**
-     * Present on an admit attempt against a real pool (budget headroom before
-     * it). `null` means UNBOUNDED, not unknown — a cold-start pool with no real
-     * ceiling yet computes `headroomBefore = +Infinity`, which `JSON.stringify`
-     * (the artifact's actual emit path) collapses to `null`; `.number()` alone
-     * rejects that on read-back even though it happily accepts `Infinity` in
-     * memory, so the round trip a real reader performs was silently unparseable.
-     * `null` is the honest, back-compat-safe encoding: it matches the literal
-     * bytes already on disk in pre-existing artifacts (e.g.
-     * `.audit-tools/audit/fanout-quota/design_review/dispatch-quota.json`).
+     * The DECISIVE attempt's full constraint-outcome array: on a grant, the
+     * successful admit's; on a ledger refusal, the refusing decision's. Empty
+     * when the ledger was never reached (no_capable_pool / cap_reached /
+     * window_uncalibrated / planned / packet_oversized).
      */
-    headroom_before: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    outstanding_before: z.ZodOptional<z.ZodNumber>;
+    constraints: z.ZodArray<z.ZodObject<{
+        resource_key: z.ZodString;
+        headroom_before: z.ZodNullable<z.ZodNumber>;
+        outstanding_before: z.ZodNumber;
+        cost: z.ZodNumber;
+        /** Whether this constraint alone had room. Admission requires ALL true. */
+        cleared: z.ZodBoolean;
+    }, "strict", z.ZodTypeAny, {
+        cost: number;
+        resource_key: string;
+        headroom_before: number | null;
+        outstanding_before: number;
+        cleared: boolean;
+    }, {
+        cost: number;
+        resource_key: string;
+        headroom_before: number | null;
+        outstanding_before: number;
+        cleared: boolean;
+    }>, "many">;
+    /**
+     * The tightest (or refusing) constraint of the decisive attempt — the
+     * binding window a report should name, as its full outcome row. Null when
+     * the ledger was never reached.
+     */
+    binding: z.ZodNullable<z.ZodObject<{
+        resource_key: z.ZodString;
+        headroom_before: z.ZodNullable<z.ZodNumber>;
+        outstanding_before: z.ZodNumber;
+        cost: z.ZodNumber;
+        /** Whether this constraint alone had room. Admission requires ALL true. */
+        cleared: z.ZodBoolean;
+    }, "strict", z.ZodTypeAny, {
+        cost: number;
+        resource_key: string;
+        headroom_before: number | null;
+        outstanding_before: number;
+        cleared: boolean;
+    }, {
+        cost: number;
+        resource_key: string;
+        headroom_before: number | null;
+        outstanding_before: number;
+        cleared: boolean;
+    }>>;
+    /** Pools consulted and refused BEFORE the decision, in walk order. */
+    attempts: z.ZodArray<z.ZodObject<{
+        pool_id: z.ZodString;
+        reason: z.ZodEnum<["budget_exhausted", "cap_reached", "window_uncalibrated"]>;
+        /** Ledger outcomes when the attempt reached the ledger; [] otherwise. */
+        constraints: z.ZodArray<z.ZodObject<{
+            resource_key: z.ZodString;
+            headroom_before: z.ZodNullable<z.ZodNumber>;
+            outstanding_before: z.ZodNumber;
+            cost: z.ZodNumber;
+            /** Whether this constraint alone had room. Admission requires ALL true. */
+            cleared: z.ZodBoolean;
+        }, "strict", z.ZodTypeAny, {
+            cost: number;
+            resource_key: string;
+            headroom_before: number | null;
+            outstanding_before: number;
+            cleared: boolean;
+        }, {
+            cost: number;
+            resource_key: string;
+            headroom_before: number | null;
+            outstanding_before: number;
+            cleared: boolean;
+        }>, "many">;
+        /** cap_reached only: the in-flight count and cap that refused. */
+        in_flight_before: z.ZodOptional<z.ZodNumber>;
+        cap: z.ZodOptional<z.ZodNumber>;
+        /** window_uncalibrated only: labels of the windows that could not price. */
+        unpriced_windows: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        reason: "budget_exhausted" | "cap_reached" | "window_uncalibrated";
+        pool_id: string;
+        constraints: {
+            cost: number;
+            resource_key: string;
+            headroom_before: number | null;
+            outstanding_before: number;
+            cleared: boolean;
+        }[];
+        in_flight_before?: number | undefined;
+        cap?: number | undefined;
+        unpriced_windows?: string[] | undefined;
+    }, {
+        reason: "budget_exhausted" | "cap_reached" | "window_uncalibrated";
+        pool_id: string;
+        constraints: {
+            cost: number;
+            resource_key: string;
+            headroom_before: number | null;
+            outstanding_before: number;
+            cleared: boolean;
+        }[];
+        in_flight_before?: number | undefined;
+        cap?: number | undefined;
+        unpriced_windows?: string[] | undefined;
+    }>, "many">;
+    /** cap_reached refusal only: the in-flight count and cap that refused. */
+    in_flight_before: z.ZodOptional<z.ZodNumber>;
+    cap: z.ZodOptional<z.ZodNumber>;
+    /** window_uncalibrated refusal only: labels of the unpriceable windows. */
+    unpriced_windows: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     cost: z.ZodNumber;
 }, "strict", z.ZodTypeAny, {
-    reason: "budget_exhausted" | "cap_reached" | "no_capable_pool" | "admitted" | "packet_oversized" | "window_uncalibrated";
+    reason: "budget_exhausted" | "cap_reached" | "no_capable_pool" | "admitted" | "planned" | "packet_oversized" | "window_uncalibrated";
     pool_id: string | null;
     cost: number;
     admitted: boolean;
     packet_id: string;
-    resource_key: string | null;
-    headroom_before?: number | null | undefined;
-    outstanding_before?: number | undefined;
+    constraints: {
+        cost: number;
+        resource_key: string;
+        headroom_before: number | null;
+        outstanding_before: number;
+        cleared: boolean;
+    }[];
+    binding: {
+        cost: number;
+        resource_key: string;
+        headroom_before: number | null;
+        outstanding_before: number;
+        cleared: boolean;
+    } | null;
+    attempts: {
+        reason: "budget_exhausted" | "cap_reached" | "window_uncalibrated";
+        pool_id: string;
+        constraints: {
+            cost: number;
+            resource_key: string;
+            headroom_before: number | null;
+            outstanding_before: number;
+            cleared: boolean;
+        }[];
+        in_flight_before?: number | undefined;
+        cap?: number | undefined;
+        unpriced_windows?: string[] | undefined;
+    }[];
+    in_flight_before?: number | undefined;
+    cap?: number | undefined;
+    unpriced_windows?: string[] | undefined;
 }, {
-    reason: "budget_exhausted" | "cap_reached" | "no_capable_pool" | "admitted" | "packet_oversized" | "window_uncalibrated";
+    reason: "budget_exhausted" | "cap_reached" | "no_capable_pool" | "admitted" | "planned" | "packet_oversized" | "window_uncalibrated";
     pool_id: string | null;
     cost: number;
     admitted: boolean;
     packet_id: string;
-    resource_key: string | null;
-    headroom_before?: number | null | undefined;
-    outstanding_before?: number | undefined;
+    constraints: {
+        cost: number;
+        resource_key: string;
+        headroom_before: number | null;
+        outstanding_before: number;
+        cleared: boolean;
+    }[];
+    binding: {
+        cost: number;
+        resource_key: string;
+        headroom_before: number | null;
+        outstanding_before: number;
+        cleared: boolean;
+    } | null;
+    attempts: {
+        reason: "budget_exhausted" | "cap_reached" | "window_uncalibrated";
+        pool_id: string;
+        constraints: {
+            cost: number;
+            resource_key: string;
+            headroom_before: number | null;
+            outstanding_before: number;
+            cleared: boolean;
+        }[];
+        in_flight_before?: number | undefined;
+        cap?: number | undefined;
+        unpriced_windows?: string[] | undefined;
+    }[];
+    in_flight_before?: number | undefined;
+    cap?: number | undefined;
+    unpriced_windows?: string[] | undefined;
 }>;
 export type AdmissionExplain = z.infer<typeof AdmissionExplainSchema>;
 /**
@@ -210,101 +467,312 @@ export declare const DispatchAdmissionSchema: z.ZodObject<{
     leases: z.ZodArray<z.ZodObject<{
         packet_id: z.ZodString;
         pool_id: z.ZodString;
-        resource_key: z.ZodString;
+        resource_keys: z.ZodArray<z.ZodString, "many">;
         lease_id: z.ZodString;
         cost: z.ZodNumber;
     }, "strict", z.ZodTypeAny, {
         pool_id: string;
         cost: number;
         packet_id: string;
-        resource_key: string;
+        resource_keys: string[];
         lease_id: string;
     }, {
         pool_id: string;
         cost: number;
         packet_id: string;
-        resource_key: string;
+        resource_keys: string[];
         lease_id: string;
     }>, "many">;
     explains: z.ZodArray<z.ZodObject<{
         packet_id: z.ZodString;
-        /** null only when NO pool was capable of the packet at all. */
+        /** null when NO pool was capable, or on a plan-only (`planned`) grant. */
         pool_id: z.ZodNullable<z.ZodString>;
-        resource_key: z.ZodNullable<z.ZodString>;
         admitted: z.ZodBoolean;
-        reason: z.ZodEnum<["admitted", "no_capable_pool", "budget_exhausted", "cap_reached", "packet_oversized", "window_uncalibrated"]>;
+        reason: z.ZodEnum<["admitted", "planned", "no_capable_pool", "budget_exhausted", "cap_reached", "packet_oversized", "window_uncalibrated"]>;
+        /**
+         * The DECISIVE attempt's full constraint-outcome array: on a grant, the
+         * successful admit's; on a ledger refusal, the refusing decision's. Empty
+         * when the ledger was never reached (no_capable_pool / cap_reached /
+         * window_uncalibrated / planned / packet_oversized).
+         */
+        constraints: z.ZodArray<z.ZodObject<{
+            resource_key: z.ZodString;
+            headroom_before: z.ZodNullable<z.ZodNumber>;
+            outstanding_before: z.ZodNumber;
+            cost: z.ZodNumber;
+            /** Whether this constraint alone had room. Admission requires ALL true. */
+            cleared: z.ZodBoolean;
+        }, "strict", z.ZodTypeAny, {
+            cost: number;
+            resource_key: string;
+            headroom_before: number | null;
+            outstanding_before: number;
+            cleared: boolean;
+        }, {
+            cost: number;
+            resource_key: string;
+            headroom_before: number | null;
+            outstanding_before: number;
+            cleared: boolean;
+        }>, "many">;
         /**
-         * Present on an admit attempt against a real pool (budget headroom before
-         * it). `null` means UNBOUNDED, not unknown — a cold-start pool with no real
-         * ceiling yet computes `headroomBefore = +Infinity`, which `JSON.stringify`
-         * (the artifact's actual emit path) collapses to `null`; `.number()` alone
-         * rejects that on read-back even though it happily accepts `Infinity` in
-         * memory, so the round trip a real reader performs was silently unparseable.
-         * `null` is the honest, back-compat-safe encoding: it matches the literal
-         * bytes already on disk in pre-existing artifacts (e.g.
-         * `.audit-tools/audit/fanout-quota/design_review/dispatch-quota.json`).
+         * The tightest (or refusing) constraint of the decisive attempt — the
+         * binding window a report should name, as its full outcome row. Null when
+         * the ledger was never reached.
          */
-        headroom_before: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        outstanding_before: z.ZodOptional<z.ZodNumber>;
+        binding: z.ZodNullable<z.ZodObject<{
+            resource_key: z.ZodString;
+            headroom_before: z.ZodNullable<z.ZodNumber>;
+            outstanding_before: z.ZodNumber;
+            cost: z.ZodNumber;
+            /** Whether this constraint alone had room. Admission requires ALL true. */
+            cleared: z.ZodBoolean;
+        }, "strict", z.ZodTypeAny, {
+            cost: number;
+            resource_key: string;
+            headroom_before: number | null;
+            outstanding_before: number;
+            cleared: boolean;
+        }, {
+            cost: number;
+            resource_key: string;
+            headroom_before: number | null;
+            outstanding_before: number;
+            cleared: boolean;
+        }>>;
+        /** Pools consulted and refused BEFORE the decision, in walk order. */
+        attempts: z.ZodArray<z.ZodObject<{
+            pool_id: z.ZodString;
+            reason: z.ZodEnum<["budget_exhausted", "cap_reached", "window_uncalibrated"]>;
+            /** Ledger outcomes when the attempt reached the ledger; [] otherwise. */
+            constraints: z.ZodArray<z.ZodObject<{
+                resource_key: z.ZodString;
+                headroom_before: z.ZodNullable<z.ZodNumber>;
+                outstanding_before: z.ZodNumber;
+                cost: z.ZodNumber;
+                /** Whether this constraint alone had room. Admission requires ALL true. */
+                cleared: z.ZodBoolean;
+            }, "strict", z.ZodTypeAny, {
+                cost: number;
+                resource_key: string;
+                headroom_before: number | null;
+                outstanding_before: number;
+                cleared: boolean;
+            }, {
+                cost: number;
+                resource_key: string;
+                headroom_before: number | null;
+                outstanding_before: number;
+                cleared: boolean;
+            }>, "many">;
+            /** cap_reached only: the in-flight count and cap that refused. */
+            in_flight_before: z.ZodOptional<z.ZodNumber>;
+            cap: z.ZodOptional<z.ZodNumber>;
+            /** window_uncalibrated only: labels of the windows that could not price. */
+            unpriced_windows: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strict", z.ZodTypeAny, {
+            reason: "budget_exhausted" | "cap_reached" | "window_uncalibrated";
+            pool_id: string;
+            constraints: {
+                cost: number;
+                resource_key: string;
+                headroom_before: number | null;
+                outstanding_before: number;
+                cleared: boolean;
+            }[];
+            in_flight_before?: number | undefined;
+            cap?: number | undefined;
+            unpriced_windows?: string[] | undefined;
+        }, {
+            reason: "budget_exhausted" | "cap_reached" | "window_uncalibrated";
+            pool_id: string;
+            constraints: {
+                cost: number;
+                resource_key: string;
+                headroom_before: number | null;
+                outstanding_before: number;
+                cleared: boolean;
+            }[];
+            in_flight_before?: number | undefined;
+            cap?: number | undefined;
+            unpriced_windows?: string[] | undefined;
+        }>, "many">;
+        /** cap_reached refusal only: the in-flight count and cap that refused. */
+        in_flight_before: z.ZodOptional<z.ZodNumber>;
+        cap: z.ZodOptional<z.ZodNumber>;
+        /** window_uncalibrated refusal only: labels of the unpriceable windows. */
+        unpriced_windows: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         cost: z.ZodNumber;
     }, "strict", z.ZodTypeAny, {
-        reason: "budget_exhausted" | "cap_reached" | "no_capable_pool" | "admitted" | "packet_oversized" | "window_uncalibrated";
+        reason: "budget_exhausted" | "cap_reached" | "no_capable_pool" | "admitted" | "planned" | "packet_oversized" | "window_uncalibrated";
         pool_id: string | null;
         cost: number;
         admitted: boolean;
         packet_id: string;
-        resource_key: string | null;
-        headroom_before?: number | null | undefined;
-        outstanding_before?: number | undefined;
+        constraints: {
+            cost: number;
+            resource_key: string;
+            headroom_before: number | null;
+            outstanding_before: number;
+            cleared: boolean;
+        }[];
+        binding: {
+            cost: number;
+            resource_key: string;
+            headroom_before: number | null;
+            outstanding_before: number;
+            cleared: boolean;
+        } | null;
+        attempts: {
+            reason: "budget_exhausted" | "cap_reached" | "window_uncalibrated";
+            pool_id: string;
+            constraints: {
+                cost: number;
+                resource_key: string;
+                headroom_before: number | null;
+                outstanding_before: number;
+                cleared: boolean;
+            }[];
+            in_flight_before?: number | undefined;
+            cap?: number | undefined;
+            unpriced_windows?: string[] | undefined;
+        }[];
+        in_flight_before?: number | undefined;
+        cap?: number | undefined;
+        unpriced_windows?: string[] | undefined;
     }, {
-        reason: "budget_exhausted" | "cap_reached" | "no_capable_pool" | "admitted" | "packet_oversized" | "window_uncalibrated";
+        reason: "budget_exhausted" | "cap_reached" | "no_capable_pool" | "admitted" | "planned" | "packet_oversized" | "window_uncalibrated";
         pool_id: string | null;
         cost: number;
         admitted: boolean;
         packet_id: string;
-        resource_key: string | null;
-        headroom_before?: number | null | undefined;
-        outstanding_before?: number | undefined;
+        constraints: {
+            cost: number;
+            resource_key: string;
+            headroom_before: number | null;
+            outstanding_before: number;
+            cleared: boolean;
+        }[];
+        binding: {
+            cost: number;
+            resource_key: string;
+            headroom_before: number | null;
+            outstanding_before: number;
+            cleared: boolean;
+        } | null;
+        attempts: {
+            reason: "budget_exhausted" | "cap_reached" | "window_uncalibrated";
+            pool_id: string;
+            constraints: {
+                cost: number;
+                resource_key: string;
+                headroom_before: number | null;
+                outstanding_before: number;
+                cleared: boolean;
+            }[];
+            in_flight_before?: number | undefined;
+            cap?: number | undefined;
+            unpriced_windows?: string[] | undefined;
+        }[];
+        in_flight_before?: number | undefined;
+        cap?: number | undefined;
+        unpriced_windows?: string[] | undefined;
     }>, "many">;
 }, "strict", z.ZodTypeAny, {
     leases: {
         pool_id: string;
         cost: number;
         packet_id: string;
-        resource_key: string;
+        resource_keys: string[];
         lease_id: string;
     }[];
     granted_packet_ids: string[];
     declared_cap: number | null;
     explains: {
-        reason: "budget_exhausted" | "cap_reached" | "no_capable_pool" | "admitted" | "packet_oversized" | "window_uncalibrated";
+        reason: "budget_exhausted" | "cap_reached" | "no_capable_pool" | "admitted" | "planned" | "packet_oversized" | "window_uncalibrated";
         pool_id: string | null;
         cost: number;
         admitted: boolean;
         packet_id: string;
-        resource_key: string | null;
-        headroom_before?: number | null | undefined;
-        outstanding_before?: number | undefined;
+        constraints: {
+            cost: number;
+            resource_key: string;
+            headroom_before: number | null;
+            outstanding_before: number;
+            cleared: boolean;
+        }[];
+        binding: {
+            cost: number;
+            resource_key: string;
+            headroom_before: number | null;
+            outstanding_before: number;
+            cleared: boolean;
+        } | null;
+        attempts: {
+            reason: "budget_exhausted" | "cap_reached" | "window_uncalibrated";
+            pool_id: string;
+            constraints: {
+                cost: number;
+                resource_key: string;
+                headroom_before: number | null;
+                outstanding_before: number;
+                cleared: boolean;
+            }[];
+            in_flight_before?: number | undefined;
+            cap?: number | undefined;
+            unpriced_windows?: string[] | undefined;
+        }[];
+        in_flight_before?: number | undefined;
+        cap?: number | undefined;
+        unpriced_windows?: string[] | undefined;
     }[];
 }, {
     leases: {
         pool_id: string;
         cost: number;
         packet_id: string;
-        resource_key: string;
+        resource_keys: string[];
         lease_id: string;
     }[];
     granted_packet_ids: string[];
     declared_cap: number | null;
     explains: {
-        reason: "budget_exhausted" | "cap_reached" | "no_capable_pool" | "admitted" | "packet_oversized" | "window_uncalibrated";
+        reason: "budget_exhausted" | "cap_reached" | "no_capable_pool" | "admitted" | "planned" | "packet_oversized" | "window_uncalibrated";
         pool_id: string | null;
         cost: number;
         admitted: boolean;
         packet_id: string;
-        resource_key: string | null;
-        headroom_before?: number | null | undefined;
-        outstanding_before?: number | undefined;
+        constraints: {
+            cost: number;
+            resource_key: string;
+            headroom_before: number | null;
+            outstanding_before: number;
+            cleared: boolean;
+        }[];
+        binding: {
+            cost: number;
+            resource_key: string;
+            headroom_before: number | null;
+            outstanding_before: number;
+            cleared: boolean;
+        } | null;
+        attempts: {
+            reason: "budget_exhausted" | "cap_reached" | "window_uncalibrated";
+            pool_id: string;
+            constraints: {
+                cost: number;
+                resource_key: string;
+                headroom_before: number | null;
+                outstanding_before: number;
+                cleared: boolean;
+            }[];
+            in_flight_before?: number | undefined;
+            cap?: number | undefined;
+            unpriced_windows?: string[] | undefined;
+        }[];
+        in_flight_before?: number | undefined;
+        cap?: number | undefined;
+        unpriced_windows?: string[] | undefined;
     }[];
 }>;
 export type DispatchAdmission = z.infer<typeof DispatchAdmissionSchema>;