@@ -79,6 +79,7 @@ export const make = Effect.gen(function* () {
     const limited = exhaustedUsageWindow(
       snapshots.find((provider) => provider.instanceId === selection.instanceId),
       now,
+      selection.model,
     );
     const call = (modelSelection: ModelSelection) =>
       resolveInstance(registry, operation, modelSelection.instanceId).pipe(
 
@@ -137,6 +137,37 @@ describe("new thread model fallback", () => {
       ).toEqual(selection);
     }
   });
+  it("only counts the usage pools the default model draws from", () => {
+    const pools = (driver: string, ids: readonly string[]) =>
+      provider({
+        driver: ProviderDriverKind.make(driver),
+        usageLimits: {
+          checkedAt: "2026-09-03T11:00:00.000Z",
+          windows: ids.map((id) => ({ ...window, id, usedPercent: 100 })),
+        },
+      });
+    const resolve = (limited: ServerProvider, model: string) =>
+      resolveNewThreadModelSelection({
+        defaultSelection: { instanceId: limited.instanceId, model },
+        fallbackSelection: fallback,
+        providers: [limited, available],
+        now,
+      }).selection?.model;
+    expect(resolve(pools("cursor", ["autoPercentUsed"]), "claude-opus-5-5")).toBe(
+      "claude-opus-5-5",
+    );
+    expect(resolve(pools("cursor", ["autoPercentUsed"]), "composer-2.5")).toBe("composer-2.5");
+    expect(resolve(pools("cursor", ["autoPercentUsed", "apiPercentUsed"]), "composer-2.5")).toBe(
+      fallback.model,
+    );
+    expect(resolve(pools("antigravity", ["gemini-weekly"]), "claude-opus-5-5")).toBe(
+      "claude-opus-5-5",
+    );
+    expect(resolve(pools("antigravity", ["3p-weekly"]), "claude-opus-5-5")).toBe(fallback.model);
+    expect(resolve(pools("opencode", ["go_weekly"]), "opencode/big-pickle")).toBe(
+      "opencode/big-pickle",
+    );
+  });
 });
 
 describe("pace", () => {
 
@@ -21,15 +21,45 @@ const MINUTE = 60_000;
 const HOUR = 60 * MINUTE;
 const DAY = 24 * HOUR;
 
-export function exhaustedUsageWindow(provider: ServerProvider | undefined, now: number) {
-  return provider?.usageLimits?.windows.find(
+export function exhaustedUsageWindow(
+  provider: ServerProvider | undefined,
+  now: number,
+  model?: string,
+) {
+  const exhausted = (provider?.usageLimits?.windows ?? []).filter(
     (window) =>
       window.usedPercent !== undefined &&
       window.usedPercent >= 100 &&
       (!window.resetsAt ||
         !Number.isFinite(Date.parse(window.resetsAt)) ||
         Date.parse(window.resetsAt) > now),
   );
+  if (model === undefined) return exhausted[0];
+  // Some drivers report separate allowances per model family; only the ones this model draws from count.
+  switch (provider?.driver) {
+    case "cursor": {
+      const api = exhausted.find((window) => window.id === "apiPercentUsed");
+      const auto = exhausted.find((window) => window.id === "autoPercentUsed");
+      return /^(auto|default|grok|composer)/.test(model) ? auto && api : api;
+    }
+    case "antigravity": {
+      const family = model.match(/^(gemini|claude|gpt)-/)?.[1];
+      return exhausted.find((window) => {
+        const pool = window.id.match(/^(gemini|claude|gpt|3p)-/)?.[1];
+        return (
+          pool === undefined ||
+          pool === family ||
+          (pool === "3p" && (family === "claude" || family === "gpt"))
+        );
+      });
+    }
+    case "opencode":
+      return exhausted.find(
+        (window) => !window.id.startsWith("go_") || model.startsWith("opencode-go/"),
+      );
+    default:
+      return exhausted[0];
+  }
 }
 
 export function resolveNewThreadModelSelection(input: {
@@ -45,7 +75,7 @@ export function resolveNewThreadModelSelection(input: {
   const unchanged = { selection, fallback: null };
   if (input.explicitSelection || !selection || !input.fallbackSelection) return unchanged;
   const provider = input.providers.find((entry) => entry.instanceId === selection.instanceId);
-  const window = exhaustedUsageWindow(provider, input.now);
+  const window = exhaustedUsageWindow(provider, input.now, selection.model);
   const fallback = input.providers.find(
     (entry) => entry.instanceId === input.fallbackSelection?.instanceId,
   );
@@ -56,7 +86,7 @@ export function resolveNewThreadModelSelection(input: {
     !fallback.installed ||
     fallback.auth.status === "unauthenticated" ||
     !isProviderAvailable(fallback) ||
-    exhaustedUsageWindow(fallback, input.now) ||
+    exhaustedUsageWindow(fallback, input.now, input.fallbackSelection.model) ||
     (input.settings &&
       !resolveProjectProviderInstanceEnabled(
         input.settings,