@@ -22,18 +22,9 @@ export type FoundQueue = Prettify<
 export async function getQueue(
   prismaClient: PrismaClientOrTransaction,
   environment: AuthenticatedEnvironment,
-  queue: RetrieveQueueParam,
-  options?: {
-    /**
-     * The dashboard's detail page shows limit rows too; the public API and pause
-     * flows stay scoped to queue rows.
-     */
-    includeLimits?: boolean;
-  }
+  queue: RetrieveQueueParam
 ) {
-  const role = options?.includeLimits
-    ? { in: ["QUEUE" as const, "LIMIT" as const] }
-    : ("QUEUE" as const);
+  const role = "QUEUE" as const;
 
   if (typeof queue === "string") {
     return joinQueueWithUser(
@@ -88,28 +79,21 @@ export class QueueRetrievePresenter extends BasePresenter {
   public async call({
     environment,
     queueInput,
-    includeLimits,
   }: {
     environment: AuthenticatedEnvironment;
     queueInput: RetrieveQueueParam;
-    includeLimits?: boolean;
   }) {
-    const queue = await getQueue(this._replica, environment, queueInput, { includeLimits });
+    const queue = await getQueue(this._replica, environment, queueInput);
     if (!queue) {
       return {
         success: false as const,
         code: "queue-not-found",
       };
     }
 
-    const isLimitRow = queue.role === "LIMIT";
     const results = await Promise.all([
-      isLimitRow
-        ? engine.gateQueuedCountOfQueues(environment, [queue.name])
-        : engine.lengthOfQueues(environment, [queue.name]),
-      isLimitRow
-        ? engine.totalConcurrencyOfQueues(environment, [queue.name])
-        : engine.currentConcurrencyOfQueues(environment, [queue.name]),
+      engine.lengthOfQueues(environment, [queue.name]),
+      engine.currentConcurrencyOfQueues(environment, [queue.name]),
       queue.totalConcurrencyLimit != null
         ? engine.totalConcurrencyOfQueues(environment, [queue.name])
         : undefined,
@@ -144,8 +128,6 @@ export class QueueRetrievePresenter extends BasePresenter {
           queue.concurrencyLimitOverridePercent !== null
             ? Number(queue.concurrencyLimitOverridePercent)
             : null,
-        kind: isLimitRow ? ("limit" as const) : ("queue" as const),
-        concurrencyVersion: queue.concurrencyVersion,
       },
     };
   }
 
@@ -290,7 +290,7 @@ export const action = async ({ request, params }: ActionFunctionArgs) => {
   const userId = await requireUserId(request);
   if (request.method.toLowerCase() !== "post") {
     return redirectWithErrorMessage(
-      `/orgs/${params.organizationSlug}/projects/${params.projectParam}/env/${params.envParam}/queues`,
+      `/orgs/${params.organizationSlug}/projects/${params.projectParam}/env/${params.envParam}/concurrency`,
       request,
       "Wrong method"
     );
@@ -318,7 +318,7 @@ export const action = async ({ request, params }: ActionFunctionArgs) => {
   const action = formData.get("action");
 
   const url = new URL(request.url);
-  const redirectPath = `/orgs/${organizationSlug}/projects/${projectParam}/env/${envParam}/queues${url.search}`;
+  const redirectPath = `/orgs/${organizationSlug}/projects/${projectParam}/env/${envParam}/concurrency${url.search}`;
 
   if (environment.archivedAt) {
     return redirectWithErrorMessage(redirectPath, request, "This branch is archived");
@@ -779,16 +779,21 @@ function QueuesWithMetricsView() {
                     queue.queued >= environment.queueSizeLimit;
                   const queueFilterableName = queueMetricsKey(queue);
                   const queueMetric = metricsByQueue[queueFilterableName];
-                  const queueDetailPath = concurrencyQueuePath(organization, project, env, {
-                    friendlyId: queue.id,
-                  });
                   const isLimit = queue.kind === "limit";
+                  /** The detail page is queue observability (queue metrics, run filters, pause
+                   * and override actions); a limit's activity lives on each holder's home queue,
+                   * so limit rows don't link anywhere. */
+                  const queueDetailPath = isLimit
+                    ? undefined
+                    : concurrencyQueuePath(organization, project, env, {
+                        friendlyId: queue.id,
+                      });
                   const displayName = isLimit ? queue.name.replace(/^limit\//, "") : queue.name;
                   return (
                     <TableRow key={queue.name}>
                       <TableCell
                         to={queueDetailPath}
-                        isTabbableCell
+                        isTabbableCell={!isLimit}
                         // The queue-type icon and the at-limit warning are real <button>s, so
                         // they render beside the link (leading/trailing), never inside it —
                         // otherwise the cell is invalid <a><button> nesting. The name stays the
 
@@ -95,7 +95,7 @@ export const handle: Handle = {
 
 export const meta = pageMeta<typeof loader>(({ data, params }) => [
   data?.queue?.name ?? params.queueParam ?? "Queue",
-  "Queues",
+  "Concurrency",
 ]);
 
 const ParamsSchema = EnvironmentParamSchema.extend({ queueParam: z.string() });
@@ -122,7 +122,6 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
   const retrieve = await new QueueRetrievePresenter().call({
     environment,
     queueInput: queueParam,
-    includeLimits: true,
   });
   if (!retrieve.success) {
     throw new Response(undefined, { status: 404, statusText: "Queue not found" });
@@ -176,7 +175,7 @@ export const action = async ({ request, params }: ActionFunctionArgs) => {
   const { organizationSlug, projectParam, envParam, queueParam } = ParamsSchema.parse(params);
 
   const url = new URL(request.url);
-  const redirectPath = `/orgs/${organizationSlug}/projects/${projectParam}/env/${envParam}/queues/${queueParam}${url.search}`;
+  const redirectPath = `/orgs/${organizationSlug}/projects/${projectParam}/env/${envParam}/concurrency/${queueParam}${url.search}`;
 
   if (request.method.toLowerCase() !== "post") {
     return redirectWithErrorMessage(redirectPath, request, "Wrong method");
@@ -296,7 +295,7 @@ export default function Page() {
   return (
     <PageContainer>
       <NavBar>
-        <PageTitle title={queue.name} backButton={{ to: backPath, text: "Queues" }} />
+        <PageTitle title={queue.name} backButton={{ to: backPath, text: "Concurrency" }} />
       </NavBar>
       {/* Paused-queue banner — mirrors the environment-paused banner (OrgBanner) at the top of
           the page when this individual queue is paused. */}
 
@@ -124,7 +124,21 @@ export class ConcurrencyLimitsSystem {
 
         return findLimitByName(this.db, environment, name)
           .andThen((row) => applyLimitOverride(this.db, row, override, overriddenBy))
-          .andThen((row) => syncLimitToEngine(environment, row))
+          .andThen((row) =>
+            syncLimitToEngine(environment, row)
+              .andThen(() =>
+                compensateEngineFromFreshRow(this.db, environment, row.id, {
+                  alreadySyncedAt: row.updatedAt.getTime(),
+                })
+                  .orElse(() => okAsync(undefined))
+                  .map(() => row)
+              )
+              .orElse((error) =>
+                compensateEngineFromFreshRow(this.db, environment, row.id)
+                  .orElse(() => okAsync(undefined))
+                  .andThen(() => errAsync(error))
+              )
+          )
           .andThen((row) =>
             fromPromise(toLimitItems(environment, [row]), (error) => ({
               type: "other" as const,
@@ -374,21 +388,24 @@ function guardedLimitUpdate(
 }
 
 /**
- * A reset's engine write precedes its guarded persist (enforce-first, so an engine
- * failure retries cleanly), which leaves the engine reverted when the persist
- * conflicts or fails. This re-syncs the engine from fresh reads of the row until
- * updatedAt stops moving (bounded), the same convergence the deploy sync uses:
- * every actor writes Postgres before its own engine sync, so re-syncing whatever
- * is freshest converges. The original error still reaches the caller.
+ * Re-syncs the engine from fresh reads of the row until updatedAt stops moving
+ * (bounded), the same convergence the deploy sync uses: every actor writes
+ * Postgres before its own engine sync, so re-syncing whatever is freshest
+ * converges. Callers use it two ways: after a failure (a reset's enforce-first
+ * engine write preceding a persist that then conflicts, or an override's sync
+ * failing after its persist), where the original error still reaches the caller;
+ * and after a successful sync with `alreadySyncedAt` set to the synced row's
+ * updatedAt, where an unchanged row costs one read and a moved row is re-synced.
  */
 function compensateEngineFromFreshRow(
   db: PrismaClientOrTransaction,
   environment: AuthenticatedEnvironment,
-  rowId: string
+  rowId: string,
+  options?: { alreadySyncedAt?: number }
 ) {
   return fromPromise(
     (async () => {
-      let lastSyncedAt: number | null = null;
+      let lastSyncedAt: number | null = options?.alreadySyncedAt ?? null;
       for (let i = 0; i < 3; i++) {
         const fresh = await db.taskQueue.findFirst({ where: { id: rowId } });
         if (!fresh || fresh.updatedAt.getTime() === lastSyncedAt) {
 
@@ -202,6 +202,57 @@ describe("ConcurrencyLimitsSystem", () => {
     }
   );
 
+  postgresTest(
+    "a failed engine sync during override compensates from the fresh row",
+    async ({ prisma }) => {
+      const { authEnv, system, row } = await seedEnvAndLimit(prisma, { total: 25 });
+
+      totalSyncMock.mockRejectedValueOnce(new Error("redis down"));
+      const failed = await system.limits.override(authEnv, "openai", { total: 50 });
+      expect(failed.isErr()).toBe(true);
+      if (failed.isErr()) {
+        expect(failed.error.type).toBe("sync_limit_to_engine_failed");
+      }
+
+      /** The persist already happened; compensation re-syncs it so the engine
+       * doesn't keep enforcing the old bound while the API reports the new one. */
+      const updated = await prisma.taskQueue.findFirstOrThrow({ where: { id: row.id } });
+      expect(updated.totalConcurrencyLimit).toBe(50);
+      expect(totalSyncMock).toHaveBeenLastCalledWith(authEnv, "limit/openai", 50);
+      expect(totalSyncMock.mock.calls.length).toBeGreaterThanOrEqual(2);
+    }
+  );
+
+  postgresTest(
+    "an older override's engine write landing last is repaired by the freshness re-check",
+    async ({ prisma }) => {
+      const { authEnv, system, row } = await seedEnvAndLimit(prisma, { total: 25 });
+
+      /** `engineTotal` is written when a sync "lands", so landing order can differ
+       * from call order: the first override's write is delayed until a second,
+       * newer override has fully completed, then lands with the stale value. */
+      let engineTotal: number | null = null;
+      let secondResult: Awaited<ReturnType<typeof system.limits.override>> | undefined;
+      totalSyncMock.mockImplementation(async (_env, _name, value) => {
+        engineTotal = value as number;
+      });
+      totalSyncMock.mockImplementationOnce(async (_env, _name, value) => {
+        secondResult = await system.limits.override(authEnv, "openai", { total: 75 });
+        engineTotal = value as number;
+      });
+
+      const first = await system.limits.override(authEnv, "openai", { total: 50 });
+      expect(first.isOk()).toBe(true);
+      expect(secondResult?.isOk()).toBe(true);
+
+      const final = await prisma.taskQueue.findFirstOrThrow({ where: { id: row.id } });
+      expect(final.totalConcurrencyLimit).toBe(75);
+      expect(engineTotal).toBe(75);
+
+      totalSyncMock.mockImplementation(async () => undefined);
+    }
+  );
+
   postgresTest("retrieve misses queue-role rows and unknown names", async ({ prisma }) => {
     const { authEnv, system, environment } = await seedEnvAndLimit(prisma, { total: 25 });