@bastani/atomic 0.9.11-alpha.4 → 0.9.11-alpha.6

package/dist/builtin/workflows/src/runs/foreground/stage-control-registry.ts

@@ -64,10 +64,15 @@ export interface StageControlHandle {
   pendingToolExecutionEvents?(): readonly AgentSessionEvent[];
   /** Ensure the SDK session exists. Cheap when already attached. */
   ensureAttached(): Promise<void>;
-  /** Deliver through the idle-aware session primitive and report the actual action. */
+  /**
+   * Deliver through the idle-aware session primitive and report the action.
+   * `beforeDelivery` must run synchronously after async setup and immediately
+   * before the underlying SDK admits or queues the message.
+   */
   sendUserMessage?(
     text: string,
     options?: { readonly deliverAs?: "steer" | "followUp" },
+    beforeDelivery?: () => void,
   ): Promise<StageUserMessageDeliveryAction>;
 
   /** Send a prompt. Use only when the stage is idle / not streaming. */
@@ -84,9 +89,9 @@ export interface StageControlHandle {
   pause(): Promise<void>;
   /**
    * Release a paused stage. If `message` is provided it is sent as the
-   * next user message before resuming.
+   * next user message before resuming. `beforeResume` guards final admission.
    */
-  resume(message?: string): Promise<void | StageUserMessageDeliveryAction>;
+  resume(message?: string, beforeResume?: () => void): Promise<void | StageUserMessageDeliveryAction>;
   /**
    * Subscribe to AgentSession events. The pending-listener semantics
    * from `InternalStageContext.subscribe` apply: listeners registered
@@ -97,6 +102,15 @@ export interface StageControlHandle {
   dispose?(): void | Promise<void>;
 }
 
+/** Tentative ownership used by workflow sends until final message admission. */
+export interface DetachedStageHandleLease {
+  readonly handle: StageControlHandle;
+  /** Keep the handle registered after admission; false when it was displaced. */
+  commit(): boolean;
+  /** Release tentative ownership and dispose an unclaimed provisional handle. */
+  release(): Promise<void>;
+}
+
 /**
  * Per-run aggregate. Fans pause/resume to currently-running stage
  * handles. Backed by the same `StageControlRegistry`.
@@ -142,12 +156,26 @@ export interface StageControlRegistry {
     stageId: string,
     create: () => StageControlHandle,
   ): StageControlHandle;
+  /**
+   * Acquire tentative ownership of a detached handle. A newly-created handle
+   * stays provisional until one lease commits or an ordinary consumer claims
+   * it through `claim()` / `getOrCreateDetached()`.
+   */
+  acquireDetached(
+    runId: string,
+    stageId: string,
+    create: () => StageControlHandle,
+  ): DetachedStageHandleLease;
+  /** Inspect without claiming a provisional detached handle. */
+  peek(runId: string, stageId: string): StageControlHandle | undefined;
+  /** Resolve and permanently claim a provisional detached handle. */
+  claim(runId: string, stageId: string): StageControlHandle | undefined;
   /**
    * Remove this stage from run-level pause/resume aggregates while keeping
    * `get()` chat attachment live until the registration disposer runs.
    */
   detachControl(runId: string, stageId: string, handle?: StageControlHandle): boolean;
-  /** Resolve a single stage handle by run + stage id, including detached chats. */
+  /** Resolve one stage handle by run + stage id, including detached chats. */
   get(runId: string, stageId: string): StageControlHandle | undefined;
   /** Resolve all currently-registered chat handles for a run. */
   forRun(runId: string): readonly StageControlHandle[];
@@ -169,6 +197,9 @@ export function createStageControlRegistry(): StageControlRegistry {
   type RegistryEntry = {
     handle: StageControlHandle;
     controlsDependencies: boolean;
+    permanent: boolean;
+    readonly leases: Set<symbol>;
+    disposal?: Promise<void>;
   };
 
   const _byRun = new Map<string, Map<string, RegistryEntry>>();
@@ -188,6 +219,20 @@ export function createStageControlRegistry(): StageControlRegistry {
     return [...runMap.values()].filter((entry) => entry.controlsDependencies);
   }
 
+  function disposeEntry(entry: RegistryEntry): Promise<void> {
+    if (entry.disposal !== undefined) return entry.disposal;
+    try {
+      entry.disposal = Promise.resolve(entry.handle.dispose?.());
+    } catch (error) {
+      entry.disposal = Promise.reject(error);
+    }
+    return entry.disposal;
+  }
+
+  function disposeEntryInBackground(entry: RegistryEntry, message: string): void {
+    void disposeEntry(entry).catch((err: unknown) => console.warn(message, err));
+  }
+
   function makeRunHandle(runId: string): WorkflowRunControlHandle {
     return {
       runId,
@@ -261,7 +306,19 @@ export function createStageControlRegistry(): StageControlRegistry {
   return {
     register(handle: StageControlHandle): () => void {
       const runMap = ensureRun(handle.runId);
-      runMap.set(handle.stageId, { handle, controlsDependencies: true });
+      const displaced = runMap.get(handle.stageId);
+      runMap.set(handle.stageId, {
+        handle,
+        controlsDependencies: true,
+        permanent: true,
+        leases: new Set(),
+      });
+      if (displaced !== undefined && displaced.handle !== handle && !displaced.permanent) {
+        disposeEntryInBackground(
+          displaced,
+          "atomic-workflows: displaced provisional stage handle dispose failed",
+        );
+      }
       return () => {
         const existing = _byRun.get(handle.runId);
         if (!existing) return;
@@ -278,17 +335,75 @@ export function createStageControlRegistry(): StageControlRegistry {
     ): StageControlHandle {
       const runMap = ensureRun(runId);
       const existing = runMap.get(stageId);
-      if (existing !== undefined && existing.handle.isDisposed !== true) return existing.handle;
+      if (existing !== undefined && existing.handle.isDisposed !== true) {
+        existing.permanent = true;
+        return existing.handle;
+      }
       if (existing !== undefined) {
         runMap.delete(stageId);
-        void Promise.resolve(existing.handle.dispose?.()).catch((err: unknown) => {
-          console.warn("atomic-workflows: stale stage handle dispose failed", err);
-        });
+        disposeEntryInBackground(existing, "atomic-workflows: stale stage handle dispose failed");
       }
       const handle = create();
-      runMap.set(handle.stageId, { handle, controlsDependencies: false });
+      runMap.set(handle.stageId, {
+        handle,
+        controlsDependencies: false,
+        permanent: true,
+        leases: new Set(),
+      });
       return handle;
     },
+    acquireDetached(
+      runId: string,
+      stageId: string,
+      create: () => StageControlHandle,
+    ): DetachedStageHandleLease {
+      const runMap = ensureRun(runId);
+      let entry = runMap.get(stageId);
+      if (entry?.handle.isDisposed === true) {
+        runMap.delete(stageId);
+        disposeEntryInBackground(entry, "atomic-workflows: stale stage handle dispose failed");
+        entry = undefined;
+      }
+      if (entry === undefined) {
+        entry = {
+          handle: create(),
+          controlsDependencies: false,
+          permanent: false,
+          leases: new Set(),
+        };
+        runMap.set(stageId, entry);
+      }
+      const leasedEntry = entry;
+      const token = Symbol("detached-stage-handle-lease");
+      leasedEntry.leases.add(token);
+      let settled = false;
+      return {
+        handle: leasedEntry.handle,
+        commit() {
+          if (settled) return false;
+          if (runMap.get(stageId) !== leasedEntry || leasedEntry.disposal !== undefined) {
+            return false;
+          }
+          settled = true;
+          leasedEntry.leases.delete(token);
+          leasedEntry.permanent = true;
+          return true;
+        },
+        async release() {
+          if (settled) return;
+          settled = true;
+          leasedEntry.leases.delete(token);
+          if (runMap.get(stageId) !== leasedEntry) {
+            if (leasedEntry.disposal !== undefined) await leasedEntry.disposal;
+            return;
+          }
+          if (leasedEntry.permanent || leasedEntry.leases.size > 0) return;
+          runMap.delete(stageId);
+          if (runMap.size === 0) _byRun.delete(runId);
+          await disposeEntry(leasedEntry);
+        },
+      };
+    },
     detachControl(runId: string, stageId: string, handle?: StageControlHandle): boolean {
       const entry = _byRun.get(runId)?.get(stageId);
       if (!entry) return false;
@@ -297,6 +412,14 @@ export function createStageControlRegistry(): StageControlRegistry {
       entry.controlsDependencies = false;
       return true;
     },
+    peek(runId: string, stageId: string): StageControlHandle | undefined {
+      return _byRun.get(runId)?.get(stageId)?.handle;
+    },
+    claim(runId: string, stageId: string): StageControlHandle | undefined {
+      const entry = _byRun.get(runId)?.get(stageId);
+      if (entry !== undefined) entry.permanent = true;
+      return entry?.handle;
+    },
     get(runId: string, stageId: string): StageControlHandle | undefined {
       return _byRun.get(runId)?.get(stageId)?.handle;
     },
@@ -309,14 +432,10 @@ export function createStageControlRegistry(): StageControlRegistry {
       return makeRunHandle(runId);
     },
     clear(): void {
-      const handles = [..._byRun.values()].flatMap((runMap) =>
-        [...runMap.values()].map((entry) => entry.handle),
-      );
+      const entries = [..._byRun.values()].flatMap((runMap) => [...runMap.values()]);
       _byRun.clear();
-      for (const handle of handles) {
-        void Promise.resolve(handle.dispose?.()).catch((err: unknown) => {
-          console.warn("atomic-workflows: stage handle dispose failed", err);
-        });
+      for (const entry of entries) {
+        disposeEntryInBackground(entry, "atomic-workflows: stage handle dispose failed");
       }
     },
   };

package/dist/builtin/workflows/src/runs/foreground/stage-runner-context.ts

@@ -17,10 +17,18 @@ import {
 import type { InternalStageContext, StageRunnerOpts } from "./stage-runner-types.js";
 
 export function createStageContext(opts: StageRunnerOpts): InternalStageContext {
-  const { stageId, stageName, adapters, runId, signal, stageOptions, executionMode } = opts;
+  const { stageId, stageName, adapters, runId, workflowIntercomGroup, signal, stageOptions, executionMode } = opts;
   const structuredOutputCapture = stageOptions?.schema ? createStructuredOutputCapture<unknown>() : undefined;
   const effectiveStageOptions = stageOptionsWithStructuredOutput(stageOptions, structuredOutputCapture);
-  const meta: StageExecutionMeta = { runId, stageId, stageName, signal, stageOptions: effectiveStageOptions, executionMode };
+  const meta: StageExecutionMeta = {
+    runId,
+    stageId,
+    stageName,
+    ...(workflowIntercomGroup === undefined ? {} : { workflowIntercomGroup }),
+    signal,
+    stageOptions: effectiveStageOptions,
+    executionMode,
+  };
   const controller = new StageSessionController(opts, meta, effectiveStageOptions, structuredOutputCapture);
   let lastAssistantText: string | undefined;
   let adapterMessages = [] as InternalStageContext["messages"];
@@ -226,8 +234,8 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
       await controller.requestPause();
     },
 
-    async __resume(message?: string) {
-      controller.resume(message);
+    async __resume(message, beforeResolve, beforeRelease) {
+      return controller.resume(message, beforeResolve, beforeRelease);
     },
 
     __isPaused() {

package/dist/builtin/workflows/src/runs/foreground/stage-runner-controller.ts

@@ -12,10 +12,8 @@ import { StageMessageAdmission } from "./stage-runner-message-admission.js";
 import { nextResumedContextOverflowFallbackIndex, terminatingToolCallId, unresolvedContextOverflowFailure, unresolvedContextOverflowMessage } from "./stage-runner-unresolved-overflow.js";
 import type { AgentSessionConsumer, StageModelFallbackMeta, StageRunnerOpts, StageSessionCreateOptions, StageSessionCreateResult, StageSessionEvent, StageSessionRuntime, WorkflowFastModeSettingsManager } from "./stage-runner-types.js";
 import { StageSessionReplacement } from "./stage-runner-replacement.js";
+import { StageSessionPause, type StageSessionPauseResumeResult } from "./stage-runner-pause.js";
 
-type PauseRequest = {
-  deferred: PromiseWithResolvers<{ message?: string }>;
-};
 
 export class StageSessionController {
   private session: StageSessionRuntime | undefined;
@@ -31,7 +29,7 @@ export class StageSessionController {
   private pendingThinkingLevel: Parameters<StageContext["setThinkingLevel"]>[0] | undefined;
   private readonly pendingListeners = new Set<(event: StageSessionEvent) => void>();
   private readonly listenerUnsubscribes = new Map<(event: StageSessionEvent) => void, () => void>();
-  private pauseRequest: PauseRequest | null = null;
+  private readonly pauseControl = new StageSessionPause(() => this.session);
   private readonly hasExplicitModelFallbackConfig: boolean;
   private candidatesPromise: Promise<WorkflowResolvedModelCandidate[]> | undefined;
   private activeCandidateIndex: number | undefined;
@@ -110,9 +108,18 @@ export class StageSessionController {
 
   async sendUserMessage(content: StageUserMessageContent, options?: StageSendUserMessageOptions, beforeDelivery?: () => void):
     Promise<Awaited<ReturnType<typeof sendStageUserMessage>>> {
-    return this.messageAdmission.run(async (release) => sendStageUserMessage(
-      await this.ensureSession("prompt"), content, options, beforeDelivery, release, this.messageAdmission,
-    ));
+    return this.messageAdmission.run(async (release) => {
+      const pausedDelivery = this.pauseControl.deferRunnerOwnedDelivery(
+        () => this.sendUserMessage(content, options, beforeDelivery),
+      );
+      if (pausedDelivery !== undefined) {
+        release();
+        return pausedDelivery;
+      }
+      return sendStageUserMessage(
+        await this.ensureSession("prompt"), content, options, beforeDelivery, release, this.messageAdmission,
+      );
+    });
   }
 
   sealGeneration(): void {
@@ -198,33 +205,19 @@ export class StageSessionController {
     await this.replacement.dispose();
     await disposeStageSession(this.session);
   }
-
-  async requestPause(): Promise<void> {
-    if (this.pauseRequest) return;
-    const deferred = Promise.withResolvers<{ message?: string }>();
-    void deferred.promise.catch(() => {});
-    const request = { deferred };
-    this.pauseRequest = request;
-    try { await this.session?.abort(); } catch (error) {
-      if (this.pauseRequest === request) { this.pauseRequest = null; deferred.reject(error); }
-      throw error;
-    }
+  requestPause(): Promise<void> { return this.pauseControl.requestPause(); }
+  resume(
+    message?: string,
+    beforeResolve?: (result: StageSessionPauseResumeResult) => void,
+    beforeRelease?: () => void,
+  ): Promise<StageSessionPauseResumeResult> {
+    return this.pauseControl.resume(message, beforeResolve, beforeRelease);
   }
-
-  resume(message?: string): void {
-    const req = this.pauseRequest;
-    if (!req) return;
-    this.pauseRequest = null;
-    req.deferred.resolve({ message });
-  }
-
-  isPaused(): boolean { return this.pauseRequest !== null; }
+  isPaused(): boolean { return this.pauseControl.isPaused(); }
   sessionMeta(): { sessionId: string | undefined; sessionFile: string | undefined } {
     return { sessionId: this.session?.sessionId, sessionFile: this.session?.sessionFile };
   }
-
   agentSession(): AgentSession | undefined { return asAgentSession(this.session); }
-
   pendingMessageCount(): number { return typeof this.session?.pendingMessageCount === "number" ? this.session.pendingMessageCount : 0; }
 
   private bindAbortSignal(): void {
@@ -237,10 +230,7 @@ export class StageSessionController {
     };
     const onAbort = (): void => {
       void this.session?.abort().catch(() => {});
-      if (!this.pauseRequest) return;
-      const req = this.pauseRequest;
-      this.pauseRequest = null;
-      req.deferred.reject(abortReason());
+      this.pauseControl.reject(abortReason());
     };
     if (signal.aborted) onAbort();
     else signal.addEventListener("abort", onAbort, { once: true });
@@ -370,10 +360,11 @@ export class StageSessionController {
   ): Promise<{ readonly terminalScanStartIndex: number }> {
     let nextText: string | undefined = initialText;
     while (nextText !== undefined) {
-      const pendingPauseBeforePrompt = this.pauseRequest;
+      const pendingPauseBeforePrompt = this.pauseControl.currentResume();
       if (pendingPauseBeforePrompt) {
-        const { message } = await pendingPauseBeforePrompt.deferred.promise;
-        nextText = message;
+        const resumed = await pendingPauseBeforePrompt;
+        await resumed.runnerOwnedDeliverySettlement;
+        nextText = resumed.message;
         if (nextText === undefined) return { terminalScanStartIndex: activeSession.messages.length };
         continue;
       }
@@ -381,22 +372,24 @@ export class StageSessionController {
       this.unresolvedContextOverflowMessage = undefined;
       try {
         await activeSession.prompt(nextText, sdkOptions);
-        const pendingPauseAfterPrompt = this.pauseRequest;
+        const pendingPauseAfterPrompt = this.pauseControl.currentResume();
         if (pendingPauseAfterPrompt) {
-          const { message } = await pendingPauseAfterPrompt.deferred.promise;
+          const resumed = await pendingPauseAfterPrompt;
+          await resumed.runnerOwnedDeliverySettlement;
           this.throwUnresolvedContextOverflowIfPresent();
-          nextText = message;
+          nextText = resumed.message;
           if (nextText === undefined) return { terminalScanStartIndex: activeSession.messages.length };
           continue;
         }
         this.throwUnresolvedContextOverflowIfPresent();
         return { terminalScanStartIndex: promptStartIndex };
       } catch (err) {
-        const pendingPauseAfterThrow = this.pauseRequest;
+        const pendingPauseAfterThrow = this.pauseControl.currentResume();
         if (pendingPauseAfterThrow) {
-          const { message } = await pendingPauseAfterThrow.deferred.promise;
+          const resumed = await pendingPauseAfterThrow;
+          await resumed.runnerOwnedDeliverySettlement;
           this.throwUnresolvedContextOverflowIfPresent();
-          nextText = message;
+          nextText = resumed.message;
           if (nextText === undefined) return { terminalScanStartIndex: activeSession.messages.length };
           continue;
         }

package/dist/builtin/workflows/src/runs/foreground/stage-runner-options.ts

@@ -21,7 +21,9 @@ function workflowOrchestrationContext(
     workflowStageName: meta.stageName,
     constraints: { disableWorkflowTool: true as const, maxSubagentDepth: 5 },
   };
-  const intercomGroup = stageHasIntercomAccess(stageOptions) ? resolveStageGroup(stageOptions) : undefined;
+  const intercomGroup = stageHasIntercomAccess(stageOptions)
+    ? resolveStageGroup(stageOptions, meta.workflowIntercomGroup)
+    : undefined;
   return intercomGroup ? { ...base, intercomGroup } : base;
 }
 
@@ -50,6 +52,8 @@ export function stripWorkflowOnlyOptions(
     resumeFromSessionFile,
     durableReplayKey: _durableReplayKey,
     durableAccumulatedDurationMs: _durableAccumulatedDurationMs,
+    durableStageId: _durableStageId,
+    durableParentIds: _durableParentIds,
     sessionDir,
     gitWorktreeDir: _gitWorktreeDir,
     baseBranch: _baseBranch,

package/dist/builtin/workflows/src/runs/foreground/stage-runner-pause.ts

@@ -0,0 +1,195 @@
+import type { StageSessionRuntime } from "./stage-runner-types.js";
+
+export interface StageSessionPauseResumeResult {
+  readonly releasedQueuedMessages: boolean;
+  /** True when a runner-admitted public delivery owns the first resumed turn. */
+  readonly runnerOwnedDeliveryPending: boolean;
+}
+
+interface PauseResumeResolution extends StageSessionPauseResumeResult {
+  readonly message?: string;
+  /** Lets the interrupted objective settle only after accepted public turns. */
+  readonly runnerOwnedDeliverySettlement: Promise<void>;
+}
+
+interface NativeQueuePauseControl {
+  readonly queuedMessagesPaused?: boolean;
+  pauseQueuedMessages(): void;
+  resumeQueuedMessages(beforeRelease?: () => void): boolean | Promise<boolean>;
+}
+
+function nativeQueuePauseControl(session: StageSessionRuntime | undefined): NativeQueuePauseControl | undefined {
+  if (
+    typeof session?.pauseQueuedMessages !== "function"
+    || typeof session.resumeQueuedMessages !== "function"
+  ) return undefined;
+  return session as StageSessionRuntime & NativeQueuePauseControl;
+}
+
+interface PauseRequest {
+  readonly deferred: PromiseWithResolvers<PauseResumeResolution>;
+  readonly abortBoundary: PromiseWithResolvers<void>;
+  readonly runnerOwnedDeliveries: Set<Promise<void>>;
+  readonly nativeQueuePause?: NativeQueuePauseControl;
+  resumePromise?: Promise<StageSessionPauseResumeResult>;
+}
+
+type PauseRejection = Error | DOMException | string;
+
+/** Serializes controlled pause, abort settlement, and one explicit resume. */
+export class StageSessionPause {
+  private request: PauseRequest | null = null;
+
+  constructor(private readonly getSession: () => StageSessionRuntime | undefined) {}
+
+  currentResume(): Promise<PauseResumeResolution> | undefined {
+    return this.request?.deferred.promise;
+  }
+
+  isPaused(): boolean {
+    return this.request !== null;
+  }
+
+  async requestPause(): Promise<void> {
+    if (this.request) return this.request.abortBoundary.promise;
+    const session = this.getSession();
+    const nativeQueuePause = nativeQueuePauseControl(session);
+    const request: PauseRequest = {
+      deferred: Promise.withResolvers<PauseResumeResolution>(),
+      abortBoundary: Promise.withResolvers<void>(),
+      runnerOwnedDeliveries: new Set(),
+      ...(nativeQueuePause === undefined ? {} : { nativeQueuePause }),
+    };
+    void request.deferred.promise.catch(() => {});
+    void request.abortBoundary.promise.catch(() => {});
+    this.request = request;
+    let failed = false;
+    try {
+      request.nativeQueuePause?.pauseQueuedMessages();
+      await session?.abort();
+      request.abortBoundary.resolve();
+      await request.abortBoundary.promise;
+    } catch (error) {
+      failed = true;
+      request.abortBoundary.reject(error);
+      request.deferred.reject(error);
+      await this.rollbackNativePause(request.nativeQueuePause);
+      throw error;
+    } finally {
+      if (failed && this.request === request) this.request = null;
+    }
+  }
+
+  private async rollbackNativePause(control: NativeQueuePauseControl | undefined): Promise<void> {
+    if (control === undefined) return;
+    try {
+      await control.resumeQueuedMessages();
+    } catch {
+      // AgentSession keeps a failed abort boundary closed until one release
+      // attempt observes it. Retry only when its public gate is still paused.
+      if (control.queuedMessagesPaused !== true) return;
+      try { await control.resumeQueuedMessages(); } catch { /* Preserve the pause/abort error. */ }
+    }
+  }
+
+  /**
+   * Capture a public delivery accepted while this pause generation owns the
+   * stage. It starts only after resume and stays visible to the interrupted
+   * objective, so readiness continuation cannot race it.
+   */
+  deferRunnerOwnedDelivery<T>(operation: () => Promise<T>): Promise<T> | undefined {
+    const request = this.request;
+    if (!request) return undefined;
+    const delivery = request.deferred.promise.then(operation);
+    const settlement = delivery.then(() => undefined, () => undefined);
+    request.runnerOwnedDeliveries.add(settlement);
+    void settlement.finally(() => request.runnerOwnedDeliveries.delete(settlement));
+    return delivery;
+  }
+
+  resume(
+    message?: string,
+    beforeResolve?: (result: StageSessionPauseResumeResult) => void,
+    beforeRelease?: () => void,
+  ): Promise<StageSessionPauseResumeResult> {
+    const request = this.request;
+    if (!request) {
+      beforeRelease?.();
+      return Promise.resolve({ releasedQueuedMessages: false, runnerOwnedDeliveryPending: false });
+    }
+    if (request.resumePromise) return request.resumePromise;
+    request.resumePromise = this.completeResume(request, message, beforeResolve, beforeRelease);
+    return request.resumePromise;
+  }
+
+  reject(reason: PauseRejection): void {
+    const request = this.request;
+    if (!request) return;
+    this.request = null;
+    request.abortBoundary.reject(reason);
+    request.deferred.reject(reason);
+  }
+
+  private async completeResume(
+    request: PauseRequest,
+    message: string | undefined,
+    beforeResolve: ((result: StageSessionPauseResumeResult) => void) | undefined,
+    beforeRelease: (() => void) | undefined,
+  ): Promise<StageSessionPauseResumeResult> {
+    try {
+      await request.abortBoundary.promise;
+    } catch (error) {
+      request.deferred.reject(error);
+      if (this.request === request) this.request = null;
+      throw error;
+    }
+
+    let releaseAdmitted = false;
+    const admitRelease = (): void => {
+      if (releaseAdmitted) return;
+      beforeRelease?.();
+      releaseAdmitted = true;
+    };
+    let releasedQueuedMessages: boolean;
+    try {
+      const nativeQueuePause = request.nativeQueuePause;
+      if (nativeQueuePause === undefined) {
+        admitRelease();
+        releasedQueuedMessages = false;
+      } else {
+        // Legacy adapters with no callback parameter linearize at invocation.
+        // Native Atomic sessions call this at their final synchronous release.
+        if (nativeQueuePause.resumeQueuedMessages.length === 0) admitRelease();
+        releasedQueuedMessages = await nativeQueuePause.resumeQueuedMessages(admitRelease);
+        admitRelease();
+      }
+    } catch (error) {
+      // Native release can fail transiently. Preserve this pause generation and
+      // its waiter/deliveries; only retire the failed attempt so explicit resume
+      // can retry the same native hold.
+      if (this.request === request) request.resumePromise = undefined;
+      throw error;
+    }
+
+    try {
+      const runnerOwnedDeliveries = [...request.runnerOwnedDeliveries];
+      const runnerOwnedDeliverySettlement = Promise.all(runnerOwnedDeliveries).then(() => undefined);
+      const result = {
+        releasedQueuedMessages,
+        runnerOwnedDeliveryPending: runnerOwnedDeliveries.length > 0,
+      };
+      beforeResolve?.(result);
+      request.deferred.resolve({
+        ...result,
+        runnerOwnedDeliverySettlement,
+        ...(message === undefined ? {} : { message }),
+      });
+      if (this.request === request) this.request = null;
+      return result;
+    } catch (error) {
+      request.deferred.reject(error);
+      if (this.request === request) this.request = null;
+      throw error;
+    }
+  }
+}

package/dist/builtin/workflows/src/runs/foreground/stage-runner-session-options.ts

@@ -1,6 +1,4 @@
 import {
-  getModelDefaultContextWindow,
-  getSupportedContextWindows,
   SessionManager,
   type CreateAgentSessionOptions,
 } from "@bastani/atomic";
@@ -22,22 +20,11 @@ export function buildStageSessionOptions(input: StageSessionOptionsInput): Stage
         ...(input.effectiveStageOptions ?? {}),
         model: input.candidate.value,
         ...(input.candidate.reasoningLevel !== undefined ? { thinkingLevel: input.candidate.reasoningLevel } : {}),
-        ...(input.candidate.contextWindow !== undefined ? { contextWindow: input.candidate.contextWindow } : {}),
         fallbackModels: undefined,
         fallbackThinkingLevels: undefined,
       };
   if (input.restoreSavedModel === true) delete options.model;
 
-  if (
-    input.restoreSavedModel !== true &&
-    input.reattachSessionFile === undefined &&
-    options.contextWindow === undefined &&
-    input.candidate !== undefined &&
-    typeof input.candidate.value !== "string" &&
-    getSupportedContextWindows(input.candidate.value).length > 1
-  ) {
-    options.contextWindow = getModelDefaultContextWindow(input.candidate.value);
-  }
   if (input.reattachSessionFile !== undefined && options.sessionManager === undefined) {
     const cwd = options.cwd ?? process.cwd();
     options.sessionManager = SessionManager.open(input.reattachSessionFile, options.sessionDir, cwd);