feat(concurrency): configurable cooldown + adaptive-headroom auto-reduce banner

Consumes the backend's concurrency-fixes (commit 2d27666) — additive to
[email protected], NO version bump. ConcurrencyStatusEntry gains
cooldownMs / autoReduced / autoReducedFrom? / notice?; new
ConcurrencyCooldownResponse / SetConcurrencyCooldownRequest + GET/PUT
/concurrency/cooldown/:providerId.

FE:
- Pure core (logic/view-model.ts): DEFAULT_COOLDOWN_MS; parseCooldownInput
  (non-negative int — 0 is valid, unlike the limit); normalizeCooldown;
  cooldownLabel ("350ms"/"1.2s"/"0ms (off)"); viewConcurrencyStatus extended
  (cooldown + autoReduce fields; auto-reduce → warning badge, not busy);
  viewAutoReduce/autoReduceNotices (banner view — prefers backend notice,
  synthesizes a fallback); summarizeStatus "N auto-reduced" fragment;
  normalizeConcurrencyStatus coerces new fields (immutable readonly build;
  autoReducedFrom/notice only when autoReduced===true); normalizeConcurrencyCooldown.
- Types (logic/types.ts): re-export the 2 new contract types +
  ConcurrencyCooldownResult + Get/SaveConcurrencyCooldown ports.
- UI: ConcurrencyCooldownRow.svelte (inline-edit cooldown + Save → PUT, seeded
  via the ChatLimitField pattern); AutoReduceBanner.svelte (dismissible banner —
  backend notice + "Was N, now M." + "Restore to N"); ConcurrencyView renders
  the cooldown per status card + the banner section. The banner persists while
  autoReduced===true, is dismissible, and clears automatically once a poll shows
  autoReduced===false after a restore PUT.
- Store (store.svelte.ts): getConcurrencyCooldown + setConcurrencyCooldown
  (surface 400/404/503 as ok:false; normalize at the seam) + interface decls.
- App.svelte: saveConcurrencyCooldown adapter → ConcurrencyView.
- Tests: +47 (view-model cooldown/auto-reduce/normalizers; component banner
  render, cooldown PUT, restore clears banner, dismiss; store cooldown GET/PUT).

Re-synced the file: dep (bun install) + re-mirrored .dispatch/transport-contract.
reference.md. typecheck 0/0, 1048 tests green (run twice), biome clean, build OK.

Worktree env: an untracked dispatch-backend → backend symlink was created in the
worktree parent so the canonical file:../dispatch-backend/... paths resolve
(NOT committed — per the §2d/§2j worktree convention).

11 files changed, 1236 insertions, 83 deletions

diff --git a/src/app/App.svelte b/src/app/App.svelte
index 59f949c..3e7d05a 100644
--- a/src/app/App.svelte
+++ b/src/app/App.svelte
@@ -76,6 +76,7 @@
 		type DeleteConcurrencyLimit,
 		type LoadConcurrencyLimits,
 		type LoadConcurrencyStatus,
+		type SaveConcurrencyCooldown,
 		type SaveConcurrencyLimit,
 	} from "../features/concurrency";
 	import type { ChatStore } from "../features/chat";
@@ -491,6 +492,8 @@
 	const deleteConcurrencyLimit: DeleteConcurrencyLimit = (providerId) =>
 		store.deleteConcurrencyLimit(providerId);
 	const loadConcurrencyStatus: LoadConcurrencyStatus = () => store.concurrencyStatus();
+	const saveConcurrencyCooldown: SaveConcurrencyCooldown = (providerId, cooldownMs) =>
+		store.setConcurrencyCooldown(providerId, cooldownMs);
 </script>
 
 <main class="relative flex h-screen overflow-hidden">
@@ -841,6 +844,7 @@
 			saveLimit={saveConcurrencyLimit}
 			deleteLimit={deleteConcurrencyLimit}
 			loadStatus={loadConcurrencyStatus}
+			saveCooldown={saveConcurrencyCooldown}
 		/>
 	{/if}
 {/snippet}
diff --git a/src/app/store.svelte.ts b/src/app/store.svelte.ts
index ead27a6..d725dc0 100644
--- a/src/app/store.svelte.ts
+++ b/src/app/store.svelte.ts
@@ -55,12 +55,14 @@ import {
 import type { ChatStore, HistorySync, MetricsSync } from "../features/chat";
 import { createChatStore } from "../features/chat";
 import type {
+  ConcurrencyCooldownResult,
   ConcurrencyDeleteResult,
   ConcurrencyLimitResult,
   ConcurrencyLimitsResult,
   ConcurrencyStatusResult,
 } from "../features/concurrency";
 import {
+  normalizeConcurrencyCooldown,
   normalizeConcurrencyLimit,
   normalizeConcurrencyLimits,
   normalizeConcurrencyStatus,
@@ -442,11 +444,29 @@ export interface AppStore {
   /**
    * Fetch live concurrency status for every provider with a configured limit
    * (`GET /concurrency/status`): in-flight slots held, agents queued, and a paused
-   * state with a `pausedUntil` epoch-ms when a 429 backoff is in effect. Returns
+   * state with a `pausedUntil` epoch-ms when a 429 backoff is in effect. Each
+   * entry also carries the per-slot release `cooldownMs` + an `autoReduced` flag
+   * (true when a 429 auto-reduced the limit by 1; the FE renders a banner). Returns
    * an empty list when the extension isn't loaded (`{ providers: [] }`).
    */
   concurrencyStatus(): Promise<ConcurrencyStatusResult>;
   /**
+   * Fetch the per-slot release cooldown (ms) for one provider
+   * (`GET /concurrency/cooldown/:providerId`). `404` (no concurrency config at
+   * all) and `503` (extension not loaded) both surface as `ok: false`.
+   */
+  getConcurrencyCooldown(providerId: string): Promise<ConcurrencyCooldownResult>;
+  /**
+   * Set the per-slot release cooldown (ms) for one provider
+   * (`PUT /concurrency/cooldown/:providerId`, body `{ cooldownMs }`). `cooldownMs`
+   * must be a non-negative integer (0 = no cooldown / instant re-admission); an
+   * invalid body is `400`. Persists + applies to subsequently recycled slots.
+   */
+  setConcurrencyCooldown(
+    providerId: string,
+    cooldownMs: number,
+  ): Promise<ConcurrencyCooldownResult>;
+  /**
    * A critical error that blocks normal operation (e.g. the cross-device tab
    * restore fetch failed). When non-null, a full-screen modal is shown with the
    * error details. Cleared by `clearFatalError` (the modal's dismiss button).
@@ -1958,6 +1978,64 @@ export function createAppStore(opts?: CreateAppStoreOptions): AppStore {
       }
     },
 
+    async getConcurrencyCooldown(providerId: string): Promise<ConcurrencyCooldownResult> {
+      try {
+        const res = await fetchImpl(
+          `${httpBase}/concurrency/cooldown/${encodeURIComponent(providerId)}`,
+        );
+        if (!res.ok) {
+          const errBody = (await res.json().catch(() => null)) as { error?: string } | null;
+          return {
+            ok: false,
+            error: errBody?.error ?? `Get concurrency cooldown failed (HTTP ${res.status})`,
+          };
+        }
+        const data = normalizeConcurrencyCooldown(await res.json());
+        if (data === null) {
+          return { ok: false, error: "Malformed concurrency cooldown response" };
+        }
+        return { ok: true, providerId: data.providerId, cooldownMs: data.cooldownMs };
+      } catch (err) {
+        return {
+          ok: false,
+          error: err instanceof Error ? err.message : "Get concurrency cooldown request failed",
+        };
+      }
+    },
+
+    async setConcurrencyCooldown(
+      providerId: string,
+      cooldownMs: number,
+    ): Promise<ConcurrencyCooldownResult> {
+      try {
+        const res = await fetchImpl(
+          `${httpBase}/concurrency/cooldown/${encodeURIComponent(providerId)}`,
+          {
+            method: "PUT",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ cooldownMs }),
+          },
+        );
+        if (!res.ok) {
+          const errBody = (await res.json().catch(() => null)) as { error?: string } | null;
+          return {
+            ok: false,
+            error: errBody?.error ?? `Set concurrency cooldown failed (HTTP ${res.status})`,
+          };
+        }
+        const data = normalizeConcurrencyCooldown(await res.json());
+        if (data === null) {
+          return { ok: false, error: "Malformed concurrency cooldown response" };
+        }
+        return { ok: true, providerId: data.providerId, cooldownMs: data.cooldownMs };
+      } catch (err) {
+        return {
+          ok: false,
+          error: err instanceof Error ? err.message : "Set concurrency cooldown request failed",
+        };
+      }
+    },
+
     async loadSystemPrompt(): Promise<SystemPromptLoadResult> {
       try {
         const res = await fetchImpl(`${httpBase}/system-prompt`);
diff --git a/src/app/store.test.ts b/src/app/store.test.ts
index 2cf473c..a2f7f2f 100644
--- a/src/app/store.test.ts
+++ b/src/app/store.test.ts
@@ -1458,6 +1458,20 @@ describe("createAppStore", () => {
       if (url.includes("/concurrency/limits/") && method === "DELETE") {
         return new Response(JSON.stringify({ ok: true, providerId: "umans" }), { status: 200 });
       }
+      if (url.includes("/concurrency/cooldown/") && method === "GET") {
+        return new Response(JSON.stringify({ providerId: "umans", cooldownMs: 350 }), {
+          status: 200,
+        });
+      }
+      if (url.includes("/concurrency/cooldown/") && method === "PUT") {
+        const seg = url.slice(
+          url.lastIndexOf("/concurrency/cooldown/") + "/concurrency/cooldown/".length,
+        );
+        const body = init?.body ? JSON.parse(init.body as string) : {};
+        return new Response(JSON.stringify({ providerId: seg, cooldownMs: body.cooldownMs ?? 0 }), {
+          status: 200,
+        });
+      }
       return base(input, init);
     };
   }
@@ -1641,11 +1655,15 @@ describe("createAppStore", () => {
       inFlight: 2,
       queued: 1,
       paused: false,
+      cooldownMs: 350,
+      autoReduced: false,
     });
     expect(result.providers[1]).toMatchObject({
       providerId: "openai-compat",
       paused: true,
       pausedUntil: 1_719_408_000_000,
+      cooldownMs: 350,
+      autoReduced: false,
     });
     store.dispose();
   });
@@ -1663,6 +1681,100 @@ describe("createAppStore", () => {
     store.dispose();
   });
 
+  it("getConcurrencyCooldown loads + coerces the cooldown", async () => {
+    const store = createAppStore({
+      socketFactory: () => fakeSocket(),
+      fetchImpl: concurrencyFetchImpl(),
+      localStorage: createFakeStorage(),
+    });
+    const result = await store.getConcurrencyCooldown("umans");
+    expect(result.ok).toBe(true);
+    if (!result.ok) throw new Error("unreachable");
+    expect(result.providerId).toBe("umans");
+    expect(result.cooldownMs).toBe(350);
+    store.dispose();
+  });
+
+  it("getConcurrencyCooldown surfaces a 404 (no concurrency config) as ok:false", async () => {
+    const store = createAppStore({
+      socketFactory: () => fakeSocket(),
+      fetchImpl: async (input) => {
+        const url =
+          typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+        if (url.includes("/concurrency/cooldown/")) {
+          return new Response(
+            JSON.stringify({ error: "No concurrency configuration for this provider" }),
+            {
+              status: 404,
+            },
+          );
+        }
+        return fakeFetchImpl()(input);
+      },
+      localStorage: createFakeStorage(),
+    });
+    const result = await store.getConcurrencyCooldown("ghost");
+    expect(result.ok).toBe(false);
+    if (result.ok) throw new Error("unreachable");
+    expect(result.error).toContain("No concurrency configuration");
+    store.dispose();
+  });
+
+  it("setConcurrencyCooldown PUTs { cooldownMs } + returns the echoed value", async () => {
+    const calls: { url: string; method: string; body: unknown }[] = [];
+    const store = createAppStore({
+      socketFactory: () => fakeSocket(),
+      fetchImpl: async (input, init) => {
+        const url =
+          typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+        const method = init?.method ?? "GET";
+        calls.push({ url, method, body: init?.body ? JSON.parse(init.body as string) : null });
+        if (url.includes("/concurrency/cooldown/") && method === "PUT") {
+          const body = init?.body ? JSON.parse(init.body as string) : {};
+          return new Response(
+            JSON.stringify({ providerId: "umans", cooldownMs: body.cooldownMs }),
+            { status: 200 },
+          );
+        }
+        return fakeFetchImpl()(input, init);
+      },
+      localStorage: createFakeStorage(),
+    });
+    const result = await store.setConcurrencyCooldown("umans", 500);
+    expect(result.ok).toBe(true);
+    if (!result.ok) throw new Error("unreachable");
+    expect(result.cooldownMs).toBe(500);
+    const cooldownCall = calls.find(
+      (c) => c.url.includes("/concurrency/cooldown/") && c.method === "PUT",
+    );
+    expect(cooldownCall?.url).toContain("/concurrency/cooldown/umans");
+    expect(cooldownCall?.body).toEqual({ cooldownMs: 500 });
+    store.dispose();
+  });
+
+  it("setConcurrencyCooldown surfaces a 400 (invalid body) as ok:false", async () => {
+    const store = createAppStore({
+      socketFactory: () => fakeSocket(),
+      fetchImpl: async (input, init) => {
+        const url =
+          typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+        if (url.includes("/concurrency/cooldown/") && init?.method === "PUT") {
+          return new Response(
+            JSON.stringify({ error: "Body must be { cooldownMs: <non-negative integer> }" }),
+            { status: 400 },
+          );
+        }
+        return fakeFetchImpl()(input, init);
+      },
+      localStorage: createFakeStorage(),
+    });
+    const result = await store.setConcurrencyCooldown("umans", -1);
+    expect(result.ok).toBe(false);
+    if (result.ok) throw new Error("unreachable");
+    expect(result.error).toContain("non-negative integer");
+    store.dispose();
+  });
+
   // ── Conversation status: `queued` (CR-13 — waiting for a concurrency slot) ────
 
   it("conversation.statusChanged 'queued' sets the status (tab spinner) without opening a duplicate tab", () => {
diff --git a/src/features/concurrency/index.ts b/src/features/concurrency/index.ts
index 151acb8..95eb5ed 100644
--- a/src/features/concurrency/index.ts
+++ b/src/features/concurrency/index.ts
@@ -1,7 +1,9 @@
 export type {
+  // Contract shapes re-exported for a single import surface.
+  ConcurrencyCooldownResponse,
+  ConcurrencyCooldownResult,
   ConcurrencyDeleteResult,
   ConcurrencyLimitEntry,
-  // Contract shapes re-exported for a single import surface.
   ConcurrencyLimitResponse,
   ConcurrencyLimitResult,
   ConcurrencyLimitsResponse,
@@ -10,30 +12,47 @@ export type {
   ConcurrencyStatusResponse,
   ConcurrencyStatusResult,
   DeleteConcurrencyLimit,
+  GetConcurrencyCooldown,
   GetConcurrencyLimit,
   LoadConcurrencyLimits,
   LoadConcurrencyStatus,
+  RestoreOutcome,
+  SaveConcurrencyCooldown,
   SaveConcurrencyLimit,
+  SetConcurrencyCooldownRequest,
   SetConcurrencyLimitRequest,
 } from "./logic/types";
-export type { Badge, ConcurrencyLimitView, ConcurrencyStatusView } from "./logic/view-model";
+export type {
+  AutoReduceNotice,
+  Badge,
+  ConcurrencyLimitView,
+  ConcurrencyStatusView,
+} from "./logic/view-model";
 export {
+  autoReduceNotices,
+  cooldownLabel,
+  DEFAULT_COOLDOWN_MS,
   formatPauseDuration,
+  normalizeConcurrencyCooldown,
   normalizeConcurrencyLimit,
   normalizeConcurrencyLimits,
   normalizeConcurrencyStatus,
   normalizeLimit,
+  parseCooldownInput,
   parseLimitInput,
   pauseLabel,
   providerFromModel,
   providerOptions,
   summarizeLimits,
   summarizeStatus,
+  viewAutoReduce,
   viewConcurrencyLimit,
   viewConcurrencyLimits,
   viewConcurrencyStatus,
   viewConcurrencyStatuses,
 } from "./logic/view-model";
+export { default as AutoReduceBanner } from "./ui/AutoReduceBanner.svelte";
+export { default as ConcurrencyCooldownRow } from "./ui/ConcurrencyCooldownRow.svelte";
 export { default as ConcurrencyLimitRow } from "./ui/ConcurrencyLimitRow.svelte";
 export { default as ConcurrencyView } from "./ui/ConcurrencyView.svelte";
 
diff --git a/src/features/concurrency/logic/types.ts b/src/features/concurrency/logic/types.ts
index f05211f..a0c5f6b 100644
--- a/src/features/concurrency/logic/types.ts
+++ b/src/features/concurrency/logic/types.ts
@@ -1,8 +1,10 @@
 import type {
+  ConcurrencyCooldownResponse,
   ConcurrencyLimitResponse,
   ConcurrencyLimitsResponse,
   ConcurrencyStatusEntry,
   ConcurrencyStatusResponse,
+  SetConcurrencyCooldownRequest,
   SetConcurrencyLimitRequest,
 } from "@dispatch/transport-contract";
 
@@ -23,14 +25,23 @@ import type {
  * are imported directly (mirrors `mcp` / `computer`). The result types + injected
  * ports below are FE-owned (the composition root adapts the store's HTTP calls to
  * them). The endpoints are GLOBAL (not workspace- or conversation-scoped).
+ *
+ * Concurrency-fixes (additive, no version bump): each `ConcurrencyStatusEntry`
+ * now also carries `cooldownMs` (per-slot release cooldown, configurable +
+ * persisted), `autoReduced` (a 429 auto-reduced the limit by 1, one-way), and
+ * when auto-reduced, `autoReducedFrom` + a `notice` banner string. A manual
+ * `PUT /concurrency/limits/:providerId` clears `autoReduced`. Two new endpoints
+ * `GET`/`PUT /concurrency/cooldown/:providerId` view/change the cooldown.
  */
 
 /** Re-export the contract shapes so consumers import a single surface. */
 export type {
+  ConcurrencyCooldownResponse,
   ConcurrencyLimitResponse,
   ConcurrencyLimitsResponse,
   ConcurrencyStatusEntry,
   ConcurrencyStatusResponse,
+  SetConcurrencyCooldownRequest,
   SetConcurrencyLimitRequest,
 };
 
@@ -69,6 +80,25 @@ export type ConcurrencyStatusResult =
   | { readonly ok: true; readonly providers: readonly ConcurrencyStatusEntry[] }
   | { readonly ok: false; readonly error: string };
 
+/**
+ * Outcome of `GET`/`PUT /concurrency/cooldown/:providerId` — the per-slot
+ * release cooldown (ms) for one provider. `GET` returns `404` when the provider
+ * has no concurrency config at all (no limit, no cooldown); `PUT` returns `400`
+ * for a non-negative-integer body. Both return `503` when the extension isn't
+ * loaded.
+ */
+export type ConcurrencyCooldownResult =
+  | { readonly ok: true; readonly providerId: string; readonly cooldownMs: number }
+  | { readonly ok: false; readonly error: string };
+
+/**
+ * Outcome of an auto-reduce banner's "Restore to N" action (PUT the limit back
+ * to `autoReducedFrom` via `PUT /concurrency/limits/:providerId`). Carried back to
+ * the banner so a FAILED restore surfaces an inline error next to the button
+ * (instead of silently re-enabling the button / showing the error far away).
+ */
+export type RestoreOutcome = { readonly ok: true } | { readonly ok: false; readonly error: string };
+
 // ── Injected ports (consumer-defines-port; the composition root adapts the
 //    store's HTTP calls to these shapes). ──────────────────────────────────────
 
@@ -80,3 +110,10 @@ export type SaveConcurrencyLimit = (
 ) => Promise<ConcurrencyLimitResult>;
 export type DeleteConcurrencyLimit = (providerId: string) => Promise<ConcurrencyDeleteResult>;
 export type LoadConcurrencyStatus = () => Promise<ConcurrencyStatusResult>;
+/** `GET /concurrency/cooldown/:providerId` — read the per-slot release cooldown. */
+export type GetConcurrencyCooldown = (providerId: string) => Promise<ConcurrencyCooldownResult>;
+/** `PUT /concurrency/cooldown/:providerId` — set the per-slot release cooldown (non-negative int). */
+export type SaveConcurrencyCooldown = (
+  providerId: string,
+  cooldownMs: number,
+) => Promise<ConcurrencyCooldownResult>;
diff --git a/src/features/concurrency/logic/view-model.test.ts b/src/features/concurrency/logic/view-model.test.ts
index 82b72b0..c284ad0 100644
--- a/src/features/concurrency/logic/view-model.test.ts
+++ b/src/features/concurrency/logic/view-model.test.ts
@@ -1,16 +1,22 @@
 import type { ConcurrencyStatusEntry } from "@dispatch/transport-contract";
 import { describe, expect, it } from "vitest";
 import {
+  autoReduceNotices,
+  cooldownLabel,
+  DEFAULT_COOLDOWN_MS,
   formatPauseDuration,
+  normalizeConcurrencyCooldown,
   normalizeConcurrencyLimit,
   normalizeConcurrencyLimits,
   normalizeConcurrencyStatus,
+  parseCooldownInput,
   parseLimitInput,
   pauseLabel,
   providerFromModel,
   providerOptions,
   summarizeLimits,
   summarizeStatus,
+  viewAutoReduce,
   viewConcurrencyLimit,
   viewConcurrencyLimits,
   viewConcurrencyStatus,
@@ -23,6 +29,8 @@ const status = (over: Partial<ConcurrencyStatusEntry> = {}): ConcurrencyStatusEn
   inFlight: 2,
   queued: 0,
   paused: false,
+  cooldownMs: 350,
+  autoReduced: false,
   ...over,
 });
 
@@ -46,6 +54,41 @@ describe("parseLimitInput", () => {
   });
 });
 
+// ── parseCooldownInput (non-negative integer — 0 is valid, unlike the limit) ──
+
+describe("parseCooldownInput", () => {
+  it("accepts zero + positive integers", () => {
+    expect(parseCooldownInput("0")).toBe(0);
+    expect(parseCooldownInput("350")).toBe(350);
+    expect(parseCooldownInput(" 100 ")).toBe(100);
+  });
+
+  it("rejects negatives, non-integers, and garbage", () => {
+    expect(parseCooldownInput("-1")).toBeNull();
+    expect(parseCooldownInput("4.5")).toBeNull();
+    expect(parseCooldownInput("")).toBeNull();
+    expect(parseCooldownInput("abc")).toBeNull();
+    expect(parseCooldownInput("100ms")).toBeNull();
+  });
+});
+
+// ── cooldownLabel ─────────────────────────────────────────────────────────────
+
+describe("cooldownLabel", () => {
+  it("0 → off label", () => {
+    expect(cooldownLabel(0)).toBe("0ms (off)");
+  });
+  it("sub-second → ms", () => {
+    expect(cooldownLabel(350)).toBe("350ms");
+    expect(cooldownLabel(999)).toBe("999ms");
+  });
+  it("≥1s → seconds (trims trailing .0)", () => {
+    expect(cooldownLabel(1000)).toBe("1s");
+    expect(cooldownLabel(1500)).toBe("1.5s");
+    expect(cooldownLabel(60_000)).toBe("60s");
+  });
+});
+
 // ── providerFromModel / providerOptions ───────────────────────────────────────
 
 describe("providerFromModel", () => {
@@ -178,6 +221,8 @@ describe("viewConcurrencyStatus", () => {
         inFlight: Number.NaN,
         queued: "oops" as unknown as number,
         paused: false,
+        cooldownMs: Number.NaN,
+        autoReduced: false,
       },
       0,
     );
@@ -185,6 +230,7 @@ describe("viewConcurrencyStatus", () => {
     expect(v.inFlight).toBe(0);
     expect(v.queued).toBe(0);
     expect(v.inFlightLabel).toBe("0/1");
+    expect(v.cooldownMs).toBe(DEFAULT_COOLDOWN_MS);
   });
 
   it("viewConcurrencyStatuses maps a list preserving order", () => {
@@ -194,6 +240,81 @@ describe("viewConcurrencyStatus", () => {
     );
     expect(views.map((v) => v.providerId)).toEqual(["a", "b"]);
   });
+
+  it("carries cooldownMs + label + autoReduced fields onto the view", () => {
+    const v = viewConcurrencyStatus(status({ cooldownMs: 1500 }), 0);
+    expect(v.cooldownMs).toBe(1500);
+    expect(v.cooldownLabel).toBe("1.5s");
+    expect(v.autoReduced).toBe(false);
+    expect(v.autoReducedFrom).toBeNull();
+  });
+
+  it("auto-reduced → warning badge (not busy) + autoReducedFrom carried", () => {
+    const v = viewConcurrencyStatus(
+      status({ limit: 3, autoReduced: true, autoReducedFrom: 4, inFlight: 0 }),
+      0,
+    );
+    expect(v.autoReduced).toBe(true);
+    expect(v.autoReducedFrom).toBe(4);
+    expect(v.badge).toBe("warning");
+    // autoReduced alone does NOT flip busy (a reduced limit still admits agents).
+    expect(v.busy).toBe(false);
+  });
+});
+
+// ── viewAutoReduce / autoReduceNotices (the auto-reduce banner view) ───────────
+
+describe("viewAutoReduce", () => {
+  it("returns null when not auto-reduced", () => {
+    expect(viewAutoReduce(status({ autoReduced: false }))).toBeNull();
+  });
+
+  it("uses the backend notice verbatim + carries from/current limits", () => {
+    const notice = viewAutoReduce(
+      status({
+        limit: 3,
+        autoReduced: true,
+        autoReducedFrom: 4,
+        notice: "Concurrency limit auto-reduced to 3 after a 429.",
+      }),
+    );
+    expect(notice).toEqual({
+      providerId: "umans",
+      message: "Concurrency limit auto-reduced to 3 after a 429.",
+      fromLimit: 4,
+      currentLimit: 3,
+    });
+  });
+
+  it("synthesizes a fallback notice when the backend notice is absent/empty", () => {
+    expect(viewAutoReduce(status({ limit: 3, autoReduced: true, autoReducedFrom: 4 }))).toEqual({
+      providerId: "umans",
+      message: "Concurrency limit auto-reduced to 3 after a 429 — restore manually when ready.",
+      fromLimit: 4,
+      currentLimit: 3,
+    });
+    expect(
+      viewAutoReduce(status({ limit: 3, autoReduced: true, autoReducedFrom: 4, notice: "" })),
+    ).not.toBeNull();
+  });
+
+  it("falls back to currentLimit+1 when autoReducedFrom is missing/garbage", () => {
+    const notice = viewAutoReduce(status({ limit: 3, autoReduced: true }));
+    expect(notice?.fromLimit).toBe(4); // 3 + 1
+  });
+});
+
+describe("autoReduceNotices", () => {
+  it("collects one banner per auto-reduced provider (input order), empty when none", () => {
+    expect(autoReduceNotices([status({ providerId: "a" })])).toEqual([]);
+    const out = autoReduceNotices([
+      status({ providerId: "a", autoReduced: true, autoReducedFrom: 4, limit: 3 }),
+      status({ providerId: "b" }),
+      status({ providerId: "c", autoReduced: true, autoReducedFrom: 2, limit: 1 }),
+    ]);
+    expect(out.map((n) => n.providerId)).toEqual(["a", "c"]);
+    expect(out[1]?.fromLimit).toBe(2);
+  });
 });
 
 // ── viewConcurrencyLimit ───────────────────────────────────────────────────────
@@ -273,6 +394,16 @@ describe("summarizeStatus", () => {
       "1 provider · 1/4 in flight",
     );
   });
+  it("includes an auto-reduced fragment only when non-zero", () => {
+    const s = summarizeStatus(
+      [
+        status({ providerId: "a", limit: 3, inFlight: 1, autoReduced: true, autoReducedFrom: 4 }),
+        status({ providerId: "b", limit: 4, inFlight: 1 }),
+      ],
+      0,
+    );
+    expect(s).toBe("2 providers · 2/7 in flight · 1 auto-reduced");
+  });
 });
 
 // ── Network-seam normalizers ───────────────────────────────────────────────────
@@ -359,6 +490,8 @@ describe("normalizeConcurrencyStatus", () => {
       inFlight: 2,
       queued: 1,
       paused: false,
+      cooldownMs: 350,
+      autoReduced: false,
     });
     expect(first !== undefined && !("pausedUntil" in first)).toBe(true);
     expect(second).toEqual({
@@ -368,6 +501,8 @@ describe("normalizeConcurrencyStatus", () => {
       queued: 3,
       paused: true,
       pausedUntil: now,
+      cooldownMs: 350,
+      autoReduced: false,
     });
   });
 
@@ -388,8 +523,24 @@ describe("normalizeConcurrencyStatus", () => {
       ],
     });
     expect(providers).toEqual([
-      { providerId: "umans", limit: 4, inFlight: 2, queued: 1, paused: false },
-      { providerId: "x", limit: 1, inFlight: 0, queued: 0, paused: false },
+      {
+        providerId: "umans",
+        limit: 4,
+        inFlight: 2,
+        queued: 1,
+        paused: false,
+        cooldownMs: 350,
+        autoReduced: false,
+      },
+      {
+        providerId: "x",
+        limit: 1,
+        inFlight: 0,
+        queued: 0,
+        paused: false,
+        cooldownMs: 350,
+        autoReduced: false,
+      },
     ]);
   });
 
@@ -402,4 +553,81 @@ describe("normalizeConcurrencyStatus", () => {
     });
     for (const p of providers) expect("pausedUntil" in p).toBe(false);
   });
+
+  it("coerces cooldownMs (default 350) + carries auto-reduce fields only when true", () => {
+    const [reduced, healthy] = normalizeConcurrencyStatus({
+      providers: [
+        {
+          providerId: "umans",
+          limit: 3,
+          inFlight: 1,
+          queued: 0,
+          paused: false,
+          cooldownMs: 500,
+          autoReduced: true,
+          autoReducedFrom: 4,
+          notice: "auto-reduced to 3 after a 429.",
+        },
+        { providerId: "openai", limit: 4, inFlight: 0, queued: 0, paused: false },
+      ],
+    });
+    expect(reduced?.cooldownMs).toBe(500);
+    expect(reduced?.autoReduced).toBe(true);
+    expect(reduced?.autoReducedFrom).toBe(4);
+    expect(reduced?.notice).toBe("auto-reduced to 3 after a 429.");
+    // Healthy entry: cooldownMs defaults to 350 when absent; auto-reduce fields
+    // are NOT present (they are only included when autoReduced===true).
+    expect(healthy?.cooldownMs).toBe(DEFAULT_COOLDOWN_MS);
+    expect(healthy?.autoReduced).toBe(false);
+    expect(healthy && "autoReducedFrom" in healthy).toBe(false);
+    expect(healthy && "notice" in healthy).toBe(false);
+  });
+
+  it("drops autoReducedFrom/notice when autoReduced is false (even if present in JSON)", () => {
+    const [p] = normalizeConcurrencyStatus({
+      providers: [
+        {
+          providerId: "x",
+          limit: 4,
+          inFlight: 0,
+          queued: 0,
+          paused: false,
+          autoReduced: false,
+          autoReducedFrom: 9,
+          notice: "stale",
+        },
+      ],
+    });
+    expect(p?.autoReduced).toBe(false);
+    expect(p && "autoReducedFrom" in p).toBe(false);
+    expect(p && "notice" in p).toBe(false);
+  });
+});
+
+// ── normalizeConcurrencyCooldown ───────────────────────────────────────────────
+
+describe("normalizeConcurrencyCooldown", () => {
+  it("coerces a well-formed body", () => {
+    expect(normalizeConcurrencyCooldown({ providerId: "umans", cooldownMs: 500 })).toEqual({
+      providerId: "umans",
+      cooldownMs: 500,
+    });
+  });
+
+  it("defaults a malformed/absent cooldownMs to 350", () => {
+    expect(normalizeConcurrencyCooldown({ providerId: "x", cooldownMs: -1 })?.cooldownMs).toBe(
+      DEFAULT_COOLDOWN_MS,
+    );
+    expect(normalizeConcurrencyCooldown({ providerId: "x" })?.cooldownMs).toBe(DEFAULT_COOLDOWN_MS);
+    expect(normalizeConcurrencyCooldown({ providerId: "x", cooldownMs: "fast" })?.cooldownMs).toBe(
+      DEFAULT_COOLDOWN_MS,
+    );
+  });
+
+  it("returns null for a missing/malformed providerId", () => {
+    expect(normalizeConcurrencyCooldown({ cooldownMs: 350 })).toBeNull();
+    expect(normalizeConcurrencyCooldown({ providerId: "", cooldownMs: 350 })).toBeNull();
+    expect(normalizeConcurrencyCooldown(null)).toBeNull();
+    expect(normalizeConcurrencyCooldown({})).toBeNull();
+  });
 });
diff --git a/src/features/concurrency/logic/view-model.ts b/src/features/concurrency/logic/view-model.ts
index 7a4fe0e..e05423b 100644
--- a/src/features/concurrency/logic/view-model.ts
+++ b/src/features/concurrency/logic/view-model.ts
@@ -1,12 +1,16 @@
-import type { ConcurrencyStatusEntry } from "@dispatch/transport-contract";
+import type {
+  ConcurrencyCooldownResponse,
+  ConcurrencyStatusEntry,
+} from "@dispatch/transport-contract";
 import type { ConcurrencyLimitEntry } from "./types";
 
 /**
  * Pure view-models for the concurrency feature — zero DOM, zero effects, zero
  * Svelte. Maps backend `ConcurrencyLimitEntry` / `ConcurrencyStatusEntry` to
- * display shapes (badges, "2/4" in-flight labels, pause countdowns, summaries),
- * holds the limit-input parsing, and the network-seam normalizers the composition
- * root coerces the untyped JSON with.
+ * display shapes (badges, "2/4" in-flight labels, pause countdowns, cooldown
+ * labels, auto-reduce banners, summaries), holds the limit/cooldown-input
+ * parsing, and the network-seam normalizers the composition root coerces the
+ * untyped JSON with.
  */
 
 export type Badge = "success" | "warning" | "error" | "neutral";
@@ -36,6 +40,29 @@ export interface ConcurrencyStatusView {
   readonly badge: Badge;
   /** True when paused or at capacity (show a spinner). */
   readonly busy: boolean;
+  /** Per-slot release cooldown in ms (defensive default 350 on garbage). */
+  readonly cooldownMs: number;
+  /** "350ms" / "1.2s" / "0ms (off)" — display label for the cooldown. */
+  readonly cooldownLabel: string;
+  /** Whether the limit was auto-reduced by a 429 (one-way; user restores manually). */
+  readonly autoReduced: boolean;
+  /** The original limit before auto-reduction; null when not auto-reduced. */
+  readonly autoReducedFrom: number | null;
+}
+
+/**
+ * A view-model for the auto-reduce banner — derived from a status entry whose
+ * `autoReduced` is `true`. `message` is the backend's `notice` when present, else
+ * a synthesized fallback. `viewAutoReduce` returns this (or null) so the banner
+ * section renders without reaching into the raw entry.
+ */
+export interface AutoReduceNotice {
+  readonly providerId: string;
+  readonly message: string;
+  /** The original limit before reduction — the value "Restore to N" PUTs. */
+  readonly fromLimit: number;
+  /** The current (reduced) limit. */
+  readonly currentLimit: number;
 }
 
 // ── Limit input parsing ───────────────────────────────────────────────────────
@@ -63,6 +90,53 @@ export function normalizeLimit(value: unknown): number {
   return int >= 1 ? int : 1;
 }
 
+// ── Cooldown input parsing ────────────────────────────────────────────────────
+//
+// The per-slot release cooldown (ms) is a NON-NEGATIVE integer (0 = no cooldown,
+// instant re-admission) — unlike the limit, 0 is a VALID value. The default is
+// 350ms (the backend's server default when a limit is set but no explicit
+// cooldown was configured). It is configurable + persisted per provider via
+// `PUT /concurrency/cooldown/:providerId`.
+
+/** The server's default cooldown (ms) — used when none is explicitly set. */
+export const DEFAULT_COOLDOWN_MS = 350;
+
+/**
+ * Parse a raw cooldown input into a non-negative integer, or `null` when it is
+ * not valid. Accepts "0" → 0, "350" → 350; rejects "-1", "4.5", "", "abc".
+ * Drives the cooldown Save button's disabled state so an invalid value never
+ * reaches the backend (the backend 400s a non-negative-integer body).
+ */
+export function parseCooldownInput(value: string): number | null {
+  const trimmed = value.trim();
+  if (trimmed === "" || !/^[0-9]+$/.test(trimmed)) return null;
+  const n = Number.parseInt(trimmed, 10);
+  return Number.isFinite(n) && n >= 0 ? n : null;
+}
+
+/**
+ * Coerce an untrusted cooldown value into a non-negative integer (default
+ * {@link DEFAULT_COOLDOWN_MS}). Used when normalizing backend responses so a
+ * malformed `cooldownMs` can never be negative/non-finite.
+ */
+export function normalizeCooldown(value: unknown): number {
+  const n = typeof value === "number" && Number.isFinite(value) ? value : DEFAULT_COOLDOWN_MS;
+  const int = Math.floor(n);
+  return int >= 0 ? int : DEFAULT_COOLDOWN_MS;
+}
+
+/**
+ * Format a cooldown (ms) as a short display label:
+ * 0 → "0ms (off)" · <1000 → "350ms" · ≥1000 → "1.2s" (trailing ".0" trimmed).
+ */
+export function cooldownLabel(ms: number): string {
+  if (ms <= 0) return "0ms (off)";
+  if (ms < 1000) return `${ms}ms`;
+  const secs = ms / 1000;
+  const fixed = secs.toFixed(1);
+  return `${fixed.endsWith(".0") ? fixed.slice(0, -2) : fixed}s`;
+}
+
 // ── Provider options (the Add-form dropdown) ───────────────────────────────────
 //
 // A concurrency `providerId` is the credential name that prefixes a model name
@@ -140,6 +214,10 @@ export function pauseLabel(
  * Build a display view for a status entry. `now` is injectable for tests
  * (defaults to `Date.now()`); the composition-root component passes nothing in
  * production (it recomputes on each poll).
+ *
+ * `autoReduced` does NOT flip `busy` (a reduced limit still admits agents; it is
+ * a degraded-but-active state surfaced via the banner, not a spinner) — it only
+ * nudges the badge to `warning` so the row signals attention.
  */
 export function viewConcurrencyStatus(
   entry: ConcurrencyStatusEntry,
@@ -149,12 +227,21 @@ export function viewConcurrencyStatus(
   const inFlight = clampCount(entry.inFlight);
   const queued = clampCount(entry.queued);
   const paused = entry.paused === true;
+  const autoReduced = entry.autoReduced === true;
   const atCapacity = inFlight >= limit;
   let badge: Badge;
   if (paused) badge = "warning";
+  else if (autoReduced) badge = "warning";
   else if (atCapacity && queued > 0) badge = "warning";
   else if (inFlight > 0) badge = "success";
   else badge = "neutral";
+  const cooldownMs = normalizeCooldown(entry.cooldownMs);
+  const autoReducedFrom =
+    autoReduced &&
+    typeof entry.autoReducedFrom === "number" &&
+    Number.isFinite(entry.autoReducedFrom)
+      ? normalizeLimit(entry.autoReducedFrom)
+      : null;
   return {
     providerId: entry.providerId,
     limit,
@@ -166,9 +253,53 @@ export function viewConcurrencyStatus(
     pausedLabel: pauseLabel(paused, entry.pausedUntil, now),
     badge,
     busy: paused || (atCapacity && queued > 0),
+    cooldownMs,
+    cooldownLabel: cooldownLabel(cooldownMs),
+    autoReduced,
+    autoReducedFrom,
   };
 }
 
+/**
+ * The auto-reduce banner view for a status entry, or `null` when it is not
+ * auto-reduced. `message` prefers the backend's `notice` (verbatim, when present
+ * + non-empty); otherwise a synthesized fallback is built from
+ * `autoReducedFrom` → `limit`. `fromLimit` is the value "Restore to N" PUTs back.
+ */
+export function viewAutoReduce(entry: ConcurrencyStatusEntry): AutoReduceNotice | null {
+  if (entry.autoReduced !== true) return null;
+  const currentLimit = normalizeLimit(entry.limit);
+  const fromLimit =
+    typeof entry.autoReducedFrom === "number" && Number.isFinite(entry.autoReducedFrom)
+      ? normalizeLimit(entry.autoReducedFrom)
+      : currentLimit + 1;
+  const notice =
+    typeof entry.notice === "string" && entry.notice.length > 0
+      ? entry.notice
+      : `Concurrency limit auto-reduced to ${currentLimit} after a 429 — restore manually when ready.`;
+  return {
+    providerId: entry.providerId,
+    message: notice,
+    fromLimit,
+    currentLimit,
+  };
+}
+
+/**
+ * All auto-reduce banners across a status list (one per auto-reduced provider),
+ * in input order. Empty when none are auto-reduced.
+ */
+export function autoReduceNotices(
+  entries: readonly ConcurrencyStatusEntry[],
+): readonly AutoReduceNotice[] {
+  const out: AutoReduceNotice[] = [];
+  for (const e of entries) {
+    const n = viewAutoReduce(e);
+    if (n !== null) out.push(n);
+  }
+  return out;
+}
+
 export function viewConcurrencyStatuses(
   entries: readonly ConcurrencyStatusEntry[],
   now: number = Date.now(),
@@ -197,8 +328,8 @@ export function summarizeLimits(limits: readonly ConcurrencyLimitEntry[]): strin
 
 /**
  * A one-line summary of the live status, e.g.
- * "2 providers · 6/10 in flight · 1 queued · 1 paused". Only the queued / paused
- * fragments appear when non-zero.
+ * "2 providers · 6/10 in flight · 1 queued · 1 paused · 1 auto-reduced". Only the
+ * queued / paused / auto-reduced fragments appear when non-zero.
  */
 export function summarizeStatus(
   providers: readonly ConcurrencyStatusEntry[],
@@ -209,12 +340,14 @@ export function summarizeStatus(
   let limitTotal = 0;
   let queued = 0;
   let paused = 0;
+  let autoReduced = 0;
   for (const p of providers) {
     const limit = normalizeLimit(p.limit);
     inFlight += clampCount(p.inFlight);
     limitTotal += limit;
     queued += clampCount(p.queued);
     if (p.paused === true) paused += 1;
+    if (p.autoReduced === true) autoReduced += 1;
   }
   const parts: string[] = [];
   parts.push(
@@ -223,6 +356,7 @@ export function summarizeStatus(
   );
   if (queued > 0) parts.push(`${queued} queued`);
   if (paused > 0) parts.push(`${paused} paused`);
+  if (autoReduced > 0) parts.push(`${autoReduced} auto-reduced`);
   // Touch `now` so the summary recomputes alongside the per-row pause countdown.
   void now;
   return parts.join(" · ");
@@ -274,7 +408,9 @@ export function normalizeConcurrencyLimit(data: unknown): ConcurrencyLimitEntry
 /**
  * Coerce an untrusted `GET /concurrency/status` body into a typed status list.
  * `pausedUntil` is included only when it is a finite number (it is absent when
- * not paused).
+ * not paused). `cooldownMs` (default 350) + `autoReduced` are always coerced;
+ * `autoReducedFrom` + `notice` are included only when `autoReduced` is true (and
+ * well-formed), mirroring the backend's "present only when auto-reduced" contract.
  */
 export function normalizeConcurrencyStatus(data: unknown): readonly ConcurrencyStatusEntry[] {
   if (!isRecord(data) || !Array.isArray(data.providers)) return [];
@@ -282,18 +418,57 @@ export function normalizeConcurrencyStatus(data: unknown): readonly ConcurrencyS
   return providers
     .filter((r): r is Record<string, unknown> => isRecord(r))
     .map((r): ConcurrencyStatusEntry => {
-      const base = {
-        providerId: asString(r.providerId) ?? "",
-        limit: normalizeLimit(r.limit),
-        inFlight: clampCount(r.inFlight),
-        queued: clampCount(r.queued),
-        paused: r.paused === true,
+      const providerId = asString(r.providerId) ?? "";
+      const limit = normalizeLimit(r.limit);
+      const inFlight = clampCount(r.inFlight);
+      const queued = clampCount(r.queued);
+      const paused = r.paused === true;
+      const cooldownMs = normalizeCooldown(r.cooldownMs);
+      const autoReduced = r.autoReduced === true;
+      // Build immutably (the contract fields are readonly): start with the always-
+      // present fields, then layer the optional `pausedUntil` (finite number only)
+      // + the auto-reduce-only `autoReducedFrom`/`notice` (present only when true).
+      let entry: ConcurrencyStatusEntry = {
+        providerId,
+        limit,
+        inFlight,
+        queued,
+        paused,
+        cooldownMs,
+        autoReduced,
       };
-      const pausedUntil =
-        typeof r.pausedUntil === "number" && Number.isFinite(r.pausedUntil)
-          ? r.pausedUntil
-          : undefined;
-      return pausedUntil !== undefined ? { ...base, pausedUntil } : base;
+      if (typeof r.pausedUntil === "number" && Number.isFinite(r.pausedUntil)) {
+        entry = { ...entry, pausedUntil: r.pausedUntil };
+      }
+      if (autoReduced) {
+        // Accumulate the auto-reduce-only optionals into a plain record (the
+        // contract fields are readonly, so we can't mutate a typed partial —
+        // collect then spread into a fresh entry).
+        const patch: { autoReducedFrom?: number; notice?: string } = {};
+        if (typeof r.autoReducedFrom === "number" && Number.isFinite(r.autoReducedFrom)) {
+          patch.autoReducedFrom = normalizeLimit(r.autoReducedFrom);
+        }
+        if (typeof r.notice === "string" && r.notice.length > 0) {
+          patch.notice = r.notice;
+        }
+        if (patch.autoReducedFrom !== undefined || patch.notice !== undefined) {
+          entry = { ...entry, ...patch };
+        }
+      }
+      return entry;
     })
     .filter((r) => r.providerId !== "");
 }
+
+/**
+ * Coerce an untrusted `GET`/`PUT /concurrency/cooldown/:providerId` body into a
+ * typed cooldown response, or `null` when it is malformed (missing/malformed
+ * `providerId` or `cooldownMs`). The composition root surfaces a 404/400/503 as
+ * `ok: false` separately; this only defends the success body.
+ */
+export function normalizeConcurrencyCooldown(data: unknown): ConcurrencyCooldownResponse | null {
+  if (!isRecord(data)) return null;
+  const providerId = asString(data.providerId);
+  if (providerId === null) return null;
+  return { providerId, cooldownMs: normalizeCooldown(data.cooldownMs) };
+}
diff --git a/src/features/concurrency/ui/AutoReduceBanner.svelte b/src/features/concurrency/ui/AutoReduceBanner.svelte
new file mode 100644
index 0000000..132ebc7
--- /dev/null
+++ b/src/features/concurrency/ui/AutoReduceBanner.svelte
@@ -0,0 +1,81 @@
+<script lang="ts">
+  import type { AutoReduceNotice } from "../logic/view-model";
+  import type { RestoreOutcome } from "../logic/types";
+
+  let {
+    notice,
+    onRestore,
+    onDismiss,
+  }: {
+    /** The auto-reduce banner view (providerId + message + from/current limit). */
+    notice: AutoReduceNotice;
+    /**
+     * "Restore to N" — PUT the limit back to `fromLimit`. Returns the outcome so
+     * a FAILED restore surfaces an inline error here (the banner owns its error
+     * display; the parent only refreshes on success).
+     */
+    onRestore: (providerId: string, limit: number) => Promise<RestoreOutcome>;
+    /** Hide this banner locally (persists hidden while autoReduced stays true). */
+    onDismiss: (providerId: string) => void;
+  } = $props();
+
+  let restoring = $state(false);
+  /** Inline restore error (e.g. "Concurrency service not available"); cleared on retry. */
+  let error = $state<string | null>(null);
+
+  async function handleRestore(): Promise<void> {
+    restoring = true;
+    error = null;
+    // The parent PUTs the limit + refreshes status on success; the banner clears
+    // once the next poll shows autoReduced===false. On failure the outcome is
+    // bubbled back here so the error shows inline next to the button.
+    const result = await onRestore(notice.providerId, notice.fromLimit);
+    restoring = false;
+    if (!result.ok) {
+      error = result.error;
+    }
+  }
+</script>
+
+<div
+  class="alert alert-warning flex flex-col gap-2 py-2 text-xs"
+  role="status"
+  data-testid={`auto-reduce-banner-${notice.providerId}`}
+>
+  <div class="flex items-start gap-2">
+    <span class="shrink-0">⚠</span>
+    <div class="flex-1">
+      <p>{notice.message}</p>
+      <p class="opacity-70">
+        Was {notice.fromLimit}, now {notice.currentLimit}.
+      </p>
+    </div>
+    <div class="flex shrink-0 items-center gap-1">
+      <!-- The "Restore to N" text stays visible while loading (only the spinner is
+           prepended) so the button keeps its accessible name during the PUT — a
+           spinner-only button loses its name for screen-reader users. -->
+      <button
+        type="button"
+        class="btn btn-warning btn-xs gap-1"
+        disabled={restoring}
+        onclick={handleRestore}
+      >
+        {#if restoring}
+          <span class="loading loading-spinner loading-xs"></span>
+        {/if}
+        Restore to {notice.fromLimit}
+      </button>
+      <button
+        type="button"
+        class="btn btn-ghost btn-xs"
+        aria-label={`Dismiss auto-reduce notice for ${notice.providerId}`}
+        onclick={() => onDismiss(notice.providerId)}
+      >
+        ✕
+      </button>
+    </div>
+  </div>
+  {#if error}
+    <p class="font-mono text-error" data-testid={`restore-error-${notice.providerId}`}>{error}</p>
+  {/if}
+</div>
diff --git a/src/features/concurrency/ui/ConcurrencyCooldownRow.svelte b/src/features/concurrency/ui/ConcurrencyCooldownRow.svelte
new file mode 100644
index 0000000..03ddec9
--- /dev/null
+++ b/src/features/concurrency/ui/ConcurrencyCooldownRow.svelte
@@ -0,0 +1,93 @@
+<script lang="ts">
+  import { untrack } from "svelte";
+  import { parseCooldownInput } from "../logic/view-model";
+  import type { SaveConcurrencyCooldown } from "../logic/types";
+
+  let {
+    providerId,
+    cooldownMs,
+    save,
+  }: {
+    /** The provider this cooldown row controls. */
+    providerId: string;
+    /** The current per-slot release cooldown (ms) from the live status poll. */
+    cooldownMs: number;
+    save: SaveConcurrencyCooldown;
+  } = $props();
+
+  // Inline-edit state: the raw text bound to the cooldown input. Seeded from the
+  // row's canonical cooldownMs, but only while the field is untouched — so a
+  // status-poll refresh re-syncs it without clobbering an in-flight edit. Mirrors
+  // the ConcurrencyLimitRow / ChatLimitField seed pattern.
+  let draft = $state("");
+  let lastSeed = $state("");
+  let saving = $state(false);
+  let error = $state<string | null>(null);
+  /** Brief "Saved." confirmation after a successful save; cleared on edit. */
+  let justSaved = $state(false);
+
+  $effect(() => {
+    const incoming = String(cooldownMs);
+    untrack(() => {
+      if (draft === lastSeed) draft = incoming;
+      lastSeed = incoming;
+    });
+  });
+
+  const parsed = $derived(parseCooldownInput(draft));
+  const dirty = $derived(parsed !== null && parsed !== cooldownMs);
+
+  function onInput(): void {
+    justSaved = false;
+    error = null;
+  }
+
+  async function handleSave(): Promise<void> {
+    if (parsed === null || parsed === cooldownMs) return;
+    saving = true;
+    error = null;
+    const result = await save(providerId, parsed);
+    saving = false;
+    if (result.ok) {
+      // Reflect the echoed cooldown back into the field immediately (the prop
+      // also re-asserts it via the seed effect above once the parent reloads).
+      draft = String(result.cooldownMs);
+      lastSeed = draft;
+      justSaved = true;
+    } else {
+      error = result.error;
+    }
+  }
+</script>
+
+<div class="flex items-center gap-2 text-xs">
+  <span class="opacity-60">cooldown</span>
+  <input
+    type="text"
+    inputmode="numeric"
+    class="input input-bordered input-xs w-20 font-mono"
+    aria-label={`Release cooldown (ms) for ${providerId}`}
+    bind:value={draft}
+    oninput={onInput}
+    disabled={saving}
+  />
+  <span class="opacity-50">ms</span>
+  <button
+    type="button"
+    class="btn btn-primary btn-xs"
+    aria-label={`Save cooldown for ${providerId}`}
+    disabled={!dirty || saving}
+    onclick={handleSave}
+  >
+    {#if saving}
+      <span class="loading loading-spinner loading-xs"></span>
+    {:else}
+      Save
+    {/if}
+  </button>
+  {#if error}
+    <span class="font-mono text-error">{error}</span>
+  {:else if justSaved && !dirty}
+    <span class="text-success">Saved.</span>
+  {/if}
+</div>
diff --git a/src/features/concurrency/ui/ConcurrencyView.svelte b/src/features/concurrency/ui/ConcurrencyView.svelte
index f8a2199..6078b1a 100644
--- a/src/features/concurrency/ui/ConcurrencyView.svelte
+++ b/src/features/concurrency/ui/ConcurrencyView.svelte
@@ -2,6 +2,7 @@
   import { untrack } from "svelte";
   import type { ConcurrencyStatusEntry } from "@dispatch/transport-contract";
   import {
+    autoReduceNotices,
     type Badge,
     parseLimitInput,
     providerOptions,
@@ -15,8 +16,12 @@
     DeleteConcurrencyLimit,
     LoadConcurrencyLimits,
     LoadConcurrencyStatus,
+    RestoreOutcome,
+    SaveConcurrencyCooldown,
     SaveConcurrencyLimit,
   } from "../logic/types";
+  import AutoReduceBanner from "./AutoReduceBanner.svelte";
+  import ConcurrencyCooldownRow from "./ConcurrencyCooldownRow.svelte";
   import ConcurrencyLimitRow from "./ConcurrencyLimitRow.svelte";
 
   let {
@@ -25,6 +30,7 @@
     saveLimit,
     deleteLimit,
     loadStatus,
+    saveCooldown,
   }: {
     /** Available models (`<provider>/<model>`) — the source of provider ids for the Add dropdown. */
     models: readonly string[];
@@ -32,6 +38,7 @@
     saveLimit: SaveConcurrencyLimit;
     deleteLimit: DeleteConcurrencyLimit;
     loadStatus: LoadConcurrencyStatus;
+    saveCooldown: SaveConcurrencyCooldown;
   } = $props();
 
   const badgeClass: Record<Badge, string> = {
@@ -136,6 +143,18 @@
     return result;
   }
 
+  // Wrap the cooldown save so a successful PUT refreshes the live status (which
+  // re-carries the new `cooldownMs`). The row still gets the result to drive its
+  // own UI. `getCooldown` is exposed for completeness/future use (the live status
+  // already carries `cooldownMs`, so the row seeds from the status view).
+  async function cooldownSave(providerId: string, cooldownMs: number) {
+    const result = await saveCooldown(providerId, cooldownMs);
+    if (result.ok) {
+      void refreshStatus();
+    }
+    return result;
+  }
+
   // ── Live status (polls while mounted) ───────────────────────────────────────
   let statusEntries = $state<readonly ConcurrencyStatusEntry[]>([]);
   let statusError = $state<string | null>(null);
@@ -158,6 +177,69 @@
   const statusViews = $derived(viewConcurrencyStatuses(statusEntries, now));
   const statusSummary = $derived(summarizeStatus(statusEntries, now));
 
+  // ── Auto-reduce banners (persist while autoReduced===true; dismissible) ───────
+  //
+  // When a provider's limit is auto-reduced by a 429, `GET /concurrency/status`
+  // carries `autoReduced: true` (+ `autoReducedFrom` + `notice`). We render a
+  // banner per such provider. The banner is DISMISSIBLE: a dismissed provider
+  // stays hidden while it remains auto-reduced (persist-while-true), and is
+  // UN-dismissed the moment a poll shows it no longer auto-reduced — so a future
+  // auto-reduce re-shows the banner. Restoring the limit (PUT) clears
+  // `autoReduced` server-side → the next poll drops the banner automatically.
+  //
+  // The dismissed set is intentionally COMPONENT-LOCAL (NOT persisted to
+  // localStorage / a module-global): it resets on remount (sidebar view switch /
+  // reload). This is correct — `autoReduced` is a REAL persisted degraded state,
+  // so re-showing the banner on a fresh mount reminds the user. Persisting a
+  // dismissal across reloads would risk HIDING an ongoing degradation (a
+  // footgun), and AGENTS.md forbids module-global ambient state. Mirrors the
+  // component-local `limitsError`/`statusError` pattern.
+  let dismissedAutoReduce = $state<ReadonlySet<string>>(new Set());
+
+  const allNotices = $derived(autoReduceNotices(statusEntries));
+  const visibleNotices = $derived(
+    allNotices.filter((n) => !dismissedAutoReduce.has(n.providerId)),
+  );
+
+  // Reconcile the dismissed set against the live auto-reduced providers: keep a
+  // dismissed entry ONLY while its provider is still auto-reduced. A provider
+  // that has been restored (no longer in `allNotices`) is dropped from the
+  // dismissed set so a future auto-reduce re-shows its banner.
+  $effect(() => {
+    const autoReducedIds = new Set(allNotices.map((n) => n.providerId));
+    untrack(() => {
+      let changed = false;
+      const next = new Set<string>();
+      for (const id of dismissedAutoReduce) {
+        if (autoReducedIds.has(id)) next.add(id);
+        else changed = true;
+      }
+      if (changed) dismissedAutoReduce = next;
+    });
+  });
+
+  function dismissAutoReduce(providerId: string): void {
+    if (dismissedAutoReduce.has(providerId)) return;
+    dismissedAutoReduce = new Set([...dismissedAutoReduce, providerId]);
+  }
+
+  // "Restore to N" — PUT the limit back to `autoReducedFrom` via the limits
+  // endpoint (a manual PUT clears `autoReduced` server-side). Refreshes limits +
+  // status on success; the next status poll shows `autoReduced===false` and the
+  // banner drops (the dismissed-set effect above un-dismisses it too). The banner
+  // component owns its own restoring-spinner + inline error; on FAILURE the
+  // outcome is bubbled back so the banner shows the error inline (instead of
+  // silently re-enabling the button / surfacing it only in the limits section).
+  async function restoreLimit(providerId: string, limit: number): Promise<RestoreOutcome> {
+    const result = await saveLimit(providerId, limit);
+    if (result.ok) {
+      void refreshLimits();
+      void refreshStatus();
+      return { ok: true };
+    }
+    return { ok: false, error: result.error };
+  }
+
   async function refreshStatus(): Promise<void> {
     if (statusInFlight) return;
     statusInFlight = true;
@@ -192,6 +274,19 @@
 </script>
 
 <div class="flex flex-col gap-4">
+  <!-- Auto-reduce banners (appear when a provider's limit was auto-reduced by a 429) -->
+  {#if visibleNotices.length > 0}
+    <section class="flex flex-col gap-2" aria-label="Concurrency auto-reduce notices">
+      {#each visibleNotices as notice (notice.providerId)}
+        <AutoReduceBanner
+          {notice}
+          onRestore={restoreLimit}
+          onDismiss={dismissAutoReduce}
+        />
+      {/each}
+    </section>
+  {/if}
+
   <!-- Limits (config) -->
   <section class="flex flex-col gap-2">
     <div class="flex items-center justify-between gap-2">
@@ -319,10 +414,22 @@
             <div class="flex flex-wrap items-center justify-between gap-2 text-xs opacity-70">
               <span title="In-flight slots held vs cap">{s.inFlightLabel} in flight</span>
               <span>{s.queuedLabel}</span>
+              <span title="Per-slot release cooldown">cooldown {s.cooldownLabel}</span>
             </div>
             {#if s.pausedLabel}
               <span class="text-xs text-warning">{s.pausedLabel}</span>
             {/if}
+            {#if s.autoReduced}
+              <span class="text-xs text-warning">
+                Limit auto-reduced{#if s.autoReducedFrom !== null}
+                  from {s.autoReducedFrom} to {s.limit}{/if}.
+              </span>
+            {/if}
+            <ConcurrencyCooldownRow
+              providerId={s.providerId}
+              cooldownMs={s.cooldownMs}
+              save={cooldownSave}
+            />
           </li>
         {/each}
       </ul>
diff --git a/src/features/concurrency/ui/ConcurrencyView.test.ts b/src/features/concurrency/ui/ConcurrencyView.test.ts
index 3dc8e78..854f13b 100644
--- a/src/features/concurrency/ui/ConcurrencyView.test.ts
+++ b/src/features/concurrency/ui/ConcurrencyView.test.ts
@@ -3,6 +3,7 @@ import { render, screen } from "@testing-library/svelte";
 import userEvent from "@testing-library/user-event";
 import { describe, expect, it } from "vitest";
 import type {
+  ConcurrencyCooldownResult,
   ConcurrencyDeleteResult,
   ConcurrencyLimitResult,
   ConcurrencyLimitsResult,
@@ -13,35 +14,80 @@ import ConcurrencyView from "./ConcurrencyView.svelte";
 // Available models → provider ids are "umans", "anthropic", "openai-compat".
 const MODELS = ["umans/umans-glm-5.2", "anthropic/claude-sonnet", "openai-compat/gpt-4o"] as const;
 
-// Fakes for the four injected ports. Each resolves immediately so the mount
-// effect's initial load settles in a microtask (assertions await via findBy*).
+// A status entry factory (defaults to a healthy limited provider). The new
+// concurrency-fixes fields (`cooldownMs`, `autoReduced`) are always present.
+function statusEntry(over: Partial<ConcurrencyStatusEntry> = {}): ConcurrencyStatusEntry {
+  return {
+    providerId: "umans",
+    limit: 4,
+    inFlight: 2,
+    queued: 1,
+    paused: false,
+    cooldownMs: 350,
+    autoReduced: false,
+    ...over,
+  };
+}
 
+// Fakes for the injected ports. Each resolves immediately so the mount effect's
+// initial load settles in a microtask (assertions await via findBy*). The status
+// list is mutable so a test can flip `autoReduced` between polls to simulate a
+// restore clearing the banner.
 function makeFakes(opts?: {
   limits?: readonly { providerId: string; limit: number }[];
-  status?: readonly ConcurrencyStatusEntry[];
+  status?: ConcurrencyStatusEntry[];
+  /**
+   * When set, `saveLimit` rejects with this error (returns `ok: false`) — used
+   * to test the auto-reduce banner's inline restore-error feedback.
+   */
+  saveLimitError?: string;
+  /**
+   * Optional hook invoked inside `saveLimit` AFTER recording the call. Lets a
+   * test simulate a backend side-effect of the PUT (e.g. clearing `autoReduced`
+   * on the next status poll). Receives the providerId + limit + the fakes bag so
+   * it can mutate the status list. (A plain method reassignment would NOT reach
+   * the already-rendered component — the prop captured the original closure.)
+   */
+  onSaveLimit?: (
+    providerId: string,
+    limit: number,
+    self: { calls: MakeFakesCalls; setStatus: (next: ConcurrencyStatusEntry[]) => void },
+  ) => void;
 }) {
   let limits = opts?.limits ?? [{ providerId: "umans", limit: 4 }];
-  const status = opts?.status ?? [
-    { providerId: "umans", limit: 4, inFlight: 2, queued: 1, paused: false },
-  ];
+  let status = opts?.status ?? [statusEntry()];
+  const onSaveLimit = opts?.onSaveLimit;
+  const saveLimitError = opts?.saveLimitError;
 
-  const calls = {
+  const calls: MakeFakesCalls = {
     loadLimits: 0,
     loadStatus: 0,
     saves: [] as { providerId: string; limit: number }[],
     deletes: [] as string[],
+    cooldownSaves: [] as { providerId: string; cooldownMs: number }[],
   };
 
+  function setStatus(next: ConcurrencyStatusEntry[]): void {
+    status = next;
+  }
+
   return {
     calls,
+    // Allow a test to mutate the status list between polls (e.g. clear
+    // autoReduced after a restore to simulate the next poll).
+    setStatus,
     loadLimits: async (): Promise<ConcurrencyLimitsResult> => {
       calls.loadLimits++;
       return { ok: true, limits };
     },
     saveLimit: async (providerId: string, limit: number): Promise<ConcurrencyLimitResult> => {
       calls.saves.push({ providerId, limit });
+      if (saveLimitError !== undefined) {
+        return { ok: false, error: saveLimitError };
+      }
       // Reflect the new limit into the list the next load returns.
       limits = [...limits.filter((l) => l.providerId !== providerId), { providerId, limit }];
+      if (onSaveLimit !== undefined) onSaveLimit(providerId, limit, { calls, setStatus });
       return { ok: true, providerId, limit };
     },
     deleteLimit: async (providerId: string): Promise<ConcurrencyDeleteResult> => {
@@ -53,21 +99,41 @@ function makeFakes(opts?: {
       calls.loadStatus++;
       return { ok: true, providers: status };
     },
+    saveCooldown: async (
+      providerId: string,
+      cooldownMs: number,
+    ): Promise<ConcurrencyCooldownResult> => {
+      calls.cooldownSaves.push({ providerId, cooldownMs });
+      // Reflect the new cooldown into the status list the next load returns.
+      status = status.map((s) => (s.providerId === providerId ? { ...s, cooldownMs } : s));
+      return { ok: true, providerId, cooldownMs };
+    },
+  };
+}
+
+type MakeFakesCalls = {
+  loadLimits: number;
+  loadStatus: number;
+  saves: { providerId: string; limit: number }[];
+  deletes: string[];
+  cooldownSaves: { providerId: string; cooldownMs: number }[];
+};
+
+function props(fakes: ReturnType<typeof makeFakes>) {
+  return {
+    models: MODELS as unknown as readonly string[],
+    loadLimits: fakes.loadLimits,
+    saveLimit: fakes.saveLimit,
+    deleteLimit: fakes.deleteLimit,
+    loadStatus: fakes.loadStatus,
+    saveCooldown: fakes.saveCooldown,
   };
 }
 
 describe("ConcurrencyView", () => {
   it("loads + renders the configured limits and live status on mount", async () => {
     const fakes = makeFakes();
-    render(ConcurrencyView, {
-      props: {
-        models: MODELS,
-        loadLimits: fakes.loadLimits,
-        saveLimit: fakes.saveLimit,
-        deleteLimit: fakes.deleteLimit,
-        loadStatus: fakes.loadStatus,
-      },
-    });
+    render(ConcurrencyView, { props: props(fakes) });
 
     // The provider dropdown is populated from the available models' providers.
     const providerSelect = await screen.findByLabelText("Provider");
@@ -81,21 +147,21 @@ describe("ConcurrencyView", () => {
     expect(fakes.calls.loadStatus).toBeGreaterThanOrEqual(1);
   });
 
+  it("renders the per-provider cooldown label from the live status", async () => {
+    const fakes = makeFakes({ status: [statusEntry({ cooldownMs: 350 })] });
+    render(ConcurrencyView, { props: props(fakes) });
+
+    // The status card shows the cooldown alongside in-flight/queue.
+    expect(await screen.findByText(/cooldown 350ms/)).toBeInTheDocument();
+  });
+
   it("surfaces NO loading indicator during refresh (background poll is silent — no flicker)", async () => {
     // The 2s status poll + post-mutation reloads are SILENT: they never toggle a
     // visible loading state, so the Refresh buttons are plain-text (no spinner)
     // and the list area never reflows mid-refresh. Regression guard for the
     // flicker fix (mirrors the heartbeat runs list).
     const fakes = makeFakes();
-    render(ConcurrencyView, {
-      props: {
-        models: MODELS,
-        loadLimits: fakes.loadLimits,
-        saveLimit: fakes.saveLimit,
-        deleteLimit: fakes.deleteLimit,
-        loadStatus: fakes.loadStatus,
-      },
-    });
+    render(ConcurrencyView, { props: props(fakes) });
 
     await screen.findByText(/1 provider · 2\/4 in flight · 1 queued/);
 
@@ -116,15 +182,7 @@ describe("ConcurrencyView", () => {
   it("adds a provider limit via the dropdown form (calls saveLimit + reloads)", async () => {
     const user = userEvent.setup();
     const fakes = makeFakes({ limits: [], status: [] });
-    render(ConcurrencyView, {
-      props: {
-        models: MODELS,
-        loadLimits: fakes.loadLimits,
-        saveLimit: fakes.saveLimit,
-        deleteLimit: fakes.deleteLimit,
-        loadStatus: fakes.loadStatus,
-      },
-    });
+    render(ConcurrencyView, { props: props(fakes) });
 
     const providerSelect = await screen.findByLabelText("Provider");
     // Choose "anthropic" from the dropdown (the list is auto-selected first).
@@ -142,15 +200,7 @@ describe("ConcurrencyView", () => {
   it("disables Add when the limit is empty/invalid (provider is auto-selected)", async () => {
     const user = userEvent.setup();
     const fakes = makeFakes({ limits: [], status: [] });
-    render(ConcurrencyView, {
-      props: {
-        models: MODELS,
-        loadLimits: fakes.loadLimits,
-        saveLimit: fakes.saveLimit,
-        deleteLimit: fakes.deleteLimit,
-        loadStatus: fakes.loadStatus,
-      },
-    });
+    render(ConcurrencyView, { props: props(fakes) });
 
     const providerSelect = await screen.findByLabelText("Provider");
     // A provider is auto-selected from the dropdown.
@@ -172,13 +222,7 @@ describe("ConcurrencyView", () => {
   it("shows no-providers + disables the dropdown when there are no models", async () => {
     const fakes = makeFakes({ limits: [], status: [] });
     render(ConcurrencyView, {
-      props: {
-        models: [],
-        loadLimits: fakes.loadLimits,
-        saveLimit: fakes.saveLimit,
-        deleteLimit: fakes.deleteLimit,
-        loadStatus: fakes.loadStatus,
-      },
+      props: { ...props(fakes), models: [] as unknown as readonly string[] },
     });
 
     const providerSelect = await screen.findByLabelText("Provider");
@@ -189,15 +233,7 @@ describe("ConcurrencyView", () => {
   it("removes a provider limit via the row ✕ (calls deleteLimit + reloads)", async () => {
     const user = userEvent.setup();
     const fakes = makeFakes();
-    render(ConcurrencyView, {
-      props: {
-        models: MODELS,
-        loadLimits: fakes.loadLimits,
-        saveLimit: fakes.saveLimit,
-        deleteLimit: fakes.deleteLimit,
-        loadStatus: fakes.loadStatus,
-      },
-    });
+    render(ConcurrencyView, { props: props(fakes) });
 
     // Wait for the limits to load (unique summary) before interacting.
     await screen.findByText(/1 limit configured/);
@@ -209,7 +245,7 @@ describe("ConcurrencyView", () => {
 
   it("surfaces a load error from the limits endpoint", async () => {
     const failing = {
-      models: MODELS,
+      models: MODELS as unknown as readonly string[],
       loadLimits: async (): Promise<ConcurrencyLimitsResult> => ({
         ok: false,
         error: "Concurrency service not available",
@@ -217,8 +253,191 @@ describe("ConcurrencyView", () => {
       saveLimit: async (): Promise<ConcurrencyLimitResult> => ({ ok: false, error: "noop" }),
       deleteLimit: async (): Promise<ConcurrencyDeleteResult> => ({ ok: false, error: "noop" }),
       loadStatus: async (): Promise<ConcurrencyStatusResult> => ({ ok: true, providers: [] }),
+      saveCooldown: async (): Promise<ConcurrencyCooldownResult> => ({ ok: false, error: "noop" }),
     };
     render(ConcurrencyView, { props: failing });
     expect(await screen.findByText("Concurrency service not available")).toBeVisible();
   });
+
+  // ── Concurrency-fixes: auto-reduce banner + cooldown editing ────────────────
+
+  it("renders an auto-reduce banner (with the backend notice + Restore) when a provider is auto-reduced", async () => {
+    const fakes = makeFakes({
+      status: [
+        statusEntry({
+          limit: 3,
+          autoReduced: true,
+          autoReducedFrom: 4,
+          notice: "Concurrency limit auto-reduced to 3 after a 429 — restore manually when ready.",
+        }),
+      ],
+    });
+    render(ConcurrencyView, { props: props(fakes) });
+
+    // The banner shows the backend notice verbatim + a "Restore to 4" action.
+    expect(await screen.findByText(/auto-reduced to 3 after a 429/)).toBeVisible();
+    expect(await screen.findByRole("button", { name: /Restore to 4/ })).toBeVisible();
+    // The "Was 4, now 3." provenance line is shown.
+    expect(await screen.findByText(/Was 4, now 3\./)).toBeVisible();
+  });
+
+  it("clears the banner after Restore (next status poll shows autoReduced===false)", async () => {
+    const user = userEvent.setup();
+    // Start auto-reduced (limit 3, was 4). The restore PUT clears `autoReduced`
+    // server-side; the next status poll returns limit 4 + autoReduced===false →
+    // the banner drops.
+    const fakes = makeFakes({
+      status: [
+        statusEntry({
+          limit: 3,
+          autoReduced: true,
+          autoReducedFrom: 4,
+          notice: "Concurrency limit auto-reduced to 3 after a 429.",
+        }),
+      ],
+      onSaveLimit: (_providerId, limit, self) => {
+        // Simulate the backend clearing `autoReduced` on the manual PUT: the next
+        // status load returns the restored limit with autoReduced===false.
+        self.setStatus([statusEntry({ limit, autoReduced: false })]);
+      },
+    });
+    render(ConcurrencyView, { props: props(fakes) });
+
+    const restoreBtn = await screen.findByRole("button", { name: /Restore to 4/ });
+    await user.click(restoreBtn);
+
+    // The restore PUT the limit back to the original (autoReducedFrom = 4).
+    expect(fakes.calls.saves).toEqual([{ providerId: "umans", limit: 4 }]);
+    // The banner is gone (no Restore button, no notice text); the status summary
+    // now reflects the restored limit (2/4 in flight).
+    await screen.findByText(/1 provider · 2\/4 in flight · 1 queued/);
+    expect(screen.queryByRole("button", { name: /Restore to/ })).toBeNull();
+    expect(screen.queryByText(/auto-reduced to 3 after a 429/)).toBeNull();
+  });
+
+  it("dismisses the auto-reduce banner locally while it stays auto-reduced", async () => {
+    const user = userEvent.setup();
+    const fakes = makeFakes({
+      status: [
+        statusEntry({
+          limit: 3,
+          autoReduced: true,
+          autoReducedFrom: 4,
+          notice: "Concurrency limit auto-reduced to 3 after a 429.",
+        }),
+      ],
+    });
+    render(ConcurrencyView, { props: props(fakes) });
+
+    await screen.findByRole("button", { name: /Restore to 4/ });
+    // Dismiss the banner (hide locally — the provider is still auto-reduced).
+    await user.click(screen.getByLabelText("Dismiss auto-reduce notice for umans"));
+    expect(screen.queryByRole("button", { name: /Restore to/ })).toBeNull();
+    expect(screen.queryByText(/auto-reduced to 3 after a 429/)).toBeNull();
+  });
+
+  it("shows an inline error in the banner when the Restore PUT fails (no silent re-enable)", async () => {
+    const user = userEvent.setup();
+    const fakes = makeFakes({
+      status: [
+        statusEntry({
+          limit: 3,
+          autoReduced: true,
+          autoReducedFrom: 4,
+          notice: "Concurrency limit auto-reduced to 3 after a 429.",
+        }),
+      ],
+      saveLimitError: "Concurrency service not available",
+    });
+    render(ConcurrencyView, { props: props(fakes) });
+
+    const restoreBtn = await screen.findByRole("button", { name: /Restore to 4/ });
+    await user.click(restoreBtn);
+
+    // The error surfaces INLINE in the banner (near the restore action), not
+    // only in the far-away limits section. The banner is still present (restore
+    // did not succeed) and the button re-enabled for a retry.
+    expect(await screen.findByTestId("restore-error-umans")).toHaveTextContent(
+      "Concurrency service not available",
+    );
+    expect(screen.getByRole("button", { name: /Restore to 4/ })).toBeVisible();
+    expect(screen.getByRole("button", { name: /Restore to 4/ })).not.toBeDisabled();
+    // The restore PUT was attempted.
+    expect(fakes.calls.saves).toEqual([{ providerId: "umans", limit: 4 }]);
+  });
+
+  it("clears the inline restore error on a retry that succeeds", async () => {
+    const user = userEvent.setup();
+    // First restore fails; the second succeeds (clears autoReduced). Reassigning
+    // `fakes.saveLimit` BEFORE `props(fakes)` is captured would NOT reach the
+    // rendered component, so swap it BEFORE render here.
+    const fakes = makeFakes({
+      status: [
+        statusEntry({
+          limit: 3,
+          autoReduced: true,
+          autoReducedFrom: 4,
+          notice: "Concurrency limit auto-reduced to 3 after a 429.",
+        }),
+      ],
+      onSaveLimit: (_providerId, limit, self) => {
+        self.setStatus([statusEntry({ limit, autoReduced: false })]);
+      },
+    });
+    let attempts = 0;
+    const succeeding = fakes.saveLimit;
+    fakes.saveLimit = async (providerId, limit) => {
+      attempts++;
+      if (attempts === 1) return { ok: false, error: "Concurrency service not available" };
+      return succeeding(providerId, limit);
+    };
+    render(ConcurrencyView, { props: props(fakes) });
+
+    const restoreBtn = await screen.findByRole("button", { name: /Restore to 4/ });
+    await user.click(restoreBtn);
+    // First attempt: inline error appears.
+    expect(await screen.findByTestId("restore-error-umans")).toBeInTheDocument();
+
+    // Retry: the error clears, the banner drops (restore succeeded).
+    await user.click(screen.getByRole("button", { name: /Restore to 4/ }));
+    await screen.findByText(/1 provider · 2\/4 in flight · 1 queued/);
+    expect(screen.queryByTestId("restore-error-umans")).toBeNull();
+    expect(screen.queryByRole("button", { name: /Restore to/ })).toBeNull();
+  });
+
+  it("edits the per-provider cooldown (PUT /concurrency/cooldown + reloads status)", async () => {
+    const user = userEvent.setup();
+    const fakes = makeFakes({ status: [statusEntry({ cooldownMs: 350 })] });
+    render(ConcurrencyView, { props: props(fakes) });
+
+    // Wait for the status card + its cooldown input (seeded with 350).
+    const cooldownInput = await screen.findByLabelText("Release cooldown (ms) for umans");
+    expect((cooldownInput as HTMLInputElement).value).toBe("350");
+
+    await user.clear(cooldownInput);
+    await user.type(cooldownInput, "500");
+    await user.click(screen.getByRole("button", { name: "Save cooldown for umans" }));
+
+    // The cooldown PUT fired with the new value.
+    expect(fakes.calls.cooldownSaves).toEqual([{ providerId: "umans", cooldownMs: 500 }]);
+    // After save the component reloads status (which now carries cooldownMs=500).
+    expect(await screen.findByText(/cooldown 500ms/)).toBeInTheDocument();
+  });
+
+  it("rejects a negative cooldown input (Save disabled — non-negative integer only)", async () => {
+    const user = userEvent.setup();
+    const fakes = makeFakes({ status: [statusEntry({ cooldownMs: 350 })] });
+    render(ConcurrencyView, { props: props(fakes) });
+
+    const cooldownInput = await screen.findByLabelText("Release cooldown (ms) for umans");
+    // 0 is valid (no cooldown); a negative is not.
+    await user.clear(cooldownInput);
+    await user.type(cooldownInput, "0");
+    expect(screen.getByRole("button", { name: "Save cooldown for umans" })).toBeEnabled();
+
+    await user.clear(cooldownInput);
+    await user.type(cooldownInput, "-5");
+    expect(screen.getByRole("button", { name: "Save cooldown for umans" })).toBeDisabled();
+    expect(fakes.calls.cooldownSaves).toHaveLength(0);
+  });
 });