fix(tui): claim the primary turn for occupancy before ask wake

Mailbox mail collect is async, so isProcessing is still false
while occupancy already owns the slot. A shared mail-then-wake
guard uses the latch claim so ask-wake cannot send on that stack.

Author: TheGreatAxios

src/subagent/mailbox-mail-drive.test.ts

@@ -132,7 +132,7 @@ describe("driveMailboxMail", () => {
       }),
     ).toBe(false);
     expect(
-      await driveMailboxMail({
+      driveMailboxMail({
         parentProcessing: false,
         mailbox: mapMailbox(new Map()),
         lanes: [],
@@ -315,7 +315,7 @@ describe("driveMailboxMail", () => {
       ["live", { status: "running" }],
     ]);
     expect(
-      await driveMailboxMail({
+      driveMailboxMail({
         parentProcessing: false,
         mailbox: mapMailbox(records),
         lanes: [],
@@ -329,6 +329,28 @@ describe("driveMailboxMail", () => {
     ).toBe(false);
   });
 
+  test("does not begin if the parent starts processing during collect", async () => {
+    const records = new Map<string, FleetDryMailboxRecord>([
+      ["w1", { status: "done", report: "ok" }],
+    ]);
+    let processing = false;
+    const driven = driveMailboxMail({
+      parentProcessing: false,
+      isParentProcessing: () => processing,
+      mailbox: mapMailbox(records),
+      lanes: [],
+      beginSystemContinuation: () => {
+        throw new Error("must not begin");
+      },
+      send: () => {
+        throw new Error("must not send");
+      },
+    });
+    processing = true;
+    expect(await driven).toBe(false);
+    expect(records.get("w1")?.collected).not.toBe(true);
+  });
+
   test("not-delivered send leaves the wake retryable", async () => {
     const records = new Map<string, FleetDryMailboxRecord>([
       ["w1", { status: "done", report: "ok" }],
@@ -395,8 +417,10 @@ describe("latchMailboxMailDrive", () => {
       }),
     );
     expect(driver()).toBe(true);
+    expect(driver.claimed()).toBe(true);
     expect(driver()).toBe(false);
     expect(driver()).toBe(false);
+    expect(driver.claimed()).toBe(true);
     await sent;
     expect(sends).toHaveLength(1);
     expect(sends[0]).toContain(MAILBOX_MAIL_WAKE_PREFIX);
@@ -410,9 +434,28 @@ describe("latchMailboxMailDrive", () => {
     });
     expect(driver()).toBe(false);
     expect(driver()).toBe(false);
+    expect(driver.claimed()).toBe(false);
     expect(calls).toBe(2);
   });
 
+  test("an empty mailbox does not claim the occupancy slot", () => {
+    const driver = latchMailboxMailDrive(() =>
+      driveMailboxMail({
+        parentProcessing: false,
+        mailbox: mapMailbox(new Map()),
+        lanes: [],
+        beginSystemContinuation: () => {
+          throw new Error("must not begin");
+        },
+        send: () => {
+          throw new Error("must not send");
+        },
+      }),
+    );
+    expect(driver()).toBe(false);
+    expect(driver.claimed()).toBe(false);
+  });
+
   test("after the in-flight drive settles, a new terminal can send", async () => {
     const records = new Map<string, FleetDryMailboxRecord>([
       ["first", { status: "done", report: "one" }],

src/subagent/mailbox-mail-drive.ts

@@ -109,16 +109,41 @@ export function buildMailboxMailPrompt(
   return [mailboxMailWakeLine(), JSON.stringify(reports)].join("\n");
 }
 
+function hasDeliverableMailboxMail(
+  mailbox: FleetDryMailbox | undefined,
+): boolean {
+  if (mailbox === undefined) return false;
+  const delivering = deliveringByMailbox.get(mailbox);
+  for (const id of mailbox.ids()) {
+    if (delivering?.has(id)) continue;
+    const record = mailbox.peek(id);
+    if (record === undefined || record.collected === true) continue;
+    if (isLiveWaitStatus(record.status)) continue;
+    return true;
+  }
+  return false;
+}
+
+function parentIsProcessing(args: {
+  parentProcessing: boolean;
+  isParentProcessing?: () => boolean;
+}): boolean {
+  return args.isParentProcessing?.() ?? args.parentProcessing;
+}
+
 export function driveMailboxMail(args: {
   parentProcessing: boolean;
+  /** Live check after awaited collect; occupancy must not start a turn already claimed. */
+  isParentProcessing?: () => boolean;
   mailbox: FleetDryMailbox | undefined;
   lanes: readonly FleetDryLane[];
   writeBlob?: FleetDryBlobWriter;
   beginSystemContinuation: (prompt: string) => void;
   send: (prompt: string) => unknown;
   onSendFailure?: () => void;
 }): boolean | Promise<boolean> {
-  if (args.parentProcessing) return false;
+  if (parentIsProcessing(args)) return false;
+  if (!hasDeliverableMailboxMail(args.mailbox)) return false;
   return driveMailboxMailAfterCollect(args);
 }
 
@@ -138,6 +163,7 @@ async function driveMailboxMailAfterCollect(
     )
   ).filter((report) => !delivering.has(report.agent_id));
   if (reports.length === 0) return false;
+  if (parentIsProcessing(args)) return false;
   const ids = reports.map((report) => report.agent_id);
   for (const id of ids) delivering.add(id);
   const prompt = buildMailboxMailPrompt(reports);
@@ -169,12 +195,28 @@ async function driveMailboxMailAfterCollect(
  * mail. `driveMailboxMail` does not mark the parent busy until after an
  * awaited collect, so overlapping flushes would each call `send()` and fill
  * the agent's depth-16 queue. Hold one drive until that promise settles.
+ *
+ * `flush()` is true only when this call starts a drive. `claimed()` is true
+ * while that drive owns the slot — ask-wake admission uses it so a wake
+ * cannot send on the same stack, or on a later stack before collect lands.
  */
+export type MailboxMailFlush = (() => boolean) & {
+  readonly claimed: () => boolean;
+};
+
+export function mailboxMailDriveClaimed(
+  flush: (() => boolean) | undefined,
+): boolean {
+  if (flush === undefined) return false;
+  const claimed = (flush as MailboxMailFlush).claimed;
+  return typeof claimed === "function" && claimed() === true;
+}
+
 export function latchMailboxMailDrive(
   drive: () => boolean | Promise<boolean>,
-): () => boolean {
+): MailboxMailFlush {
   let inFlight = false;
-  return () => {
+  const flush = (): boolean => {
     if (inFlight) return false;
     const driven = drive();
     if (driven === false) return false;
@@ -184,4 +226,5 @@ export function latchMailboxMailDrive(
     });
     return true;
   };
+  return Object.assign(flush, { claimed: () => inFlight });
 }

src/tui/agent-ask-wake.test.ts

@@ -4,6 +4,7 @@ import { createLiveSessionPort } from "./live-session-port";
 import { createAppShell } from "./shell/index";
 import { withTestRenderer } from "./harness";
 import type { PendingAskWake } from "../subagent/fleet-report.js";
+import { latchMailboxMailDrive } from "../subagent/mailbox-mail-drive.js";
 import { classifySubmission, createSubmitHandler } from "./runner/submit.js";
 import {
   createDeliveryGeneration,
@@ -33,7 +34,7 @@ async function withWakeBridge(
   run: (
     bridge: ReturnType<typeof attachSessionBridge>,
     sends: string[],
-  ) => void,
+  ) => void | Promise<void>,
 ) {
   await withTestRenderer(
     async (h) => {
@@ -55,7 +56,7 @@ async function withWakeBridge(
         }),
       );
       try {
-        run(bridge, sends);
+        await run(bridge, sends);
       } finally {
         bridge.dispose();
         shell.dispose();
@@ -65,6 +66,22 @@ async function withWakeBridge(
   );
 }
 
+function latchAsyncMailboxMail(
+  bridge: ReturnType<typeof attachSessionBridge>,
+  order: string[],
+  hold: Promise<void>,
+) {
+  return latchMailboxMailDrive(() => {
+    order.push("mail");
+    return (async () => {
+      await hold;
+      order.push("begin");
+      bridge.beginSystemContinuation("mailbox occupancy");
+      return true;
+    })();
+  });
+}
+
 for (const action of [
   "retry",
   "interrupt",
@@ -485,6 +502,120 @@ describe("agent ask wake delivery", () => {
     });
   });
 
+  test("async mailbox drive on gate close claims the slot before wake (CL-8061)", async () => {
+    await withWakeBridge(async (bridge, sends) => {
+      const order: string[] = [];
+      let release: () => void = () => undefined;
+      const hold = new Promise<void>((resolve) => {
+        release = resolve;
+      });
+      bridge.setOnAskWakeSent(() => {
+        order.push("wake");
+      });
+      bridge.setMailboxMailDriver(latchAsyncMailboxMail(bridge, order, hold));
+      bridge.gateOpened();
+      bridge.handle({ type: "agent-ask", asks: [wake("a1", "q1")] });
+      expect(sends).toEqual([]);
+      bridge.gateClosed();
+      expect(order).toEqual(["mail"]);
+      expect(sends).toEqual([]);
+      expect(bridge.turn.isProcessing).toBe(false);
+      release();
+      await hold;
+      await Promise.resolve();
+      await Promise.resolve();
+      expect(order).toEqual(["mail", "begin"]);
+      expect(bridge.turn.isProcessing).toBe(true);
+      expect(sends).toEqual([]);
+    });
+  });
+
+  test("async mailbox drive on idle-with-fleet settle claims the slot before wake (CL-8061)", async () => {
+    await withWakeBridge(async (bridge, sends) => {
+      const order: string[] = [];
+      let release: () => void = () => undefined;
+      const hold = new Promise<void>((resolve) => {
+        release = resolve;
+      });
+      bridge.setOnAskWakeSent(() => {
+        order.push("wake");
+      });
+      bridge.setMailboxMailDriver(latchAsyncMailboxMail(bridge, order, hold));
+      bridge.handle({ type: "inference.start", data: {} });
+      bridge.handle({ type: "fleet", running: 1 });
+      bridge.handle({ type: "agent-ask", asks: [wake("a1", "q1")] });
+      expect(sends).toEqual([]);
+      bridge.handle({ type: "inference.done", data: {} });
+      expect(order).toEqual(["mail"]);
+      expect(sends).toEqual([]);
+      expect(bridge.turn.isProcessing).toBe(false);
+      release();
+      await hold;
+      await Promise.resolve();
+      await Promise.resolve();
+      expect(order).toEqual(["mail", "begin"]);
+      expect(bridge.turn.isProcessing).toBe(true);
+      expect(sends).toEqual([]);
+    });
+  });
+
+  test("releaseRunToIdle flushes mailbox mail before the ask wake (CL-8061)", async () => {
+    await withWakeBridge((bridge, sends) => {
+      const order: string[] = [];
+      bridge.setOnAskWakeSent(() => {
+        order.push("wake");
+      });
+      bridge.setMailboxMailDriver(() => {
+        order.push("mail");
+        return false;
+      });
+      bridge.handle({ type: "inference.start", data: {} });
+      bridge.handle({ type: "agent-ask", asks: [wake("a1", "q1")] });
+      expect(sends).toEqual([]);
+      bridge.handle({ type: "inference.done", data: {} });
+      expect(order).toEqual(["mail", "wake"]);
+      expect(sends).toHaveLength(1);
+    });
+  });
+
+  test("releaseRunToIdle suppresses the wake when mail takes the turn (CL-8061)", async () => {
+    await withWakeBridge((bridge, sends) => {
+      const order: string[] = [];
+      bridge.setOnAskWakeSent(() => {
+        order.push("wake");
+      });
+      bridge.setMailboxMailDriver(() => {
+        order.push("mail");
+        bridge.beginSystemContinuation("mailbox occupancy");
+        return true;
+      });
+      bridge.handle({ type: "inference.start", data: {} });
+      bridge.handle({ type: "agent-ask", asks: [wake("a1", "q1")] });
+      expect(sends).toEqual([]);
+      bridge.handle({ type: "inference.done", data: {} });
+      expect(order).toEqual(["mail"]);
+      expect(sends).toEqual([]);
+    });
+  });
+
+  test("idle parent subscribe does not flush wake before mailbox mail (CL-8061)", async () => {
+    await withWakeBridge((bridge, sends) => {
+      const order: string[] = [];
+      bridge.setOnAskWakeSent(() => {
+        order.push("wake");
+      });
+      bridge.setMailboxMailDriver(() => {
+        order.push("mail");
+        bridge.beginSystemContinuation("mailbox occupancy");
+        return true;
+      });
+      bridge.handle({ type: "agent-ask", asks: [wake("a1", "q1")] });
+      expect(order).toEqual(["mail"]);
+      expect(sends).toEqual([]);
+      expect(bridge.turn.isProcessing).toBe(true);
+    });
+  });
+
   test("clearQueuedDelivery drops stashed wakes and resets delivered identities", async () => {
     await withWakeBridge((bridge, sends) => {
       bridge.handle({ type: "inference.start", data: {} });

src/tui/runner/wiring.ts

@@ -362,6 +362,7 @@ export function wirePostStartup(
       const storage = state.currentStorage;
       return driveMailboxMail({
         parentProcessing: sessionBridge.turn.isProcessing,
+        isParentProcessing: () => sessionBridge.turn.isProcessing,
         mailbox: services.toolset.fleetRecords,
         lanes: services.subAgentSessions.list(),
         ...(storage !== null