@claudexor/schema 3.3.10 → 3.3.11

package/dist/credential-profile-snapshot.d.ts

@@ -930,6 +930,43 @@ export declare const ControlCredentialProfilesSnapshotResponse: z.ZodObject<{
             source: z.ZodEnum<["codex_app_server", "codex_rollout", "claude_statusline", "claude_api_retry", "claude_oauth_usage"]>;
             observed_at: z.ZodString;
             freshness: z.ZodEnum<["fresh", "stale", "unknown"]>;
+        } & {
+            availability: z.ZodOptional<z.ZodObject<{
+                state: z.ZodEnum<["available", "exhausted", "cooldown"]>;
+                blocking_constraints: z.ZodArray<z.ZodString, "many">;
+                resets_at: z.ZodNullable<z.ZodString>;
+                model_scoped_exhaustions: z.ZodArray<z.ZodObject<{
+                    constraint_id: z.ZodString;
+                    applies_to_models: z.ZodArray<z.ZodString, "many">;
+                    resets_at: z.ZodNullable<z.ZodString>;
+                }, "strict", z.ZodTypeAny, {
+                    constraint_id: string;
+                    applies_to_models: string[];
+                    resets_at: string | null;
+                }, {
+                    constraint_id: string;
+                    applies_to_models: string[];
+                    resets_at: string | null;
+                }>, "many">;
+            }, "strict", z.ZodTypeAny, {
+                state: "available" | "cooldown" | "exhausted";
+                blocking_constraints: string[];
+                resets_at: string | null;
+                model_scoped_exhaustions: {
+                    constraint_id: string;
+                    applies_to_models: string[];
+                    resets_at: string | null;
+                }[];
+            }, {
+                state: "available" | "cooldown" | "exhausted";
+                blocking_constraints: string[];
+                resets_at: string | null;
+                model_scoped_exhaustions: {
+                    constraint_id: string;
+                    applies_to_models: string[];
+                    resets_at: string | null;
+                }[];
+            }>>;
         }, "strict", z.ZodTypeAny, {
             subject: {
                 harness: string;
@@ -949,6 +986,16 @@ export declare const ControlCredentialProfilesSnapshotResponse: z.ZodObject<{
             source: "claude_api_retry" | "claude_oauth_usage" | "claude_statusline" | "codex_app_server" | "codex_rollout";
             observed_at: string;
             freshness: "fresh" | "stale" | "unknown";
+            availability?: {
+                state: "available" | "cooldown" | "exhausted";
+                blocking_constraints: string[];
+                resets_at: string | null;
+                model_scoped_exhaustions: {
+                    constraint_id: string;
+                    applies_to_models: string[];
+                    resets_at: string | null;
+                }[];
+            } | undefined;
         }, {
             subject: {
                 harness: string;
@@ -968,6 +1015,16 @@ export declare const ControlCredentialProfilesSnapshotResponse: z.ZodObject<{
             source: "claude_api_retry" | "claude_oauth_usage" | "claude_statusline" | "codex_app_server" | "codex_rollout";
             observed_at: string;
             freshness: "fresh" | "stale" | "unknown";
+            availability?: {
+                state: "available" | "cooldown" | "exhausted";
+                blocking_constraints: string[];
+                resets_at: string | null;
+                model_scoped_exhaustions: {
+                    constraint_id: string;
+                    applies_to_models: string[];
+                    resets_at: string | null;
+                }[];
+            } | undefined;
         }>, "many">;
         absences: z.ZodDefault<z.ZodArray<z.ZodObject<{
             subject: z.ZodObject<{
@@ -1031,6 +1088,16 @@ export declare const ControlCredentialProfilesSnapshotResponse: z.ZodObject<{
             source: "claude_api_retry" | "claude_oauth_usage" | "claude_statusline" | "codex_app_server" | "codex_rollout";
             observed_at: string;
             freshness: "fresh" | "stale" | "unknown";
+            availability?: {
+                state: "available" | "cooldown" | "exhausted";
+                blocking_constraints: string[];
+                resets_at: string | null;
+                model_scoped_exhaustions: {
+                    constraint_id: string;
+                    applies_to_models: string[];
+                    resets_at: string | null;
+                }[];
+            } | undefined;
         }[];
         absences: {
             subject: {
@@ -1064,6 +1131,16 @@ export declare const ControlCredentialProfilesSnapshotResponse: z.ZodObject<{
             source: "claude_api_retry" | "claude_oauth_usage" | "claude_statusline" | "codex_app_server" | "codex_rollout";
             observed_at: string;
             freshness: "fresh" | "stale" | "unknown";
+            availability?: {
+                state: "available" | "cooldown" | "exhausted";
+                blocking_constraints: string[];
+                resets_at: string | null;
+                model_scoped_exhaustions: {
+                    constraint_id: string;
+                    applies_to_models: string[];
+                    resets_at: string | null;
+                }[];
+            } | undefined;
         }[];
         absences?: {
             subject: {
@@ -1253,6 +1330,16 @@ export declare const ControlCredentialProfilesSnapshotResponse: z.ZodObject<{
             source: "claude_api_retry" | "claude_oauth_usage" | "claude_statusline" | "codex_app_server" | "codex_rollout";
             observed_at: string;
             freshness: "fresh" | "stale" | "unknown";
+            availability?: {
+                state: "available" | "cooldown" | "exhausted";
+                blocking_constraints: string[];
+                resets_at: string | null;
+                model_scoped_exhaustions: {
+                    constraint_id: string;
+                    applies_to_models: string[];
+                    resets_at: string | null;
+                }[];
+            } | undefined;
         }[];
         absences: {
             subject: {
@@ -1442,6 +1529,16 @@ export declare const ControlCredentialProfilesSnapshotResponse: z.ZodObject<{
             source: "claude_api_retry" | "claude_oauth_usage" | "claude_statusline" | "codex_app_server" | "codex_rollout";
             observed_at: string;
             freshness: "fresh" | "stale" | "unknown";
+            availability?: {
+                state: "available" | "cooldown" | "exhausted";
+                blocking_constraints: string[];
+                resets_at: string | null;
+                model_scoped_exhaustions: {
+                    constraint_id: string;
+                    applies_to_models: string[];
+                    resets_at: string | null;
+                }[];
+            } | undefined;
         }[];
         absences?: {
             subject: {
@@ -2692,6 +2789,43 @@ export declare const ControlCredentialProfilesQueryResponse: z.ZodUnion<[z.ZodOb
             source: z.ZodEnum<["codex_app_server", "codex_rollout", "claude_statusline", "claude_api_retry", "claude_oauth_usage"]>;
             observed_at: z.ZodString;
             freshness: z.ZodEnum<["fresh", "stale", "unknown"]>;
+        } & {
+            availability: z.ZodOptional<z.ZodObject<{
+                state: z.ZodEnum<["available", "exhausted", "cooldown"]>;
+                blocking_constraints: z.ZodArray<z.ZodString, "many">;
+                resets_at: z.ZodNullable<z.ZodString>;
+                model_scoped_exhaustions: z.ZodArray<z.ZodObject<{
+                    constraint_id: z.ZodString;
+                    applies_to_models: z.ZodArray<z.ZodString, "many">;
+                    resets_at: z.ZodNullable<z.ZodString>;
+                }, "strict", z.ZodTypeAny, {
+                    constraint_id: string;
+                    applies_to_models: string[];
+                    resets_at: string | null;
+                }, {
+                    constraint_id: string;
+                    applies_to_models: string[];
+                    resets_at: string | null;
+                }>, "many">;
+            }, "strict", z.ZodTypeAny, {
+                state: "available" | "cooldown" | "exhausted";
+                blocking_constraints: string[];
+                resets_at: string | null;
+                model_scoped_exhaustions: {
+                    constraint_id: string;
+                    applies_to_models: string[];
+                    resets_at: string | null;
+                }[];
+            }, {
+                state: "available" | "cooldown" | "exhausted";
+                blocking_constraints: string[];
+                resets_at: string | null;
+                model_scoped_exhaustions: {
+                    constraint_id: string;
+                    applies_to_models: string[];
+                    resets_at: string | null;
+                }[];
+            }>>;
         }, "strict", z.ZodTypeAny, {
             subject: {
                 harness: string;
@@ -2711,6 +2845,16 @@ export declare const ControlCredentialProfilesQueryResponse: z.ZodUnion<[z.ZodOb
             source: "claude_api_retry" | "claude_oauth_usage" | "claude_statusline" | "codex_app_server" | "codex_rollout";
             observed_at: string;
             freshness: "fresh" | "stale" | "unknown";
+            availability?: {
+                state: "available" | "cooldown" | "exhausted";
+                blocking_constraints: string[];
+                resets_at: string | null;
+                model_scoped_exhaustions: {
+                    constraint_id: string;
+                    applies_to_models: string[];
+                    resets_at: string | null;
+                }[];
+            } | undefined;
         }, {
             subject: {
                 harness: string;
@@ -2730,6 +2874,16 @@ export declare const ControlCredentialProfilesQueryResponse: z.ZodUnion<[z.ZodOb
             source: "claude_api_retry" | "claude_oauth_usage" | "claude_statusline" | "codex_app_server" | "codex_rollout";
             observed_at: string;
             freshness: "fresh" | "stale" | "unknown";
+            availability?: {
+                state: "available" | "cooldown" | "exhausted";
+                blocking_constraints: string[];
+                resets_at: string | null;
+                model_scoped_exhaustions: {
+                    constraint_id: string;
+                    applies_to_models: string[];
+                    resets_at: string | null;
+                }[];
+            } | undefined;
         }>, "many">;
         absences: z.ZodDefault<z.ZodArray<z.ZodObject<{
             subject: z.ZodObject<{
@@ -2793,6 +2947,16 @@ export declare const ControlCredentialProfilesQueryResponse: z.ZodUnion<[z.ZodOb
             source: "claude_api_retry" | "claude_oauth_usage" | "claude_statusline" | "codex_app_server" | "codex_rollout";
             observed_at: string;
             freshness: "fresh" | "stale" | "unknown";
+            availability?: {
+                state: "available" | "cooldown" | "exhausted";
+                blocking_constraints: string[];
+                resets_at: string | null;
+                model_scoped_exhaustions: {
+                    constraint_id: string;
+                    applies_to_models: string[];
+                    resets_at: string | null;
+                }[];
+            } | undefined;
         }[];
         absences: {
             subject: {
@@ -2826,6 +2990,16 @@ export declare const ControlCredentialProfilesQueryResponse: z.ZodUnion<[z.ZodOb
             source: "claude_api_retry" | "claude_oauth_usage" | "claude_statusline" | "codex_app_server" | "codex_rollout";
             observed_at: string;
             freshness: "fresh" | "stale" | "unknown";
+            availability?: {
+                state: "available" | "cooldown" | "exhausted";
+                blocking_constraints: string[];
+                resets_at: string | null;
+                model_scoped_exhaustions: {
+                    constraint_id: string;
+                    applies_to_models: string[];
+                    resets_at: string | null;
+                }[];
+            } | undefined;
         }[];
         absences?: {
             subject: {
@@ -3015,6 +3189,16 @@ export declare const ControlCredentialProfilesQueryResponse: z.ZodUnion<[z.ZodOb
             source: "claude_api_retry" | "claude_oauth_usage" | "claude_statusline" | "codex_app_server" | "codex_rollout";
             observed_at: string;
             freshness: "fresh" | "stale" | "unknown";
+            availability?: {
+                state: "available" | "cooldown" | "exhausted";
+                blocking_constraints: string[];
+                resets_at: string | null;
+                model_scoped_exhaustions: {
+                    constraint_id: string;
+                    applies_to_models: string[];
+                    resets_at: string | null;
+                }[];
+            } | undefined;
         }[];
         absences: {
             subject: {
@@ -3204,6 +3388,16 @@ export declare const ControlCredentialProfilesQueryResponse: z.ZodUnion<[z.ZodOb
             source: "claude_api_retry" | "claude_oauth_usage" | "claude_statusline" | "codex_app_server" | "codex_rollout";
             observed_at: string;
             freshness: "fresh" | "stale" | "unknown";
+            availability?: {
+                state: "available" | "cooldown" | "exhausted";
+                blocking_constraints: string[];
+                resets_at: string | null;
+                model_scoped_exhaustions: {
+                    constraint_id: string;
+                    applies_to_models: string[];
+                    resets_at: string | null;
+                }[];
+            } | undefined;
         }[];
         absences?: {
             subject: {

package/dist/credential-profile-snapshot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"credential-profile-snapshot.d.ts","sourceRoot":"","sources":["../src/credential-profile-snapshot.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"credential-profile-snapshot.d.ts","sourceRoot":"","sources":["../src/credential-profile-snapshot.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAM3B;+EAC+E;AAC/E,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBnD,CAAC;AACJ,MAAM,MAAM,yCAAyC,GAAG,CAAC,CAAC,KAAK,CAC7D,OAAO,yCAAyC,CACjD,CAAC;AAEF;;+EAE+E;AAC/E,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEqC,CAAC;AACzF,MAAM,MAAM,sCAAsC,GAAG,CAAC,CAAC,KAAK,CAC1D,OAAO,sCAAsC,CAC9C,CAAC"}

package/dist/quota.d.ts

@@ -199,6 +199,218 @@ export declare const QuotaAbsence: z.ZodObject<{
     observed_at: string;
 }>;
 export type QuotaAbsence = z.infer<typeof QuotaAbsence>;
+export declare const QuotaAvailabilityState: z.ZodEnum<["available", "exhausted", "cooldown"]>;
+export type QuotaAvailabilityState = z.infer<typeof QuotaAvailabilityState>;
+export declare const QuotaModelScopedExhaustion: z.ZodObject<{
+    constraint_id: z.ZodString;
+    applies_to_models: z.ZodArray<z.ZodString, "many">;
+    resets_at: z.ZodNullable<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    constraint_id: string;
+    applies_to_models: string[];
+    resets_at: string | null;
+}, {
+    constraint_id: string;
+    applies_to_models: string[];
+    resets_at: string | null;
+}>;
+export type QuotaModelScopedExhaustion = z.infer<typeof QuotaModelScopedExhaustion>;
+export declare const QuotaAvailability: z.ZodObject<{
+    state: z.ZodEnum<["available", "exhausted", "cooldown"]>;
+    blocking_constraints: z.ZodArray<z.ZodString, "many">;
+    resets_at: z.ZodNullable<z.ZodString>;
+    model_scoped_exhaustions: z.ZodArray<z.ZodObject<{
+        constraint_id: z.ZodString;
+        applies_to_models: z.ZodArray<z.ZodString, "many">;
+        resets_at: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        constraint_id: string;
+        applies_to_models: string[];
+        resets_at: string | null;
+    }, {
+        constraint_id: string;
+        applies_to_models: string[];
+        resets_at: string | null;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    state: "available" | "cooldown" | "exhausted";
+    blocking_constraints: string[];
+    resets_at: string | null;
+    model_scoped_exhaustions: {
+        constraint_id: string;
+        applies_to_models: string[];
+        resets_at: string | null;
+    }[];
+}, {
+    state: "available" | "cooldown" | "exhausted";
+    blocking_constraints: string[];
+    resets_at: string | null;
+    model_scoped_exhaustions: {
+        constraint_id: string;
+        applies_to_models: string[];
+        resets_at: string | null;
+    }[];
+}>;
+export type QuotaAvailability = z.infer<typeof QuotaAvailability>;
+export declare const ControlQuotaSnapshot: z.ZodObject<{
+    subject: z.ZodObject<{
+        harness: z.ZodString;
+        credential_route: z.ZodEnum<["vendor_native", "managed_api_key", "local"]>;
+        plan_label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        /** The CREDENTIAL SUBJECT the windows belong to (release wave round-16
+         * #2): a Claudexor credential-profile id, or null for the harness's
+         * engine-default credential. Every producer (oauth-usage refresher,
+         * typed-event registry, adapter quota events) uses exactly this
+         * vocabulary; budget routing filters snapshots by exact subject so one
+         * account's exhaustion never cools another. */
+        subject_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, "strict", z.ZodTypeAny, {
+        harness: string;
+        credential_route: "local" | "managed_api_key" | "vendor_native";
+        plan_label: string | null;
+        subject_id: string | null;
+    }, {
+        harness: string;
+        credential_route: "local" | "managed_api_key" | "vendor_native";
+        plan_label?: string | null | undefined;
+        subject_id?: string | null | undefined;
+    }>;
+    constraints: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        /** omitted/null = this vendor window applies to every model. A non-null
+         * list is the producer's canonical model-id/alias scope, so a
+         * model-specific cap never cools a different model on the same subject. */
+        applies_to_models: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+        used_ratio: z.ZodNullable<z.ZodNumber>;
+        window_seconds: z.ZodNullable<z.ZodNumber>;
+        resets_at: z.ZodNullable<z.ZodString>;
+        cooldown_until: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        label: string;
+        applies_to_models?: string[] | null | undefined;
+        used_ratio: number | null;
+        window_seconds: number | null;
+        resets_at: string | null;
+        cooldown_until: string | null;
+    }, {
+        id: string;
+        label: string;
+        applies_to_models?: string[] | null | undefined;
+        used_ratio: number | null;
+        window_seconds: number | null;
+        resets_at: string | null;
+        cooldown_until?: string | null | undefined;
+    }>, "many">;
+    source: z.ZodEnum<["codex_app_server", "codex_rollout", "claude_statusline", "claude_api_retry", "claude_oauth_usage"]>;
+    observed_at: z.ZodString;
+    freshness: z.ZodEnum<["fresh", "stale", "unknown"]>;
+} & {
+    availability: z.ZodOptional<z.ZodObject<{
+        state: z.ZodEnum<["available", "exhausted", "cooldown"]>;
+        blocking_constraints: z.ZodArray<z.ZodString, "many">;
+        resets_at: z.ZodNullable<z.ZodString>;
+        model_scoped_exhaustions: z.ZodArray<z.ZodObject<{
+            constraint_id: z.ZodString;
+            applies_to_models: z.ZodArray<z.ZodString, "many">;
+            resets_at: z.ZodNullable<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            constraint_id: string;
+            applies_to_models: string[];
+            resets_at: string | null;
+        }, {
+            constraint_id: string;
+            applies_to_models: string[];
+            resets_at: string | null;
+        }>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        state: "available" | "cooldown" | "exhausted";
+        blocking_constraints: string[];
+        resets_at: string | null;
+        model_scoped_exhaustions: {
+            constraint_id: string;
+            applies_to_models: string[];
+            resets_at: string | null;
+        }[];
+    }, {
+        state: "available" | "cooldown" | "exhausted";
+        blocking_constraints: string[];
+        resets_at: string | null;
+        model_scoped_exhaustions: {
+            constraint_id: string;
+            applies_to_models: string[];
+            resets_at: string | null;
+        }[];
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    subject: {
+        harness: string;
+        credential_route: "local" | "managed_api_key" | "vendor_native";
+        plan_label: string | null;
+        subject_id: string | null;
+    };
+    constraints: {
+        id: string;
+        label: string;
+        applies_to_models?: string[] | null | undefined;
+        used_ratio: number | null;
+        window_seconds: number | null;
+        resets_at: string | null;
+        cooldown_until: string | null;
+    }[];
+    source: "claude_api_retry" | "claude_oauth_usage" | "claude_statusline" | "codex_app_server" | "codex_rollout";
+    observed_at: string;
+    freshness: "fresh" | "stale" | "unknown";
+    availability?: {
+        state: "available" | "cooldown" | "exhausted";
+        blocking_constraints: string[];
+        resets_at: string | null;
+        model_scoped_exhaustions: {
+            constraint_id: string;
+            applies_to_models: string[];
+            resets_at: string | null;
+        }[];
+    } | undefined;
+}, {
+    subject: {
+        harness: string;
+        credential_route: "local" | "managed_api_key" | "vendor_native";
+        plan_label?: string | null | undefined;
+        subject_id?: string | null | undefined;
+    };
+    constraints: {
+        id: string;
+        label: string;
+        applies_to_models?: string[] | null | undefined;
+        used_ratio: number | null;
+        window_seconds: number | null;
+        resets_at: string | null;
+        cooldown_until?: string | null | undefined;
+    }[];
+    source: "claude_api_retry" | "claude_oauth_usage" | "claude_statusline" | "codex_app_server" | "codex_rollout";
+    observed_at: string;
+    freshness: "fresh" | "stale" | "unknown";
+    availability?: {
+        state: "available" | "cooldown" | "exhausted";
+        blocking_constraints: string[];
+        resets_at: string | null;
+        model_scoped_exhaustions: {
+            constraint_id: string;
+            applies_to_models: string[];
+            resets_at: string | null;
+        }[];
+    } | undefined;
+}>;
+export type ControlQuotaSnapshot = z.infer<typeof ControlQuotaSnapshot>;
+export declare const ControlQuotaRefreshRequest: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    model?: string | undefined;
+}, {
+    model?: string | undefined;
+}>;
+export type ControlQuotaRefreshRequest = z.infer<typeof ControlQuotaRefreshRequest>;
 export declare const ControlQuotaResponse: z.ZodObject<{
     snapshots: z.ZodArray<z.ZodObject<{
         subject: z.ZodObject<{
@@ -254,6 +466,43 @@ export declare const ControlQuotaResponse: z.ZodObject<{
         source: z.ZodEnum<["codex_app_server", "codex_rollout", "claude_statusline", "claude_api_retry", "claude_oauth_usage"]>;
         observed_at: z.ZodString;
         freshness: z.ZodEnum<["fresh", "stale", "unknown"]>;
+    } & {
+        availability: z.ZodOptional<z.ZodObject<{
+            state: z.ZodEnum<["available", "exhausted", "cooldown"]>;
+            blocking_constraints: z.ZodArray<z.ZodString, "many">;
+            resets_at: z.ZodNullable<z.ZodString>;
+            model_scoped_exhaustions: z.ZodArray<z.ZodObject<{
+                constraint_id: z.ZodString;
+                applies_to_models: z.ZodArray<z.ZodString, "many">;
+                resets_at: z.ZodNullable<z.ZodString>;
+            }, "strict", z.ZodTypeAny, {
+                constraint_id: string;
+                applies_to_models: string[];
+                resets_at: string | null;
+            }, {
+                constraint_id: string;
+                applies_to_models: string[];
+                resets_at: string | null;
+            }>, "many">;
+        }, "strict", z.ZodTypeAny, {
+            state: "available" | "cooldown" | "exhausted";
+            blocking_constraints: string[];
+            resets_at: string | null;
+            model_scoped_exhaustions: {
+                constraint_id: string;
+                applies_to_models: string[];
+                resets_at: string | null;
+            }[];
+        }, {
+            state: "available" | "cooldown" | "exhausted";
+            blocking_constraints: string[];
+            resets_at: string | null;
+            model_scoped_exhaustions: {
+                constraint_id: string;
+                applies_to_models: string[];
+                resets_at: string | null;
+            }[];
+        }>>;
     }, "strict", z.ZodTypeAny, {
         subject: {
             harness: string;
@@ -273,6 +522,16 @@ export declare const ControlQuotaResponse: z.ZodObject<{
         source: "claude_api_retry" | "claude_oauth_usage" | "claude_statusline" | "codex_app_server" | "codex_rollout";
         observed_at: string;
         freshness: "fresh" | "stale" | "unknown";
+        availability?: {
+            state: "available" | "cooldown" | "exhausted";
+            blocking_constraints: string[];
+            resets_at: string | null;
+            model_scoped_exhaustions: {
+                constraint_id: string;
+                applies_to_models: string[];
+                resets_at: string | null;
+            }[];
+        } | undefined;
     }, {
         subject: {
             harness: string;
@@ -292,6 +551,16 @@ export declare const ControlQuotaResponse: z.ZodObject<{
         source: "claude_api_retry" | "claude_oauth_usage" | "claude_statusline" | "codex_app_server" | "codex_rollout";
         observed_at: string;
         freshness: "fresh" | "stale" | "unknown";
+        availability?: {
+            state: "available" | "cooldown" | "exhausted";
+            blocking_constraints: string[];
+            resets_at: string | null;
+            model_scoped_exhaustions: {
+                constraint_id: string;
+                applies_to_models: string[];
+                resets_at: string | null;
+            }[];
+        } | undefined;
     }>, "many">;
     absences: z.ZodDefault<z.ZodArray<z.ZodObject<{
         subject: z.ZodObject<{
@@ -361,6 +630,16 @@ export declare const ControlQuotaResponse: z.ZodObject<{
         source: "claude_api_retry" | "claude_oauth_usage" | "claude_statusline" | "codex_app_server" | "codex_rollout";
         observed_at: string;
         freshness: "fresh" | "stale" | "unknown";
+        availability?: {
+            state: "available" | "cooldown" | "exhausted";
+            blocking_constraints: string[];
+            resets_at: string | null;
+            model_scoped_exhaustions: {
+                constraint_id: string;
+                applies_to_models: string[];
+                resets_at: string | null;
+            }[];
+        } | undefined;
     }[];
     absences: {
         subject: {
@@ -394,6 +673,16 @@ export declare const ControlQuotaResponse: z.ZodObject<{
         source: "claude_api_retry" | "claude_oauth_usage" | "claude_statusline" | "codex_app_server" | "codex_rollout";
         observed_at: string;
         freshness: "fresh" | "stale" | "unknown";
+        availability?: {
+            state: "available" | "cooldown" | "exhausted";
+            blocking_constraints: string[];
+            resets_at: string | null;
+            model_scoped_exhaustions: {
+                constraint_id: string;
+                applies_to_models: string[];
+                resets_at: string | null;
+            }[];
+        } | undefined;
     }[];
     absences?: {
         subject: {
@@ -409,4 +698,29 @@ export declare const ControlQuotaResponse: z.ZodObject<{
     refreshed_at: string | null;
 }>;
 export type ControlQuotaResponse = z.infer<typeof ControlQuotaResponse>;
+/** Derive one snapshot's typed model-aware availability — a pure projection
+ * over the snapshot's own constraints, never an aggregate across subjects.
+ * Blocking semantics mirror the router's `BudgetLedger`: a window
+ * blocks while its cooldown_until is in the future, or while used_ratio >= 1
+ * with a still-future resets_at (a spent ratio whose reset elapsed or is
+ * unknown is stale data, not a live block). Without `model`, only windows that
+ * apply to EVERY model can block; model-scoped spent windows are disclosed in
+ * model_scoped_exhaustions and leave state available — including a spent
+ * scoped window whose reset is UNKNOWN (disclosed with resets_at null, never
+ * blocking); one whose reset ELAPSED is provably released and not disclosed.
+ * With `model`, scoped windows matching it block too.
+ * Full-coverage inference ("every model is
+ * covered by some spent scoped window") is deliberately not attempted: the
+ * model universe is unknowable here, so that case stays available + disclosed. */
+export declare function quotaSnapshotAvailability(snapshot: Pick<QuotaSnapshot, "constraints">, opts?: {
+    now?: Date;
+    model?: string | null;
+}): QuotaAvailability;
+/** Decorate a quota response with per-snapshot availability projections —
+ * applied at the /v2/quota boundary so journals, projection signatures, and
+ * embedded raw snapshots stay byte-identical. */
+export declare function withQuotaAvailability(response: ControlQuotaResponse, opts?: {
+    now?: Date;
+    model?: string | null;
+}): ControlQuotaResponse;
 //# sourceMappingURL=quota.d.ts.map

package/dist/quota.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quota.d.ts","sourceRoot":"","sources":["../src/quota.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAG3B,eAAO,MAAM,WAAW,iHAQgD,CAAC;AACzE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEtD,eAAO,MAAM,cAAc,0CAE+B,CAAC;AAC3D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,eAAO,MAAM,YAAY;;;;IAKrB;;;;;mDAK+C;;;;;;;;;;;;EAMhD,CAAC;AACJ,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD,eAAO,MAAM,eAAe;;;IAIxB;;+EAE2E;;;;;;;;;;;;;;;;;;;;;;EAU5E,CAAC;AACJ,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,eAAO,MAAM,aAAa;;;;;QAjCtB;;;;;uDAK+C;;;;;;;;;;;;;;;;QAa/C;;mFAE2E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBM,CAAC;AACtF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D,eAAO,MAAM,kBAAkB,8HAa+D,CAAC;AAC/F,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,eAAO,MAAM,YAAY;;;;;QA7DrB;;;;;uDAK+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgE8C,CAAC;AAClG,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD,eAAO,MAAM,oBAAoB;;;;;;YAxE7B;;;;;2DAK+C;;;;;;;;;;;;;;;;YAa/C;;uFAE2E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YApB3E;;;;;2DAK+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+EmB,CAAC;AACvE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}
+{"version":3,"file":"quota.d.ts","sourceRoot":"","sources":["../src/quota.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAG3B,eAAO,MAAM,WAAW,iHAQgD,CAAC;AACzE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEtD,eAAO,MAAM,cAAc,0CAE+B,CAAC;AAC3D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,eAAO,MAAM,YAAY;;;;IAKrB;;;;;mDAK+C;;;;;;;;;;;;EAMhD,CAAC;AACJ,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD,eAAO,MAAM,eAAe;;;IAIxB;;+EAE2E;;;;;;;;;;;;;;;;;;;;;;EAU5E,CAAC;AACJ,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,eAAO,MAAM,aAAa;;;;;QAjCtB;;;;;uDAK+C;;;;;;;;;;;;;;;;QAa/C;;mFAE2E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsBM,CAAC;AACtF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D,eAAO,MAAM,kBAAkB,8HAa+D,CAAC;AAC/F,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,eAAO,MAAM,YAAY;;;;;QA7DrB;;;;;uDAK+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgE8C,CAAC;AAClG,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD,eAAO,MAAM,sBAAsB,mDAIhC,CAAC;AACJ,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE5E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;EASpC,CAAC;AACJ,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAEpF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsB3B,CAAC;AACJ,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,eAAO,MAAM,oBAAoB;;;;;QApH7B;;;;;uDAK+C;;;;;;;;;;;;;;;;QAa/C;;mFAE2E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoGS,CAAC;AACzF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAExE,eAAO,MAAM,0BAA0B;;;;;;EAapC,CAAC;AACJ,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAEpF,eAAO,MAAM,oBAAoB;;;;;;YA3I7B;;;;;2DAK+C;;;;;;;;;;;;;;;;YAa/C;;uFAE2E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YApB3E;;;;;2DAK+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkJmB,CAAC;AACvE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AA4BxE;;;;;;;;;;;;;kFAakF;AAClF,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,IAAI,CAAC,aAAa,EAAE,aAAa,CAAC,EAC5C,IAAI,GAAE;IAAE,GAAG,CAAC,EAAE,IAAI,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAO,GAC/C,iBAAiB,CAyDnB;AAED;;iDAEiD;AACjD,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,oBAAoB,EAC9B,IAAI,GAAE;IAAE,GAAG,CAAC,EAAE,IAAI,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAO,GAC/C,oBAAoB,CAQtB"}

package/dist/quota.js

@@ -75,9 +75,50 @@ export const QuotaAbsence = z
 })
     .strict()
     .describe("A registered subject's typed missing-snapshot — absence is stated, never inferred.");
+export const QuotaAvailabilityState = z
+    .enum(["available", "exhausted", "cooldown"])
+    .describe("Spendability verdict for one snapshot: exhausted = a spent window blocks every applicable request; cooldown = an applicable window is only rate-limit-cooling; available = nothing applicable blocks.");
+export const QuotaModelScopedExhaustion = z
+    .object({
+    constraint_id: Id,
+    applies_to_models: z.array(Id).min(1),
+    resets_at: z.string().datetime({ offset: true }).nullable(),
+})
+    .strict()
+    .describe("A spent or cooling window that applies only to the named models. Without a requested model it never sets the whole subject exhausted; when the request names a model it covers, it blocks that request too (and is then also listed in blocking_constraints). resets_at is its earliest known release instant (null = unknown).");
+export const QuotaAvailability = z
+    .object({
+    state: QuotaAvailabilityState,
+    blocking_constraints: z
+        .array(Id)
+        .describe("Ids of the constraints that produced a non-available state."),
+    resets_at: z
+        .string()
+        .datetime({ offset: true })
+        .nullable()
+        .describe("Earliest known instant at which any blocking constraint may release; null when nothing blocks or no reset is known."),
+    model_scoped_exhaustions: z
+        .array(QuotaModelScopedExhaustion)
+        .describe("Every spent/cooling model-scoped window, listed regardless of state so consumers see partial exhaustion without re-deriving constraint scope."),
+})
+    .strict()
+    .describe("Derived model-aware availability projection for one quota snapshot. Without a requested model, only windows applying to EVERY model can set exhausted/cooldown — a model-scoped spent window keeps state available and is disclosed in model_scoped_exhaustions.");
+export const ControlQuotaSnapshot = QuotaSnapshot.extend({
+    availability: QuotaAvailability.optional().describe("Typed availability projection derived by the /v2/quota route; absent on surfaces that embed raw snapshots."),
+}).describe("One vendor-owned quota snapshot plus its derived availability projection.");
+export const ControlQuotaRefreshRequest = z
+    .object({
+    model: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Optional model id/alias the caller intends to spend against. When present, each snapshot's availability.state is computed against this model (case-insensitive alias containment in either direction), so windows scoped to OTHER models never report the subject exhausted."),
+})
+    .strict()
+    .describe("Optional POST /v2/quota body; an empty or absent body keeps the model-agnostic projection.");
 export const ControlQuotaResponse = z
     .object({
-    snapshots: z.array(QuotaSnapshot),
+    snapshots: z.array(ControlQuotaSnapshot),
     absences: z
         .array(QuotaAbsence)
         .default([])
@@ -86,4 +127,113 @@ export const ControlQuotaResponse = z
 })
     .strict()
     .describe("Current quota snapshots without a fabricated aggregate.");
+/** Millisecond instant of a still-future ISO timestamp, else null. */
+function futureMs(iso, now) {
+    if (!iso)
+        return null;
+    const at = Date.parse(iso);
+    return Number.isFinite(at) && at > now ? at : null;
+}
+/** API-parameter model matching, deliberately looser than the router's exact
+ * `quotaConstraintAppliesToModel` (@claudexor/budget): consumers pass whatever
+ * model string they route with ("claude-fable-5", "fable", a bracketed
+ * variant), while producers publish vendor alias lists — so match by
+ * case-insensitive alias containment in either direction. A null/empty scope
+ * list is a vendor-wide window and matches every model. */
+function modelScopeMatches(scope, model) {
+    if (scope == null || scope.length === 0)
+        return true;
+    const target = model.trim().toLowerCase();
+    return scope.some((alias) => {
+        const candidate = alias.trim().toLowerCase();
+        return (candidate !== "" &&
+            target !== "" &&
+            (candidate.includes(target) || target.includes(candidate)));
+    });
+}
+/** Derive one snapshot's typed model-aware availability — a pure projection
+ * over the snapshot's own constraints, never an aggregate across subjects.
+ * Blocking semantics mirror the router's `BudgetLedger`: a window
+ * blocks while its cooldown_until is in the future, or while used_ratio >= 1
+ * with a still-future resets_at (a spent ratio whose reset elapsed or is
+ * unknown is stale data, not a live block). Without `model`, only windows that
+ * apply to EVERY model can block; model-scoped spent windows are disclosed in
+ * model_scoped_exhaustions and leave state available — including a spent
+ * scoped window whose reset is UNKNOWN (disclosed with resets_at null, never
+ * blocking); one whose reset ELAPSED is provably released and not disclosed.
+ * With `model`, scoped windows matching it block too.
+ * Full-coverage inference ("every model is
+ * covered by some spent scoped window") is deliberately not attempted: the
+ * model universe is unknowable here, so that case stays available + disclosed. */
+export function quotaSnapshotAvailability(snapshot, opts = {}) {
+    const now = (opts.now ?? new Date()).getTime();
+    const model = opts.model ?? null;
+    const blocking = [];
+    const scopedExhaustions = [];
+    let sawExhausted = false;
+    let earliestRelease = null;
+    for (const constraint of snapshot.constraints) {
+        const resetAt = futureMs(constraint.resets_at, now);
+        const cooldownAt = futureMs(constraint.cooldown_until, now);
+        const exhausted = constraint.used_ratio !== null && constraint.used_ratio >= 1 && resetAt !== null;
+        const cooling = cooldownAt !== null;
+        // A spent ratio with an UNKNOWN reset never blocks (BudgetLedger mirror:
+        // stale data, not a live block), but a scoped one is still DISCLOSED below
+        // with resets_at null; an elapsed reset is provably released and stays
+        // undisclosed.
+        const spentUnknownReset = constraint.used_ratio !== null && constraint.used_ratio >= 1 && constraint.resets_at === null;
+        if (!exhausted && !cooling && !spentUnknownReset)
+            continue;
+        // A constraint stays blocked until EVERY active condition lifts, so its
+        // own release is the LATER of the two; the snapshot-level resets_at below
+        // is the EARLIEST such release across blocking constraints. A
+        // disclosure-only window (spent, unknown reset) has no release instant.
+        const release = !exhausted && !cooling
+            ? null
+            : exhausted && cooling
+                ? resetAt >= cooldownAt
+                    ? { iso: constraint.resets_at, at: resetAt }
+                    : { iso: constraint.cooldown_until, at: cooldownAt }
+                : exhausted
+                    ? { iso: constraint.resets_at, at: resetAt }
+                    : { iso: constraint.cooldown_until, at: cooldownAt };
+        const scope = constraint.applies_to_models ?? null;
+        const scoped = scope !== null && scope.length > 0;
+        if (scoped) {
+            scopedExhaustions.push({
+                constraint_id: constraint.id,
+                applies_to_models: [...scope],
+                resets_at: release?.iso ?? null,
+            });
+        }
+        if (release === null)
+            continue;
+        if (scoped && (model === null || !modelScopeMatches(scope, model)))
+            continue;
+        blocking.push(constraint.id);
+        if (exhausted)
+            sawExhausted = true;
+        if (earliestRelease === null || release.at < earliestRelease.at) {
+            earliestRelease = release;
+        }
+    }
+    return QuotaAvailability.parse({
+        state: blocking.length === 0 ? "available" : sawExhausted ? "exhausted" : "cooldown",
+        blocking_constraints: blocking,
+        resets_at: earliestRelease?.iso ?? null,
+        model_scoped_exhaustions: scopedExhaustions,
+    });
+}
+/** Decorate a quota response with per-snapshot availability projections —
+ * applied at the /v2/quota boundary so journals, projection signatures, and
+ * embedded raw snapshots stay byte-identical. */
+export function withQuotaAvailability(response, opts = {}) {
+    return {
+        ...response,
+        snapshots: response.snapshots.map((snapshot) => ({
+            ...snapshot,
+            availability: quotaSnapshotAvailability(snapshot, opts),
+        })),
+    };
+}
 //# sourceMappingURL=quota.js.map

package/dist/quota.js.map

@@ -1 +1 @@
-{"version":3,"file":"quota.js","sourceRoot":"","sources":["../src/quota.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"quota.js","sourceRoot":"","sources":["../src/quota.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAC3B,OAAO,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AAErC,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC;KACzB,IAAI,CAAC;IACJ,kBAAkB;IAClB,eAAe;IACf,mBAAmB;IACnB,kBAAkB;IAClB,oBAAoB;CACrB,CAAC;KACD,QAAQ,CAAC,2DAA2D,CAAC,CAAC;AAGzE,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC;KAC5B,IAAI,CAAC,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;KACnC,QAAQ,CAAC,6CAA6C,CAAC,CAAC;AAG3D,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC;KAC1B,MAAM,CAAC;IACN,OAAO,EAAE,EAAE;IACX,gBAAgB,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,eAAe,EAAE,iBAAiB,EAAE,OAAO,CAAC,CAAC;IACvE,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;IAC/C;;;;;mDAK+C;IAC/C,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;CAChD,CAAC;KACD,MAAM,EAAE;KACR,QAAQ,CACP,mHAAmH,CACpH,CAAC;AAGJ,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC;KAC7B,MAAM,CAAC;IACN,EAAE,EAAE,EAAE;IACN,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACxB;;+EAE2E;IAC3E,iBAAiB,EAAE,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IACpD,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IAC/C,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IAChD,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,QAAQ,EAAE;IAC3D,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;CAC/E,CAAC;KACD,MAAM,EAAE;KACR,QAAQ,CACP,sHAAsH,CACvH,CAAC;AAGJ,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC;KAC3B,MAAM,CAAC;IACN,OAAO,EAAE,YAAY;IACrB,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC;IACrC,MAAM,EAAE,WAAW;IACnB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;IAClD,SAAS,EAAE,cAAc;CAC1B,CAAC;KACD,MAAM,EAAE;KACR,QAAQ,CAAC,wEAAwE,CAAC,CAAC;AAGtF,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC;KAChC,IAAI,CAAC;IACJ,eAAe;IACf,uBAAuB;IACvB,sBAAsB;IACtB,gBAAgB;IAChB,WAAW;IACX;;;6EAGyE;IACzE,cAAc;CACf,CAAC;KACD,QAAQ,CAAC,iFAAiF,CAAC,CAAC;AAG/F,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC;KAC1B,MAAM,CAAC;IACN,OAAO,EAAE,YAAY;IACrB,MAAM,EAAE,kBAAkB;IAC1B,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;IAC3C,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;CACnD,CAAC;KACD,MAAM,EAAE;KACR,QAAQ,CAAC,oFAAoF,CAAC,CAAC;AAGlG,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC;KACpC,IAAI,CAAC,CAAC,WAAW,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;KAC5C,QAAQ,CACP,uMAAuM,CACxM,CAAC;AAGJ,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC;KACxC,MAAM,CAAC;IACN,aAAa,EAAE,EAAE;IACjB,iBAAiB,EAAE,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACrC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,QAAQ,EAAE;CAC5D,CAAC;KACD,MAAM,EAAE;KACR,QAAQ,CACP,iUAAiU,CAClU,CAAC;AAGJ,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC;KAC/B,MAAM,CAAC;IACN,KAAK,EAAE,sBAAsB;IAC7B,oBAAoB,EAAE,CAAC;SACpB,KAAK,CAAC,EAAE,CAAC;SACT,QAAQ,CAAC,6DAA6D,CAAC;IAC1E,SAAS,EAAE,CAAC;SACT,MAAM,EAAE;SACR,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;SAC1B,QAAQ,EAAE;SACV,QAAQ,CACP,qHAAqH,CACtH;IACH,wBAAwB,EAAE,CAAC;SACxB,KAAK,CAAC,0BAA0B,CAAC;SACjC,QAAQ,CACP,+IAA+I,CAChJ;CACJ,CAAC;KACD,MAAM,EAAE;KACR,QAAQ,CACP,kQAAkQ,CACnQ,CAAC;AAGJ,MAAM,CAAC,MAAM,oBAAoB,GAAG,aAAa,CAAC,MAAM,CAAC;IACvD,YAAY,EAAE,iBAAiB,CAAC,QAAQ,EAAE,CAAC,QAAQ,CACjD,4GAA4G,CAC7G;CACF,CAAC,CAAC,QAAQ,CAAC,2EAA2E,CAAC,CAAC;AAGzF,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC;KACxC,MAAM,CAAC;IACN,KAAK,EAAE,CAAC;SACL,MAAM,EAAE;SACR,GAAG,CAAC,CAAC,CAAC;SACN,QAAQ,EAAE;SACV,QAAQ,CACP,8QAA8Q,CAC/Q;CACJ,CAAC;KACD,MAAM,EAAE;KACR,QAAQ,CACP,4FAA4F,CAC7F,CAAC;AAGJ,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC;KAClC,MAAM,CAAC;IACN,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC;IACxC,QAAQ,EAAE,CAAC;SACR,KAAK,CAAC,YAAY,CAAC;SACnB,OAAO,CAAC,EAAE,CAAC;SACX,QAAQ,CACP,mIAAmI,CACpI;IACH,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,QAAQ,EAAE;CAC/D,CAAC;KACD,MAAM,EAAE;KACR,QAAQ,CAAC,yDAAyD,CAAC,CAAC;AAGvE,sEAAsE;AACtE,SAAS,QAAQ,CAAC,GAAkB,EAAE,GAAW;IAC/C,IAAI,CAAC,GAAG;QAAE,OAAO,IAAI,CAAC;IACtB,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC3B,OAAO,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;AACrD,CAAC;AAED;;;;;2DAK2D;AAC3D,SAAS,iBAAiB,CAAC,KAA2C,EAAE,KAAa;IACnF,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACrD,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IAC1C,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;QAC1B,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QAC7C,OAAO,CACL,SAAS,KAAK,EAAE;YAChB,MAAM,KAAK,EAAE;YACb,CAAC,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAC3D,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;kFAakF;AAClF,MAAM,UAAU,yBAAyB,CACvC,QAA4C,EAC5C,IAAI,GAA0C,EAAE;IAEhD,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,IAAI,IAAI,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;IAC/C,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC;IACjC,MAAM,QAAQ,GAAa,EAAE,CAAC;IAC9B,MAAM,iBAAiB,GAAiC,EAAE,CAAC;IAC3D,IAAI,YAAY,GAAG,KAAK,CAAC;IACzB,IAAI,eAAe,GAAuC,IAAI,CAAC;IAC/D,KAAK,MAAM,UAAU,IAAI,QAAQ,CAAC,WAAW,EAAE,CAAC;QAC9C,MAAM,OAAO,GAAG,QAAQ,CAAC,UAAU,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;QACpD,MAAM,UAAU,GAAG,QAAQ,CAAC,UAAU,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC;QAC5D,MAAM,SAAS,GACb,UAAU,CAAC,UAAU,KAAK,IAAI,IAAI,UAAU,CAAC,UAAU,IAAI,CAAC,IAAI,OAAO,KAAK,IAAI,CAAC;QACnF,MAAM,OAAO,GAAG,UAAU,KAAK,IAAI,CAAC;QACpC,yEAAyE;QACzE,2EAA2E;QAC3E,uEAAuE;QACvE,eAAe;QACf,MAAM,iBAAiB,GACrB,UAAU,CAAC,UAAU,KAAK,IAAI,IAAI,UAAU,CAAC,UAAU,IAAI,CAAC,IAAI,UAAU,CAAC,SAAS,KAAK,IAAI,CAAC;QAChG,IAAI,CAAC,SAAS,IAAI,CAAC,OAAO,IAAI,CAAC,iBAAiB;YAAE,SAAS;QAC3D,wEAAwE;QACxE,0EAA0E;QAC1E,8DAA8D;QAC9D,wEAAwE;QACxE,MAAM,OAAO,GACX,CAAC,SAAS,IAAI,CAAC,OAAO;YACpB,CAAC,CAAC,IAAI;YACN,CAAC,CAAC,SAAS,IAAI,OAAO;gBACpB,CAAC,CAAE,OAAkB,IAAK,UAAqB;oBAC7C,CAAC,CAAC,EAAE,GAAG,EAAE,UAAU,CAAC,SAAmB,EAAE,EAAE,EAAE,OAAiB,EAAE;oBAChE,CAAC,CAAC,EAAE,GAAG,EAAE,UAAU,CAAC,cAAwB,EAAE,EAAE,EAAE,UAAoB,EAAE;gBAC1E,CAAC,CAAC,SAAS;oBACT,CAAC,CAAC,EAAE,GAAG,EAAE,UAAU,CAAC,SAAmB,EAAE,EAAE,EAAE,OAAiB,EAAE;oBAChE,CAAC,CAAC,EAAE,GAAG,EAAE,UAAU,CAAC,cAAwB,EAAE,EAAE,EAAE,UAAoB,EAAE,CAAC;QACjF,MAAM,KAAK,GAAG,UAAU,CAAC,iBAAiB,IAAI,IAAI,CAAC;QACnD,MAAM,MAAM,GAAG,KAAK,KAAK,IAAI,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;QAClD,IAAI,MAAM,EAAE,CAAC;YACX,iBAAiB,CAAC,IAAI,CAAC;gBACrB,aAAa,EAAE,UAAU,CAAC,EAAE;gBAC5B,iBAAiB,EAAE,CAAC,GAAG,KAAK,CAAC;gBAC7B,SAAS,EAAE,OAAO,EAAE,GAAG,IAAI,IAAI;aAChC,CAAC,CAAC;QACL,CAAC;QACD,IAAI,OAAO,KAAK,IAAI;YAAE,SAAS;QAC/B,IAAI,MAAM,IAAI,CAAC,KAAK,KAAK,IAAI,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;YAAE,SAAS;QAC7E,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;QAC7B,IAAI,SAAS;YAAE,YAAY,GAAG,IAAI,CAAC;QACnC,IAAI,eAAe,KAAK,IAAI,IAAI,OAAO,CAAC,EAAE,GAAG,eAAe,CAAC,EAAE,EAAE,CAAC;YAChE,eAAe,GAAG,OAAO,CAAC;QAC5B,CAAC;IACH,CAAC;IACD,OAAO,iBAAiB,CAAC,KAAK,CAAC;QAC7B,KAAK,EAAE,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,UAAU;QACpF,oBAAoB,EAAE,QAAQ;QAC9B,SAAS,EAAE,eAAe,EAAE,GAAG,IAAI,IAAI;QACvC,wBAAwB,EAAE,iBAAiB;KAC5C,CAAC,CAAC;AACL,CAAC;AAED;;iDAEiD;AACjD,MAAM,UAAU,qBAAqB,CACnC,QAA8B,EAC9B,IAAI,GAA0C,EAAE;IAEhD,OAAO;QACL,GAAG,QAAQ;QACX,SAAS,EAAE,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;YAC/C,GAAG,QAAQ;YACX,YAAY,EAAE,yBAAyB,CAAC,QAAQ,EAAE,IAAI,CAAC;SACxD,CAAC,CAAC;KACJ,CAAC;AACJ,CAAC"}

package/generated/ControlCredentialProfilesQueryResponse.schema.json

@@ -1256,6 +1256,84 @@
                           "unknown"
                         ],
                         "description": "Freshness of a quota snapshot at read time."
+                      },
+                      "availability": {
+                        "type": "object",
+                        "properties": {
+                          "state": {
+                            "type": "string",
+                            "enum": [
+                              "available",
+                              "exhausted",
+                              "cooldown"
+                            ],
+                            "description": "Spendability verdict for one snapshot: exhausted = a spent window blocks every applicable request; cooldown = an applicable window is only rate-limit-cooling; available = nothing applicable blocks."
+                          },
+                          "blocking_constraints": {
+                            "type": "array",
+                            "items": {
+                              "$ref": "#/definitions/ControlCredentialProfilesQueryResponse/anyOf/0/properties/profiles/items/properties/status/properties/profile_id"
+                            },
+                            "description": "Ids of the constraints that produced a non-available state."
+                          },
+                          "resets_at": {
+                            "anyOf": [
+                              {
+                                "type": "string",
+                                "format": "date-time"
+                              },
+                              {
+                                "type": "null"
+                              }
+                            ],
+                            "description": "Earliest known instant at which any blocking constraint may release; null when nothing blocks or no reset is known."
+                          },
+                          "model_scoped_exhaustions": {
+                            "type": "array",
+                            "items": {
+                              "type": "object",
+                              "properties": {
+                                "constraint_id": {
+                                  "$ref": "#/definitions/ControlCredentialProfilesQueryResponse/anyOf/0/properties/profiles/items/properties/status/properties/profile_id"
+                                },
+                                "applies_to_models": {
+                                  "type": "array",
+                                  "items": {
+                                    "$ref": "#/definitions/ControlCredentialProfilesQueryResponse/anyOf/0/properties/profiles/items/properties/status/properties/profile_id"
+                                  },
+                                  "minItems": 1
+                                },
+                                "resets_at": {
+                                  "anyOf": [
+                                    {
+                                      "type": "string",
+                                      "format": "date-time"
+                                    },
+                                    {
+                                      "type": "null"
+                                    }
+                                  ]
+                                }
+                              },
+                              "required": [
+                                "constraint_id",
+                                "applies_to_models",
+                                "resets_at"
+                              ],
+                              "additionalProperties": false,
+                              "description": "A spent or cooling window that applies only to the named models. Without a requested model it never sets the whole subject exhausted; when the request names a model it covers, it blocks that request too (and is then also listed in blocking_constraints). resets_at is its earliest known release instant (null = unknown)."
+                            },
+                            "description": "Every spent/cooling model-scoped window, listed regardless of state so consumers see partial exhaustion without re-deriving constraint scope."
+                          }
+                        },
+                        "required": [
+                          "state",
+                          "blocking_constraints",
+                          "resets_at",
+                          "model_scoped_exhaustions"
+                        ],
+                        "additionalProperties": false,
+                        "description": "Typed availability projection derived by the /v2/quota route; absent on surfaces that embed raw snapshots."
                       }
                     },
                     "required": [
@@ -1266,7 +1344,7 @@
                       "freshness"
                     ],
                     "additionalProperties": false,
-                    "description": "All independently reported quota windows for one vendor-owned subject."
+                    "description": "One vendor-owned quota snapshot plus its derived availability projection."
                   }
                 },
                 "absences": {

package/generated/ControlCredentialProfilesSnapshotResponse.schema.json

@@ -1238,6 +1238,84 @@
                       "unknown"
                     ],
                     "description": "Freshness of a quota snapshot at read time."
+                  },
+                  "availability": {
+                    "type": "object",
+                    "properties": {
+                      "state": {
+                        "type": "string",
+                        "enum": [
+                          "available",
+                          "exhausted",
+                          "cooldown"
+                        ],
+                        "description": "Spendability verdict for one snapshot: exhausted = a spent window blocks every applicable request; cooldown = an applicable window is only rate-limit-cooling; available = nothing applicable blocks."
+                      },
+                      "blocking_constraints": {
+                        "type": "array",
+                        "items": {
+                          "$ref": "#/definitions/ControlCredentialProfilesSnapshotResponse/properties/profiles/items/properties/status/properties/profile_id"
+                        },
+                        "description": "Ids of the constraints that produced a non-available state."
+                      },
+                      "resets_at": {
+                        "anyOf": [
+                          {
+                            "type": "string",
+                            "format": "date-time"
+                          },
+                          {
+                            "type": "null"
+                          }
+                        ],
+                        "description": "Earliest known instant at which any blocking constraint may release; null when nothing blocks or no reset is known."
+                      },
+                      "model_scoped_exhaustions": {
+                        "type": "array",
+                        "items": {
+                          "type": "object",
+                          "properties": {
+                            "constraint_id": {
+                              "$ref": "#/definitions/ControlCredentialProfilesSnapshotResponse/properties/profiles/items/properties/status/properties/profile_id"
+                            },
+                            "applies_to_models": {
+                              "type": "array",
+                              "items": {
+                                "$ref": "#/definitions/ControlCredentialProfilesSnapshotResponse/properties/profiles/items/properties/status/properties/profile_id"
+                              },
+                              "minItems": 1
+                            },
+                            "resets_at": {
+                              "anyOf": [
+                                {
+                                  "type": "string",
+                                  "format": "date-time"
+                                },
+                                {
+                                  "type": "null"
+                                }
+                              ]
+                            }
+                          },
+                          "required": [
+                            "constraint_id",
+                            "applies_to_models",
+                            "resets_at"
+                          ],
+                          "additionalProperties": false,
+                          "description": "A spent or cooling window that applies only to the named models. Without a requested model it never sets the whole subject exhausted; when the request names a model it covers, it blocks that request too (and is then also listed in blocking_constraints). resets_at is its earliest known release instant (null = unknown)."
+                        },
+                        "description": "Every spent/cooling model-scoped window, listed regardless of state so consumers see partial exhaustion without re-deriving constraint scope."
+                      }
+                    },
+                    "required": [
+                      "state",
+                      "blocking_constraints",
+                      "resets_at",
+                      "model_scoped_exhaustions"
+                    ],
+                    "additionalProperties": false,
+                    "description": "Typed availability projection derived by the /v2/quota route; absent on surfaces that embed raw snapshots."
                   }
                 },
                 "required": [
@@ -1248,7 +1326,7 @@
                   "freshness"
                 ],
                 "additionalProperties": false,
-                "description": "All independently reported quota windows for one vendor-owned subject."
+                "description": "One vendor-owned quota snapshot plus its derived availability projection."
               }
             },
             "absences": {

package/generated/ControlQuotaRefreshRequest.schema.json

@@ -0,0 +1,18 @@
+{
+  "$ref": "#/definitions/ControlQuotaRefreshRequest",
+  "definitions": {
+    "ControlQuotaRefreshRequest": {
+      "type": "object",
+      "properties": {
+        "model": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Optional model id/alias the caller intends to spend against. When present, each snapshot's availability.state is computed against this model (case-insensitive alias containment in either direction), so windows scoped to OTHER models never report the subject exhausted."
+        }
+      },
+      "additionalProperties": false,
+      "description": "Optional POST /v2/quota body; an empty or absent body keeps the model-agnostic projection."
+    }
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/generated/ControlQuotaResponse.schema.json

@@ -153,6 +153,84 @@
                   "unknown"
                 ],
                 "description": "Freshness of a quota snapshot at read time."
+              },
+              "availability": {
+                "type": "object",
+                "properties": {
+                  "state": {
+                    "type": "string",
+                    "enum": [
+                      "available",
+                      "exhausted",
+                      "cooldown"
+                    ],
+                    "description": "Spendability verdict for one snapshot: exhausted = a spent window blocks every applicable request; cooldown = an applicable window is only rate-limit-cooling; available = nothing applicable blocks."
+                  },
+                  "blocking_constraints": {
+                    "type": "array",
+                    "items": {
+                      "$ref": "#/definitions/ControlQuotaResponse/properties/snapshots/items/properties/subject/properties/harness"
+                    },
+                    "description": "Ids of the constraints that produced a non-available state."
+                  },
+                  "resets_at": {
+                    "anyOf": [
+                      {
+                        "type": "string",
+                        "format": "date-time"
+                      },
+                      {
+                        "type": "null"
+                      }
+                    ],
+                    "description": "Earliest known instant at which any blocking constraint may release; null when nothing blocks or no reset is known."
+                  },
+                  "model_scoped_exhaustions": {
+                    "type": "array",
+                    "items": {
+                      "type": "object",
+                      "properties": {
+                        "constraint_id": {
+                          "$ref": "#/definitions/ControlQuotaResponse/properties/snapshots/items/properties/subject/properties/harness"
+                        },
+                        "applies_to_models": {
+                          "type": "array",
+                          "items": {
+                            "$ref": "#/definitions/ControlQuotaResponse/properties/snapshots/items/properties/subject/properties/harness"
+                          },
+                          "minItems": 1
+                        },
+                        "resets_at": {
+                          "anyOf": [
+                            {
+                              "type": "string",
+                              "format": "date-time"
+                            },
+                            {
+                              "type": "null"
+                            }
+                          ]
+                        }
+                      },
+                      "required": [
+                        "constraint_id",
+                        "applies_to_models",
+                        "resets_at"
+                      ],
+                      "additionalProperties": false,
+                      "description": "A spent or cooling window that applies only to the named models. Without a requested model it never sets the whole subject exhausted; when the request names a model it covers, it blocks that request too (and is then also listed in blocking_constraints). resets_at is its earliest known release instant (null = unknown)."
+                    },
+                    "description": "Every spent/cooling model-scoped window, listed regardless of state so consumers see partial exhaustion without re-deriving constraint scope."
+                  }
+                },
+                "required": [
+                  "state",
+                  "blocking_constraints",
+                  "resets_at",
+                  "model_scoped_exhaustions"
+                ],
+                "additionalProperties": false,
+                "description": "Typed availability projection derived by the /v2/quota route; absent on surfaces that embed raw snapshots."
               }
             },
             "required": [
@@ -163,7 +241,7 @@
               "freshness"
             ],
             "additionalProperties": false,
-            "description": "All independently reported quota windows for one vendor-owned subject."
+            "description": "One vendor-owned quota snapshot plus its derived availability projection."
           }
         },
         "absences": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claudexor/schema",
-  "version": "3.3.10",
+  "version": "3.3.11",
   "license": "MIT",
   "description": "Single source of truth for all Claudexor data shapes (Zod + generated JSON Schema).",
   "type": "module",
@@ -20,7 +20,7 @@
   "dependencies": {
     "zod": "^4.4.3",
     "zod-to-json-schema": "^3.24.1",
-    "@claudexor/util": "3.3.10"
+    "@claudexor/util": "3.3.11"
   },
   "repository": {
     "type": "git",