@bastani/atomic 0.9.11-alpha.5 → 0.9.11-alpha.7

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-send-user-message.ts

@@ -1,4 +1,5 @@
 import type { StageSendUserMessageOptions, StageUserMessageContent } from "../../shared/types.js";
+import type { StageDeliveryActivity } from "./stage-delivery-activity.js";
 import type { StageMessageAdmission, StageMessageTurn } from "./stage-runner-message-admission.js";
 import type { StageSessionRuntime, StageUserMessageDeliveryAction } from "./stage-runner-types.js";
 
@@ -59,6 +60,7 @@ export async function sendStageUserMessage(
   beforeDelivery?: () => void,
   promptStarted?: () => void,
   admission?: StageMessageAdmission,
+  activity?: StageDeliveryActivity,
 ): Promise<StageUserMessageDeliveryAction> {
   const streaming = activeSession.isStreaming || admission?.isOwned(activeSession) === true;
   const deliverAs = streaming ? options?.deliverAs ?? "followUp" : options?.deliverAs;
@@ -71,6 +73,9 @@ export async function sendStageUserMessage(
         ? createLocalPromptOwnershipObserver(activeSession, promptStarted)
         : coordinatedPromptOwnershipObserver(admission.startTurn(activeSession, promptStarted ?? (() => {})));
     ownership?.arm();
+    // An admitted idle delivery owns the visible Working period from here until
+    // it settles; a streaming delivery joins a turn that already owns it.
+    const deliveryId = streaming ? undefined : activity?.start();
     try {
       const delivery = activeSession.sendUserMessage(content, {
         ...(deliverAs === undefined ? {} : { deliverAs }),
@@ -89,6 +94,7 @@ export async function sendStageUserMessage(
       throw error;
     } finally {
       ownership?.dispose();
+      activity?.settle(deliveryId);
     }
   }
   if (typeof content !== "string") throw unsupportedContentError();
@@ -102,6 +108,7 @@ export async function sendStageUserMessage(
     ? createLocalPromptOwnershipObserver(activeSession, promptStarted)
     : coordinatedPromptOwnershipObserver(admission.startTurn(activeSession, promptStarted ?? (() => {})));
   ownership.arm();
+  const deliveryId = activity?.start();
   try {
     const turn = activeSession.prompt(content);
     ownership.observeStreaming();
@@ -113,5 +120,6 @@ export async function sendStageUserMessage(
     throw error;
   } finally {
     ownership.dispose();
+    activity?.settle(deliveryId);
   }
 }

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);

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

@@ -29,6 +29,12 @@ export type WorkflowFastModeSettingsManager = {
 
 export type StageUserMessageDeliveryAction = "prompt" | "steer" | "followUp" | "handled";
 
+/** Internal session preparation and side-effect-free eligibility boundary. */
+export interface StageUserMessagePreparation {
+  readonly sessionFile?: string;
+  readonly beforePreparation?: () => void;
+}
+
 export interface StageUserMessageDeliveryHooks {
   readonly beforeDelivery?: () => void;
   /** Releases serialized admission once an idle prompt synchronously owns the turn. */
@@ -45,6 +51,12 @@ export interface StageSessionRuntime {
   sealWorkflowStageGeneration?(): void;
   closeWorkflowStageGeneration?(): Promise<void>;
   transferWorkflowStageDeliveriesTo?(target: object): void;
+  /** True when this runtime implements a native queued-message pause gate. */
+  readonly queuedMessagesPaused?: boolean;
+  /** Optional native optimization that synchronously holds queued work. */
+  pauseQueuedMessages?(): void;
+  /** Optional native release; calls `beforeRelease` at the final synchronous boundary. */
+  resumeQueuedMessages?(beforeRelease?: () => void): boolean | Promise<boolean>;
   steer(text: string): Promise<void>;
   followUp(text: string): Promise<void>;
   subscribe(listener: (event: StageSessionEvent) => void): () => void;
@@ -112,6 +124,8 @@ export interface StageRunnerOpts {
   stageOptions?: StageOptions;
   /** Run ID of the containing workflow execution — forwarded to session adapter metadata. */
   runId: string;
+  /** Runtime-owned home group shared by this top-level workflow invocation. */
+  workflowIntercomGroup?: string;
   /** AbortSignal from the executor's own AbortController — forwarded to session adapter metadata. */
   signal?: AbortSignal;
   /** Optional model catalog used for fallback validation/resolution. */
@@ -144,7 +158,17 @@ export interface InternalStageContext extends StageContext {
     content: StageUserMessageContent,
     options?: StageSendUserMessageOptions,
     beforeDelivery?: () => void,
+    preparation?: StageUserMessagePreparation,
   ): Promise<StageUserMessageDeliveryAction>;
+  /**
+   * Internal: subscribe to workflow-owned delivery lifecycle facts for this
+   * stage. An accepted idle delivery reports `delivery_start` before the public
+   * `agent_start` reaches subscribers, so an attached chat can paint Working
+   * for the whole turn rather than only after the SDK event queue drains.
+   */
+  __subscribeDeliveryActivity(
+    listener: (event: import("./stage-delivery-activity.js").StageDeliveryActivityEvent) => void,
+  ): () => void;
   /** Internal: synchronously reject new detached traffic without waiting for active work. */
   __sealGeneration(): void;
   /** Internal: atomically stop detached traffic admission and drain admitted work. */
@@ -159,8 +183,12 @@ export interface InternalStageContext extends StageContext {
   __modelFallbackMeta(): StageModelFallbackMeta;
   /** Internal: register a controlled-pause request. */
   __requestPause(): Promise<void>;
-  /** Internal: complete a pending controlled pause. */
-  __resume(message?: string): Promise<void>;
+  /** Internal: complete a pending controlled pause and report its released raw work. */
+  __resume(
+    message?: string,
+    beforeResolve?: (result: import("./stage-runner-pause.js").StageSessionPauseResumeResult) => void,
+    beforeRelease?: () => void,
+  ): Promise<import("./stage-runner-pause.js").StageSessionPauseResumeResult>;
   /** Internal: true while a controlled pause is in flight. */
   __isPaused(): boolean;
   /** Internal: true once a schema-backed prompt captured its final structured output. */

package/dist/builtin/workflows/src/runs/shared/model-fallback-candidates.ts

@@ -1,4 +1,3 @@
-import { getModelDefaultContextWindow, getSupportedContextWindows, parseContextWindowValue } from "@bastani/atomic";
 import type { CreateAgentSessionOptions } from "@bastani/atomic";
 import type {
   WorkflowModelCatalogPort,
@@ -11,135 +10,20 @@ export interface WorkflowResolvedModelCandidate {
   readonly id: string;
   readonly value: WorkflowModelValue;
   readonly reasoningLevel?: WorkflowThinkingLevel;
-  /**
-   * Resolved context-window token budget for this candidate's session, parsed
-   * from a parenthesized authoring token in the model string (e.g.
-   * `github-copilot/claude-opus-4.8 (1m):xhigh` or `...:xhigh (1m)`). Resolved
-   * against the candidate model's advertised windows: a `(long)` marker or a
-   * request above the model's default selects the long tier (exact match wins,
-   * otherwise the smallest window >= the request, rounding UP so `(1m)`/`(1.1m)`
-   * select a long tier even when it sits slightly above the marker size). Left
-   * `undefined` when the model exposes no long tier, so the session keeps the
-   * model's default (short) window.
-   */
-  readonly contextWindow?: number;
 }
 
 function makeCandidate(
   id: string,
   value: WorkflowModelValue,
   level: WorkflowThinkingLevel | undefined,
-  contextWindow?: number,
 ): WorkflowResolvedModelCandidate {
   return {
     id,
     value,
     ...(level !== undefined ? { reasoningLevel: level } : {}),
-    ...(contextWindow !== undefined ? { contextWindow } : {}),
   };
 }
 
-/**
- * Result of extracting a trailing parenthesized context-window authoring token.
- * - `requestedContextWindow`: a numeric size token (e.g. `1m`, `1.1m`, `272k`).
- * - `requestedLongContext`: the generic `(long)` marker, which selects the
- *   model's advertised long tier regardless of its exact size.
- */
-interface ExtractedContextWindowToken {
-  readonly baseModel: string;
-  readonly requestedContextWindow?: number;
-  readonly requestedLongContext?: boolean;
-}
-
-/**
- * Extract a trailing parenthesized context-window authoring token, e.g. the
- * `(1m)` in `github-copilot/claude-opus-4.8 (1m)`. Mirrors GitHub Copilot's
- * model-name convention (`Claude Opus 4.8 (1M context)`) and intentionally
- * lives in the model-name portion — *not* a `:` suffix — so it never collides
- * with the `:off|minimal|low|medium|high|xhigh` reasoning-level suffix.
- *
- * Accepted token forms, all selecting the model's long tier when one exists:
- *   - `(long)` — a generic, size-agnostic long-context marker (case-insensitive);
- *   - a rounded size matching the model's long tier, e.g. `(1m)` for a ~1M tier
- *     (claude-opus-4.8) or `(1.1m)` for a ~1.05M tier (gpt-5.5), resolved by
- *     rounding UP to the long tier (see `resolveRequestedContextWindow`);
- *   - any exact/partial size (e.g. `(272k)` keeps the short tier).
- *
- * Parsed with plain string scanning rather than a regular expression so that
- * adversarial model strings (e.g. `(` followed by long whitespace runs) cannot
- * trigger super-linear backtracking (CodeQL js/polynomial-redos).
- */
-function extractContextWindowToken(model: string): ExtractedContextWindowToken {
-  const trimmedEnd = model.trimEnd();
-  if (!trimmedEnd.endsWith(")")) return { baseModel: model };
-  const open = trimmedEnd.lastIndexOf("(");
-  // Require at least one character before the `(` so a bare `(1m)` is not a model.
-  if (open <= 0) return { baseModel: model };
-  const inner = trimmedEnd.slice(open + 1, -1);
-  // The token must be a single flat `(...)` group with no nested parentheses.
-  if (inner.includes("(") || inner.includes(")")) return { baseModel: model };
-  const token = inner.trim();
-  const baseModel = trimmedEnd.slice(0, open).trim();
-  if (token.length === 0 || baseModel.length === 0) return { baseModel: model };
-  // `(long)` is a generic long-context marker: select the model's advertised
-  // long tier regardless of its exact size, so the same token works across
-  // models with different long tiers (e.g. claude-opus-4.8 1m vs gpt-5.5 1.1m).
-  if (token.toLowerCase() === "long") return { baseModel, requestedLongContext: true };
-  const parsed = parseContextWindowValue(token);
-  // A parenthesized token that does not parse as a context size (e.g. an
-  // accidental `(preview)`) is left attached to the model id so the normal
-  // "not available" lookup surfaces the typo instead of being silently dropped.
-  if (parsed.value === undefined) return { baseModel: model };
-  return { baseModel, requestedContextWindow: parsed.value };
-}
-
-/**
- * Resolve a requested context-window budget against a candidate model's
- * advertised windows. A request at or below the model's default window keeps
- * the default (no upgrade). A request above the default selects the long tier:
- * the exact value when supported, otherwise the smallest advertised window that
- * meets the request, rounding UP so a `(1m)` token lands on a long tier even
- * when it sits slightly above 1m (e.g. gpt-5.5's 1.05m full-context tier). When
- * no advertised window meets the request, the largest window is chosen so the
- * token always selects the long tier when one exists. Returns `undefined` when
- * the resolution lands back on the model's default (no upgrade) or the model
- * value is a plain string (not resolved against the live catalog).
- */
-function resolveRequestedContextWindow(
-  value: WorkflowModelValue,
-  requested: number,
-): number | undefined {
-  if (typeof value === "string") return undefined;
-  const supported = getSupportedContextWindows(value);
-  if (supported.length === 0) return undefined;
-  const defaultContextWindow = getModelDefaultContextWindow(value);
-  // A request at or below the default window keeps the default (no upgrade).
-  if (requested <= defaultContextWindow) return undefined;
-  if (supported.includes(requested)) return requested;
-  // Round UP to the smallest advertised window that meets the request; when no
-  // window meets it, fall back to the largest window (the long tier) so the
-  // token still selects the long tier. `supported` is sorted ascending.
-  const atOrAbove = supported.filter((window) => window >= requested);
-  const longTier = atOrAbove.length > 0 ? Math.min(...atOrAbove) : supported[supported.length - 1]!;
-  return longTier === defaultContextWindow ? undefined : longTier;
-}
-
-/**
- * Resolve the generic `(long)` long-context marker against a candidate model's
- * advertised windows: select the largest advertised window that exceeds the
- * model's default (the long tier). Returns `undefined` for single-window models
- * or plain string values, so the session keeps the model's default window.
- */
-function resolveLongContextWindow(value: WorkflowModelValue): number | undefined {
-  if (typeof value === "string") return undefined;
-  const supported = getSupportedContextWindows(value);
-  if (supported.length <= 1) return undefined;
-  const defaultContextWindow = getModelDefaultContextWindow(value);
-  // `supported` is sorted ascending; the largest window is the long tier.
-  const longTier = supported[supported.length - 1]!;
-  return longTier > defaultContextWindow ? longTier : undefined;
-}
-
 const WORKFLOW_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const satisfies readonly WorkflowThinkingLevel[];
 const WORKFLOW_THINKING_LEVEL_SET: ReadonlySet<string> = new Set(WORKFLOW_THINKING_LEVELS);
 
@@ -154,7 +38,7 @@ export function splitReasoningSuffix(model: string): { readonly baseModel: strin
 }
 
 function candidateKey(candidate: WorkflowResolvedModelCandidate): string {
-  return `${candidate.id}::${candidate.reasoningLevel ?? ""}::${candidate.contextWindow ?? ""}`;
+  return `${candidate.id}::${candidate.reasoningLevel ?? ""}`;
 }
 
 interface ModelResolutionFailure {
@@ -219,34 +103,10 @@ function resolveStringModel(
 ): WorkflowResolvedModelCandidate | ModelResolutionFailure {
   const input = rawInput.trim();
   if (!input) return { input: rawInput, reason: "empty model id" };
-  // Extract the trailing context-window token, split the reasoning suffix, then
-  // extract the token once more. This handles both `model (1m):level` (token
-  // before the suffix) and `model:level (1m)` (token after the suffix) without
-  // letting the token collide with the `:off|minimal|low|medium|high|xhigh`
-  // reasoning suffix.
-  const tokenFirst = extractContextWindowToken(input);
-  const { baseModel: afterReasoning, level } = splitReasoningSuffix(tokenFirst.baseModel);
-  let baseModel = afterReasoning;
-  let requestedContextWindow = tokenFirst.requestedContextWindow;
-  let requestedLongContext = tokenFirst.requestedLongContext;
-  if (requestedContextWindow === undefined && requestedLongContext === undefined) {
-    const retry = extractContextWindowToken(afterReasoning);
-    baseModel = retry.baseModel;
-    requestedContextWindow = retry.requestedContextWindow;
-    requestedLongContext = retry.requestedLongContext;
-  }
+  const { baseModel, level } = splitReasoningSuffix(input);
 
   const candidate = (id: string, value: WorkflowModelValue): WorkflowResolvedModelCandidate =>
-    makeCandidate(
-      id,
-      value,
-      level,
-      requestedLongContext
-        ? resolveLongContextWindow(value)
-        : requestedContextWindow === undefined
-          ? undefined
-          : resolveRequestedContextWindow(value, requestedContextWindow),
-    );
+    makeCandidate(id, value, level);
 
   if (availableModels === undefined) {
     return candidate(baseModel, baseModel);

package/dist/builtin/workflows/src/sdk-surface.ts

@@ -34,7 +34,7 @@ export type { StageNode } from "./engine/graph-inference.js";
 export { setupGitWorktree } from "./runs/shared/worktree.js";
 export type { GitWorktreeSetupOptions, GitWorktreeSetupResult } from "./runs/shared/worktree.js";
 export { createStore, store } from "./shared/store.js";
-export type { RunStatus, StageStatus, ToolEvent, StageSnapshot, RunSnapshot, StoreSnapshot, WorkflowNotice, NoticeLevel, WorkflowOverlayAdapter, PromptKind, CustomPromptIdentitySource, PendingPrompt } from "./shared/store-types.js";
+export type { RunStatus, StageStatus, ToolEvent, ToolNodeSnapshot, StageSnapshot, RunSnapshot, StoreSnapshot, WorkflowNotice, NoticeLevel, WorkflowOverlayAdapter, PromptKind, CustomPromptIdentitySource, PendingPrompt } from "./shared/store-types.js";
 
 // Phase D — cancellation registry
 export { createCancellationRegistry, cancellationRegistry } from "./runs/background/cancellation-registry.js";

package/dist/builtin/workflows/src/shared/authoring-contract-stage.d.ts

@@ -118,17 +118,6 @@ export interface StageOptions<TSchemaDef extends TSchema | undefined = TSchema |
     /** Optional structured final-answer schema. When set, the stage receives a schema-specific final-answer tool. */
     readonly schema?: TSchemaDef;
     readonly model?: WorkflowModelValue;
-    /**
-     * Context-window token budget for the stage session. May also be expressed
-     * per-model via a parenthesized token in a `model`/`fallbackModels` entry
-     * (e.g. `github-copilot/claude-opus-4.8 (1m):xhigh`), which is preferred when
-     * only specific fallbacks should use a larger window. Non-strict by default:
-     * an unsupported value keeps the model's default window (see
-     * `contextWindowStrict`).
-     */
-    readonly contextWindow?: number;
-    /** Treat an unsupported `contextWindow` as an error instead of falling back to the model default. */
-    readonly contextWindowStrict?: boolean;
     readonly mcp?: StageMcpOptions;
     readonly tools?: readonly string[];
     readonly noTools?: "all" | "builtin";
@@ -209,6 +198,12 @@ export interface StageSessionRuntime {
     sendUserMessage?(content: StageUserMessageContent, options?: StageSendUserMessageOptions): Promise<void>;
     steer(text: string): Promise<void>;
     followUp(text: string): Promise<void>;
+    /** True when this runtime implements a native queued-message pause gate. */
+    readonly queuedMessagesPaused?: boolean;
+    /** Optional native optimization that synchronously holds queued steer/follow-up work. */
+    pauseQueuedMessages?(): void;
+    /** Optional native release; calls `beforeRelease` at final admission. */
+    resumeQueuedMessages?(beforeRelease?: () => void): boolean | Promise<boolean>;
     /**
      * Must emit `agent_start` when a submitted user-message turn takes ownership and
      * `agent_end` when that owned turn terminates. Registration may replay state

package/dist/builtin/workflows/src/shared/authoring-contract-stage.ts

@@ -155,17 +155,6 @@ export interface StageOptions<TSchemaDef extends TSchema | undefined = TSchema |
   /** Optional structured final-answer schema. When set, the stage receives a schema-specific final-answer tool. */
   readonly schema?: TSchemaDef;
   readonly model?: WorkflowModelValue;
-  /**
-   * Context-window token budget for the stage session. May also be expressed
-   * per-model via a parenthesized token in a `model`/`fallbackModels` entry
-   * (e.g. `github-copilot/claude-opus-4.8 (1m):xhigh`), which is preferred when
-   * only specific fallbacks should use a larger window. Non-strict by default:
-   * an unsupported value keeps the model's default window (see
-   * `contextWindowStrict`).
-   */
-  readonly contextWindow?: number;
-  /** Treat an unsupported `contextWindow` as an error instead of falling back to the model default. */
-  readonly contextWindowStrict?: boolean;
   readonly mcp?: StageMcpOptions;
   readonly tools?: readonly string[];
   readonly noTools?: "all" | "builtin";
@@ -253,6 +242,12 @@ export interface StageSessionRuntime {
   sendUserMessage?(content: StageUserMessageContent, options?: StageSendUserMessageOptions): Promise<void>;
   steer(text: string): Promise<void>;
   followUp(text: string): Promise<void>;
+  /** True when this runtime implements a native queued-message pause gate. */
+  readonly queuedMessagesPaused?: boolean;
+  /** Optional native optimization that synchronously holds queued steer/follow-up work. */
+  pauseQueuedMessages?(): void;
+  /** Optional native release; calls `beforeRelease` at final admission. */
+  resumeQueuedMessages?(beforeRelease?: () => void): boolean | Promise<boolean>;
   /**
    * Must emit `agent_start` when a submitted user-message turn takes ownership and
    * `agent_end` when that owned turn terminates. Registration may replay state