@@ -15,6 +15,7 @@ import { BasePresenter } from "./basePresenter.server";
 
 type SlotHolderPhase = "admitted" | "dequeued";
 export type SlotHolderConsistency = "consistent" | "mismatch" | "unresolved";
+type SlotHolderCounterAgreement = "agree" | "disagree" | "unresolved";
 /** "not_found": a Redis slot holder with no matching TaskRun row. */
 type SlotHolderStatus = TaskRunStatus | "not_found";
 
@@ -25,6 +26,11 @@ export type EnvConcurrency = {
   current: number;
   /** The dequeue gate is `current < limit * burstFactor`, not `current < limit`. */
   burstFactor: number;
+  /**
+   * Env-scoped admitted slots. When `admitted > current`, the environment holds admitted
+   * slots the queue's holder list can't attribute.
+   */
+  admitted: number;
 };
 
 export type SlotHolder = {
@@ -47,7 +53,9 @@ export type SlotHolderFacts = {
   /** Dequeued holders that provably exist but aren't listed. */
   unlistedRunning: number;
   /** The counts mean nothing when this is "unresolved". */
-  consistency: SlotHolderConsistency;
+  counterAgreement: SlotHolderCounterAgreement;
+  /** Always true: an admitted concurrency-key holder with no backlog is never listable. */
+  ckAdmittedMayBeUnlisted: true;
 };
 
 // A run can only hold a slot before its final status. PENDING counts because Redis
@@ -78,11 +86,11 @@ export function slotHolderConsistency(
 export async function envConcurrencyFromRead(
   limit: number,
   burstFactor: number,
-  readCurrent: () => Promise<number>
+  readCounts: () => Promise<{ current: number; admitted: number }>
 ): Promise<EnvConcurrency | undefined> {
   try {
-    const current = await readCurrent();
-    return { limit, current, burstFactor };
+    const { current, admitted } = await readCounts();
+    return { limit, current, burstFactor, admitted };
   } catch {
     return undefined;
   }
@@ -215,9 +223,13 @@ export class QueueRetrievePresenter extends BasePresenter {
       typeof environment.concurrencyLimitBurstFactor === "number"
         ? environment.concurrencyLimitBurstFactor
         : environment.concurrencyLimitBurstFactor.toNumber();
-    return envConcurrencyFromRead(environment.maximumConcurrencyLimit, burstFactor, () =>
-      engine.concurrencyOfEnvQueue(environment)
-    );
+    return envConcurrencyFromRead(environment.maximumConcurrencyLimit, burstFactor, async () => {
+      const [current, admitted] = await Promise.all([
+        engine.concurrencyOfEnvQueue(environment),
+        engine.admittedConcurrencyOfEnvQueue(environment),
+      ]);
+      return { current, admitted };
+    });
   }
 
   /**
@@ -236,7 +248,8 @@ export class QueueRetrievePresenter extends BasePresenter {
         runningReported: 0,
         truncated: false,
         unlistedRunning: 0,
-        consistency: "unresolved" as const,
+        counterAgreement: "unresolved" as const,
+        ckAdmittedMayBeUnlisted: true as const,
       },
     };
 
@@ -290,7 +303,8 @@ export class QueueRetrievePresenter extends BasePresenter {
         runningReported: snapshot.runningReported,
         truncated: snapshot.truncated,
         unlistedRunning: snapshot.unlistedRunning,
-        consistency: snapshot.consistency,
+        counterAgreement: snapshot.counterAgreement,
+        ckAdmittedMayBeUnlisted: snapshot.ckAdmittedMayBeUnlisted,
       },
     };
   }
 
@@ -46,11 +46,14 @@ describe("slotHolderConsistency", () => {
 });
 
 describe("envConcurrencyFromRead", () => {
-  it("pairs the env limit and burst factor with the read current concurrency", async () => {
-    await expect(envConcurrencyFromRead(10, 2, async () => 7)).resolves.toEqual({
+  it("pairs the env limit and burst factor with the read concurrency counts", async () => {
+    await expect(
+      envConcurrencyFromRead(10, 2, async () => ({ current: 7, admitted: 9 }))
+    ).resolves.toEqual({
       limit: 10,
       current: 7,
       burstFactor: 2,
+      admitted: 9,
     });
   });
 
 
@@ -88,8 +88,8 @@ describe("the head-start and agent prefixes are the same prefix", () => {
  * drift. The snapshot below is the itemised diff a reviewer reads.
  */
 const PREFIX_BUDGET = {
-  assistant: { chars: 77_000, estimatedTokens: 19_500, tools: 24, promptChars: 27_000 },
-  code: { chars: 83_000, estimatedTokens: 21_000, tools: 28, promptChars: 29_500 },
+  assistant: { chars: 77_500, estimatedTokens: 19_500, tools: 24, promptChars: 27_000 },
+  code: { chars: 83_500, estimatedTokens: 21_000, tools: 28, promptChars: 29_500 },
 } as const;
 
 describe("the prefix stays inside its budget", () => {
 
@@ -371,7 +371,8 @@ describe("get_queue carries slot-holder facts through, and omits them when absen
       runningReported: 4,
       truncated: true,
       unlistedRunning: 2,
-      consistency: "mismatch",
+      counterAgreement: "disagree",
+      ckAdmittedMayBeUnlisted: true,
     };
     stubFetch({ slotHolders: [], slotHolderFacts });
     const answer = await getQueue()({ queue: "email-sends", type: "custom" });
@@ -392,16 +393,33 @@ describe("get_queue carries slot-holder facts through, and omits them when absen
       runningReported: 2,
       truncated: false,
       unlistedRunning: 0,
-      consistency: "consistent",
+      counterAgreement: "agree",
+      ckAdmittedMayBeUnlisted: true,
     };
     stubFetch({ slotHolderFacts });
     const answer = await getQueue()({ queue: "email-sends", type: "custom" });
     expect(answer).toMatchObject({ slotHolderFacts });
     expect(answer).not.toHaveProperty("slotHolders");
   });
 
-  it("carries envConcurrency verbatim, including burstFactor", async () => {
-    const envConcurrency = { limit: 10, current: 10, burstFactor: 2 };
+  it("carries ckAdmittedMayBeUnlisted alongside an all-zero holder list", async () => {
+    // The zeroes alone would read as "idle"; the flag is what stops that.
+    const slotHolderFacts = {
+      admittedCount: 0,
+      dequeuedCount: 0,
+      runningReported: 0,
+      truncated: false,
+      unlistedRunning: 0,
+      counterAgreement: "agree",
+      ckAdmittedMayBeUnlisted: true,
+    };
+    stubFetch({ slotHolders: [], slotHolderFacts });
+    const answer = await getQueue()({ queue: "email-sends", type: "custom" });
+    expect(answer).toMatchObject({ slotHolders: [], slotHolderFacts });
+  });
+
+  it("carries envConcurrency verbatim, including burstFactor and admitted", async () => {
+    const envConcurrency = { limit: 10, current: 10, burstFactor: 2, admitted: 14 };
     stubFetch({ envConcurrency });
     const answer = await getQueue()({ queue: "email-sends", type: "custom" });
     expect(answer).toMatchObject({ envConcurrency });
 
@@ -216,7 +216,7 @@ export const getQueueSchema = tool({
   description:
     "Get one queue's metrics over a window: wait latency (p50/p95), peak depth, how many runs started (throughput), and how often the queue was throttled by its concurrency limit. Use this for 'how deep is the X queue', 'is X backed up', or 'why are runs waiting'. The answer also carries the queue's live row: `paused`, `queuedNow`, `runningNow`, `concurrencyLimit`, and `exists: false` when no queue of that name is there at all. When `exists` is `false` in the current environment, " +
     MANDATORY_SWEEP +
-    " When that read fails rather than answers, `exists` is `\"unknown\"` with a `liveStateError`: the queue's state is unknown, not missing. For a custom queue it also carries `consumerTasks`: the deployed tasks whose queue config names this queue. When present, `slotHolders` (each run's id, status, uri, consistency, phase (`admitted` | `dequeued`), and concurrencyKey) lists the runs holding the queue's concurrency slots, but the list is never guaranteed exhaustive; `slotHolderFacts` (admittedCount, dequeuedCount, runningReported, truncated, unlistedRunning, consistency) is the server-computed snapshot summary — `truncated` or `unlistedRunning > 0` mean there are holders `slotHolders` doesn't list. When present, `concurrency` (current, base, override, overriddenBy, overriddenAt) distinguishes a temporary override from configured `concurrencyLimit`. When present, `envConcurrency` (limit, current, burstFactor) is the environment-wide dequeue gate: the environment saturates at `current >= limit * burstFactor`, not at `current >= limit` (burstFactor defaults to 2, so headroom above the plain limit is often still open) — and `current` is the last-displayed dequeued count, which can lag the number actually gating dequeues. Use these three fields together before naming the environment as the bottleneck; never infer that from throttledCount alone. All are absent on an older API rather than empty. A holder's phase `admitted` (not yet `dequeued`) may legitimately be pending, not a mismatch. Consistency \"mismatch\" on a holder means the scheduler still counts it as a holder though its run state disagrees; on slotHolderFacts it means the scheduler's own counters disagree right now — prefer those facts to comparing runningNow yourself. Call a holder \"leaked\" or \"stale\" ONLY when both are observed this turn — its run state is terminal (or not found) AND the scheduler still holds the slot; from counters alone, never. Consistency `unresolved` means the run id is citable but its state, and slotHolderFacts' counts, are not — don't assert either. Never assert a run is currently executing from runningNow or concurrencyLimit alone, and never say holders are unaccounted for beyond what truncated/unlistedRunning/consistency actually state — 'nothing holds the slots' is never licensed by an incomplete list.",
+    " When that read fails rather than answers, `exists` is `\"unknown\"` with a `liveStateError`: the queue's state is unknown, not missing. For a custom queue it also carries `consumerTasks`: the deployed tasks whose queue config names this queue. When present, `slotHolders` (each run's id, status, uri, consistency, phase (`admitted` | `dequeued`), and concurrencyKey) lists the runs holding the queue's concurrency slots, but the list is never guaranteed exhaustive; `slotHolderFacts` (admittedCount, dequeuedCount, runningReported, truncated, unlistedRunning, counterAgreement, ckAdmittedMayBeUnlisted) is the server-computed snapshot summary — `truncated` or `unlistedRunning > 0` mean there are holders `slotHolders` doesn't list. `ckAdmittedMayBeUnlisted` is always true: a holder admitted under a concurrency key with nothing backlogged is never listed or counted, so an all-zero holder list is not proof the queue is idle. When present, `concurrency` (current, base, override, overriddenBy, overriddenAt) distinguishes a temporary override from configured `concurrencyLimit`. When present, `envConcurrency` (limit, current, burstFactor, admitted) is the environment-wide dequeue gate: the environment saturates at `current >= limit * burstFactor`, not at `current >= limit` (burstFactor defaults to 2, so headroom above the plain limit is often still open) — and `current` is the last-displayed dequeued count, which can lag the number actually gating dequeues. `admitted > current` means the environment holds admitted slots this queue's holder list can't attribute. Use these three fields together before naming the environment as the bottleneck; never infer that from throttledCount alone. All are absent on an older API rather than empty. A holder's phase `admitted` (not yet `dequeued`) may legitimately be pending, not a mismatch. Consistency \"mismatch\" on a holder means the scheduler still counts it as a holder though its run state disagrees; `counterAgreement: \"disagree\"` on slotHolderFacts means the scheduler's own counters disagree right now — prefer those facts to comparing runningNow yourself. Call a holder \"leaked\" or \"stale\" ONLY when both are observed this turn — its run state is terminal (or not found) AND the scheduler still holds the slot; from counters alone, never. `unresolved` (holder consistency, or counterAgreement) means the run id is citable but its state, and slotHolderFacts' counts, are not — don't assert either. Never assert a run is currently executing from runningNow or concurrencyLimit alone, and never say holders are unaccounted for beyond what truncated/unlistedRunning/counterAgreement/ckAdmittedMayBeUnlisted actually state — 'nothing holds the slots' is never licensed by an incomplete list.",
   inputSchema: z.object({
     queue: z
       .string()
 
@@ -1730,6 +1730,13 @@ export class RunEngine {
     return this.runQueue.currentConcurrencyOfEnvironment(environment);
   }
 
+  /** Admitted env-scope slots — the gating count, ahead of the displayed dequeued one. */
+  async admittedConcurrencyOfEnvQueue(
+    environment: MinimalAuthenticatedEnvironment
+  ): Promise<number> {
+    return this.runQueue.operationalCurrentConcurrencyOfEnvironment(environment);
+  }
+
   async lengthOfQueues(
     environment: MinimalAuthenticatedEnvironment,
     queues: string[]
 
@@ -165,7 +165,13 @@ export type QueueSlotHolders = {
   truncated: boolean;
   /** Dequeued holders that provably exist but aren't in the list. */
   unlistedRunning: number;
-  consistency: "consistent" | "mismatch";
+  /** Whether the queue's own counters agree with the enumerated members. */
+  counterAgreement: "agree" | "disagree";
+  /**
+   * Structurally always true: enumeration covers the base queue and backlogged CK variants
+   * only, and any run can carry a concurrency key, so an admitted CK holder can be unlistable.
+   */
+  ckAdmittedMayBeUnlisted: true;
 };
 
 /** Injected queue-metrics stream emitter; all calls are no-ops when metrics are disabled. */
@@ -687,7 +693,8 @@ export class RunQueue {
 
   /**
    * Snapshot of who holds this queue's slots. Never complete: ckIndex only tracks queued
-   * variants, so a drained CK variant's holders are invisible. `consistency` flags drift.
+   * variants, so a drained CK variant's holders are invisible — `ckAdmittedMayBeUnlisted`
+   * states that unconditionally. `counterAgreement` flags drift.
    */
   public async slotHoldersOfQueue(
     env: MinimalAuthenticatedEnvironment,
@@ -729,8 +736,9 @@ export class RunQueue {
       // A CK-variant scan cap also makes the snapshot incomplete, same as a holder-list cap.
       truncated: truncated === 1 || skippedVariants > 0,
       unlistedRunning: Math.max(0, runningReported - dequeuedCount),
-      consistency:
-        dequeuedCount === runningReported && orphanCount === 0 ? "consistent" : "mismatch",
+      counterAgreement:
+        dequeuedCount === runningReported && orphanCount === 0 ? "agree" : "disagree",
+      ckAdmittedMayBeUnlisted: true,
     };
   }
 
 
@@ -101,7 +101,7 @@ describe("RunQueue.slotHoldersOfQueue", () => {
       expect(admitted.runningReported).toBe(0);
       expect(admitted.truncated).toBe(false);
       expect(admitted.unlistedRunning).toBe(0);
-      expect(admitted.consistency).toBe("consistent");
+      expect(admitted.counterAgreement).toBe("agree");
 
       const dequeued = await queue.dequeueMessageFromWorkerQueue("consumer_1", WORKER_QUEUE);
       expect(dequeued?.messageId).toBe("r1");
@@ -111,7 +111,7 @@ describe("RunQueue.slotHoldersOfQueue", () => {
       expect(after.dequeuedCount).toBe(1);
       expect(after.runningReported).toBe(1);
       expect(after.unlistedRunning).toBe(0);
-      expect(after.consistency).toBe("consistent");
+      expect(after.counterAgreement).toBe("agree");
     } finally {
       await queue.quit();
     }
@@ -143,7 +143,7 @@ describe("RunQueue.slotHoldersOfQueue", () => {
       expect(result.runningReported).toBe(1);
       expect(result.truncated).toBe(false);
       expect(result.unlistedRunning).toBe(0);
-      expect(result.consistency).toBe("consistent");
+      expect(result.counterAgreement).toBe("agree");
     } finally {
       await queue.quit();
     }
@@ -167,7 +167,7 @@ describe("RunQueue.slotHoldersOfQueue", () => {
       });
 
       const baseline = await queue.slotHoldersOfQueue(authenticatedEnvDev, QUEUE);
-      expect(baseline.consistency).toBe("consistent");
+      expect(baseline.counterAgreement).toBe("agree");
 
       // Control break: the counter no longer matches the enumerated members.
       await queue.redis.set(
@@ -176,7 +176,7 @@ describe("RunQueue.slotHoldersOfQueue", () => {
       );
 
       const broken = await queue.slotHoldersOfQueue(authenticatedEnvDev, QUEUE);
-      expect(broken.consistency).toBe("mismatch");
+      expect(broken.counterAgreement).toBe("disagree");
       expect(broken.holders).toEqual([{ runId: "r1", concurrencyKey: "ck-a", phase: "admitted" }]);
       expect(broken.runningReported).toBe(7);
       expect(broken.unlistedRunning).toBe(7);
@@ -204,41 +204,45 @@ describe("RunQueue.slotHoldersOfQueue", () => {
         expect(result.holders).toEqual([]);
         expect(result.runningReported).toBe(1);
         expect(result.unlistedRunning).toBe(1);
-        expect(result.consistency).toBe("mismatch");
+        expect(result.counterAgreement).toBe("disagree");
       } finally {
         await queue.quit();
       }
     }
   );
 
-  redisTest("a lone fast-path CK holder is simply not listed", async ({ redisContainer }) => {
-    const queue = createQueue(redisContainer);
-    try {
-      // Nothing queued on the variant means no ckIndex entry, so this holder can't be
-      // enumerated. No field claims otherwise — the payload just doesn't mention it.
-      await queue.enqueueMessage({
-        env: authenticatedEnvDev,
-        message: makeMessage({ runId: "r1", concurrencyKey: "ck-a" }),
-        workerQueue: WORKER_QUEUE,
-        skipDequeueProcessing: true,
-        enableFastPath: true,
-      });
+  redisTest(
+    "a lone fast-path CK holder is not listed, and the payload says so",
+    async ({ redisContainer }) => {
+      const queue = createQueue(redisContainer);
+      try {
+        // Nothing queued on the variant means no ckIndex entry, so this holder can't be
+        // enumerated. `ckAdmittedMayBeUnlisted` is what stops the zeroes reading as "idle".
+        await queue.enqueueMessage({
+          env: authenticatedEnvDev,
+          message: makeMessage({ runId: "r1", concurrencyKey: "ck-a" }),
+          workerQueue: WORKER_QUEUE,
+          skipDequeueProcessing: true,
+          enableFastPath: true,
+        });
 
-      const result = await queue.slotHoldersOfQueue(authenticatedEnvDev, QUEUE);
-      expect(result).toEqual({
-        holders: [],
-        admittedCount: 0,
-        dequeuedCount: 0,
-        runningReported: 0,
-        truncated: false,
-        unlistedRunning: 0,
-        consistency: "consistent",
-      });
-      expect(result).not.toHaveProperty("holderResolution");
-    } finally {
-      await queue.quit();
+        const result = await queue.slotHoldersOfQueue(authenticatedEnvDev, QUEUE);
+        expect(result).toEqual({
+          holders: [],
+          admittedCount: 0,
+          dequeuedCount: 0,
+          runningReported: 0,
+          truncated: false,
+          unlistedRunning: 0,
+          counterAgreement: "agree",
+          ckAdmittedMayBeUnlisted: true,
+        });
+        expect(result).not.toHaveProperty("holderResolution");
+      } finally {
+        await queue.quit();
+      }
     }
-  });
+  );
 
   redisTest("caps the holder list and reports it as truncated", async ({ redisContainer }) => {
     const queue = createQueue(redisContainer);