@@ -5,11 +5,11 @@ import {
   ASK_DIRECTOR_MAX_QUESTIONS,
   commitAskDirector,
   createAskDirectorState,
+  createDeferredContinuation,
   evaluateAskDirector,
   handleAskDirector,
   releaseAskDirector,
   resetAskDirectorTurn,
-  skipStallContinuationWhileAskPending,
 } from "./ask-director.js";
 
 describe("evaluateAskDirector", () => {
@@ -207,18 +207,43 @@ describe("evaluateAskDirector", () => {
 describe("requestContinuation stall skip", () => {
   test("is a no-op while askDirectorState.pending", () => {
     const state = createAskDirectorState();
+    const latch = createDeferredContinuation();
     let delivered = 0;
-    skipStallContinuationWhileAskPending(state, () => {
+    const deliver = () => {
       delivered += 1;
-    });
+    };
+    latch.request(state, deliver);
     expect(delivered).toBe(1);
 
     expect(evaluateAskDirector({ question: "which file?", state }).ok).toBe(
       true,
     );
-    skipStallContinuationWhileAskPending(state, () => {
+    latch.request(state, deliver);
+    expect(delivered).toBe(1);
+  });
+
+  test("ask-pending skip defers compact continuation until the ask releases", () => {
+    const state = createAskDirectorState();
+    const latch = createDeferredContinuation();
+    let delivered = 0;
+    const deliver = () => {
       delivered += 1;
-    });
+    };
+
+    expect(evaluateAskDirector({ question: "which file?", state }).ok).toBe(
+      true,
+    );
+    latch.request(state, deliver);
+    expect(delivered).toBe(0);
+
+    latch.flush(state, deliver);
+    expect(delivered).toBe(0);
+
+    releaseAskDirector(state);
+    latch.flush(state, deliver);
+    expect(delivered).toBe(1);
+
+    latch.flush(state, deliver);
     expect(delivered).toBe(1);
   });
 });
 
@@ -89,15 +89,30 @@ export function resetAskDirectorTurn(state: AskDirectorState): void {
 }
 
 /**
- * Waiting on the spawning director is work, not silence. A stall ping
- * would otherwise salvage a blocked ask_director as stalled.
+ * Compact continuation shares the stall ping channel. Skipping while
+ * ask_director is parked must not drop the only continue: remember the skip
+ * and flush after the ask releases.
  */
-export function skipStallContinuationWhileAskPending(
-  state: AskDirectorState,
-  deliver: () => void,
-): void {
-  if (state.pending) return;
-  deliver();
+export function createDeferredContinuation(): {
+  request: (state: AskDirectorState, deliver: () => void) => void;
+  flush: (state: AskDirectorState, deliver: () => void) => void;
+} {
+  let deferred = false;
+  return {
+    request(state, deliver) {
+      if (state.pending) {
+        deferred = true;
+        return;
+      }
+      deferred = false;
+      deliver();
+    },
+    flush(state, deliver) {
+      if (!deferred || state.pending) return;
+      deferred = false;
+      deliver();
+    },
+  };
 }
 
 export async function handleAskDirector(args: {
 
@@ -152,9 +152,9 @@ import {
   ASK_DIRECTOR_MAX_BYTES,
   ASK_DIRECTOR_MAX_QUESTIONS,
   createAskDirectorState,
+  createDeferredContinuation,
   handleAskDirector,
   resetAskDirectorTurn,
-  skipStallContinuationWhileAskPending,
 } from "./ask-director.js";
 import {
   abortError,
@@ -625,6 +625,8 @@ async function runSubAgentInner(
   let turnToken = params.tier === "leaf" ? generateSessionId() : undefined;
   const submitResultState = createSubmitResultState();
   const askDirectorState = createAskDirectorState();
+  const compactContinue = createDeferredContinuation();
+  let deliverCompactContinue = (): void => undefined;
   const spawnRegistry = createSubAgentSpawnRegistryPlugin();
   // Assigned inside the try once the agent handle exists; before that (or after
   // close) a completion is dropped, matching the continuation contract.
@@ -862,12 +864,16 @@ async function runSubAgentInner(
                 "Record the question under Blockers and finish with the markdown report envelope."
               );
             }
-            return handleAskDirector({
-              question: rawArgs.question,
-              state: askDirectorState,
-              port,
-              signal,
-            });
+            try {
+              return await handleAskDirector({
+                question: rawArgs.question,
+                state: askDirectorState,
+                port,
+                signal,
+              });
+            } finally {
+              compactContinue.flush(askDirectorState, deliverCompactContinue);
+            }
           },
         }),
       ];
@@ -1038,13 +1044,14 @@ async function runSubAgentInner(
       ReturnType<typeof createAgentWithLiveToolDispatch>
     > | null = null;
     const requestContinuation = (): void => {
-      skipStallContinuationWhileAskPending(askDirectorState, () => {
-        try {
-          agentHandle?.deliver(buildCompactionContinuationMessage());
-        } catch {
-          // Agent may be closing; a dropped continuation is harmless.
-        }
-      });
+      compactContinue.request(askDirectorState, deliverCompactContinue);
+    };
+    deliverCompactContinue = (): void => {
+      try {
+        agentHandle?.deliver(buildCompactionContinuationMessage());
+      } catch {
+        // Agent may be closing; a dropped continuation is harmless.
+      }
     };
 
     // modelFamilyPolicy is resolved above at the skill mount so the
 
@@ -4,6 +4,7 @@ import {
   deliverAgentMessage,
   deliveryResultNotice,
   runGenerationGuardedDeliver,
+  settleCompactionContinuationHop,
 } from "./delivery-queue.js";
 
 describe("deliverAgentMessage", () => {
@@ -125,6 +126,57 @@ describe("runGenerationGuardedDeliver", () => {
   });
 });
 
+describe("settleCompactionContinuationHop", () => {
+  test("a superseded hop re-issues the continue against the live agent", async () => {
+    let generation = 1;
+    const stillCurrent = () => generation === 1;
+    let delivered = 0;
+    generation = 2;
+    const result = await settleCompactionContinuationHop({
+      stillCurrent,
+      deliver: async () => {
+        delivered += 1;
+        return { status: "accepted" as const };
+      },
+    });
+    expect(result).toEqual({ status: "accepted" });
+    expect(delivered).toBe(1);
+  });
+
+  test("a closed hop re-issues the continue once", async () => {
+    let attempts = 0;
+    const result = await settleCompactionContinuationHop({
+      stillCurrent: () => true,
+      deliver: async () => {
+        attempts += 1;
+        if (attempts === 1) {
+          return {
+            status: "not-delivered" as const,
+            reason: "agent-closed" as const,
+            detail: "agent is closed",
+          };
+        }
+        return { status: "accepted" as const };
+      },
+    });
+    expect(result).toEqual({ status: "accepted" });
+    expect(attempts).toBe(2);
+  });
+
+  test("a current hop delivers once and does not re-issue", async () => {
+    let runs = 0;
+    const result = await settleCompactionContinuationHop({
+      stillCurrent: () => true,
+      deliver: async () => {
+        runs += 1;
+        return { status: "accepted" as const };
+      },
+    });
+    expect(result).toEqual({ status: "accepted" });
+    expect(runs).toBe(1);
+  });
+});
+
 describe("deliveryResultNotice", () => {
   test("closed restored and deferred copy is actionable", () => {
     const closed = {
 
@@ -104,6 +104,39 @@ export async function runGenerationGuardedDeliver(options: {
   return options.run();
 }
 
+function compactionContinuationShouldReissue(
+  result: AgentDeliveryResult,
+): boolean {
+  return (
+    result.status === "not-delivered" &&
+    (result.reason === "superseded" || result.reason === "agent-closed")
+  );
+}
+
+/**
+ * Compact continuation is consume-once at the stream gate, so a superseded or
+ * closed hop must re-issue in the same serial op — otherwise the only continue
+ * is dropped and the reactor idles.
+ */
+export async function settleCompactionContinuationHop(options: {
+  stillCurrent: () => boolean;
+  deliver: () => Promise<AgentDeliveryResult>;
+}): Promise<AgentDeliveryResult> {
+  const first = await runGenerationGuardedDeliver({
+    stillCurrent: options.stillCurrent,
+    onStale: () => ({
+      status: "not-delivered",
+      reason: "superseded",
+      detail: "session identity changed before delivery",
+    }),
+    run: options.deliver,
+  });
+  if (compactionContinuationShouldReissue(first)) {
+    return options.deliver();
+  }
+  return first;
+}
+
 /** Operator-facing copy for a settled delivery that did not accept. */
 export function deliveryResultNotice(
   result: Exclude<AgentDeliveryResult, { status: "accepted" }>,
 
@@ -325,11 +325,12 @@ export async function createRunLifecycle(
       // the same message the old requestContinuation closure delivered,
       // through the serial op queue like every other deliver. Each emission
       // is answered once: a replayed duplicate of an already-answered
-      // emission is ignored instead of re-delivered.
+      // emission is ignored instead of re-delivered. A superseded or closed
+      // hop re-issues in the same op so consume-once cannot drop the only
+      // continue.
       if (continuationGate.shouldDeliver(event.seq)) {
-        const targetAgent = liveAgent(state);
-        state.enqueueAgentDeliver?.(() =>
-          targetAgent.deliver(buildCompactionContinuationMessage()),
+        state.enqueueCompactionContinuation?.(() =>
+          liveAgent(state).deliver(buildCompactionContinuationMessage()),
         );
       }
     }
 
@@ -82,6 +82,7 @@ import {
   deliverAgentMessage,
   deliveryResultNotice,
   runGenerationGuardedDeliver,
+  settleCompactionContinuationHop,
   type AgentDeliveryResult,
 } from "../delivery-queue.js";
 import { createCorrelationAcceptance } from "../correlation-acceptance.js";
@@ -568,6 +569,23 @@ export async function assembleTUISession(
       state.systemNotice?.(deliveryResultNotice(result));
     });
   };
+  state.enqueueCompactionContinuation = (
+    deliverToLiveAgent: () => void,
+  ): void => {
+    const stillCurrent = deliveryGeneration.capture();
+    void sessionOps.enqueue(async () => {
+      const result = await settleCompactionContinuationHop({
+        stillCurrent,
+        deliver: () =>
+          deliverAgentMessage({
+            getFatalBuildError: () => state.fatalBuildError,
+            deliverToLiveAgent,
+          }),
+      });
+      if (result.status === "accepted") return;
+      state.systemNotice?.(deliveryResultNotice(result));
+    });
+  };
 
   const buildSessionSources = (): LiveSessionSources =>
     resolveLiveSessionSources(state.config, state.sessionId);
 
@@ -257,6 +257,7 @@ export interface RunnerState {
     deliverToLiveAgent: () => void,
     onSettle?: (result: AgentDeliveryResult) => void,
   ) => void;
+  enqueueCompactionContinuation?: (deliverToLiveAgent: () => void) => void;
   reloadIfIdle?: () => void;
   systemNotice?: (text: string) => void;
   currentAttemptIdentity?: () => InferenceAttemptIdentity;