@bastani/atomic 0.8.31-alpha.3 → 0.8.31-alpha.5

package/dist/builtin/workflows/src/runs/foreground/executor.ts

@@ -121,6 +121,8 @@ export interface RunOpts extends Omit<AuthoringContract.RunOpts, "adapters" | "s
   ui?: WorkflowUIAdapter;
   /** Runtime execution mode. Controls child session policy metadata. */
   executionMode?: WorkflowExecutionMode;
+  /** Host-resolved non-default session directory inherited by stages without explicit sessionDir. */
+  defaultSessionDir?: string;
   /** Internal detached-run mode: surface ctx.ui.* as node-local workflow prompt stages. */
   usePromptNodesForUi?: boolean;
   /**
@@ -1003,6 +1005,24 @@ export function toolResultHasChatAnswer(result: unknown): boolean {
   );
 }
 
+// ---------------------------------------------------------------------------
+// Resume continuation hook (#1407)
+// ---------------------------------------------------------------------------
+// When an interactive paused stage is resumed with a user message, the resumed
+// answer turn should be followed by one deterministic same-session nudge so the
+// model returns to the interrupted work without showing the readiness gate for
+// the resume-answer turn itself.
+
+export const RESUME_CONTINUATION_PROMPT = "Continue where you left off.";
+
+export function shouldInjectResumeContinuation(state: {
+  readonly resumeOccurred: boolean;
+  readonly gateEnabled: boolean;
+  readonly aborted: boolean;
+}): boolean {
+  return state.resumeOccurred && state.gateEnabled && !state.aborted;
+}
+
 let cachedReadinessGateTool: ReturnType<typeof createAskUserQuestionToolDefinition> | undefined;
 function readinessGateTool(): ReturnType<typeof createAskUserQuestionToolDefinition> {
   return (cachedReadinessGateTool ??= createAskUserQuestionToolDefinition());
@@ -4199,6 +4219,7 @@ export async function run<TInputs extends WorkflowInputValues>(
           __requestPause: async () => rejectReplayMutation("pause"),
           __resume: async () => rejectReplayMutation("resume"),
           __isPaused: () => false,
+          __structuredOutputFinalized: () => false,
         };
         return replayContext;
       }
@@ -4233,6 +4254,7 @@ export async function run<TInputs extends WorkflowInputValues>(
         stageOptions: stageOptionsForContext,
         models: opts.models,
         executionMode: opts.executionMode,
+        defaultSessionDir: opts.defaultSessionDir,
         onModelFallbackMetaChange(meta) {
           applyModelFallbackMeta(meta);
           if (stageSnapshot.status === "running") {
@@ -4251,6 +4273,12 @@ export async function run<TInputs extends WorkflowInputValues>(
       // When true the readiness gate is bypassed — the stage stays in the
       // composer without showing an extra confirmation UI (#1264).
       let chatAnswerObservedThisTurn = false;
+      // Saturated one-slot marker for the latest real pause->resume(message)
+      // transition that still needs the deterministic same-session continuation
+      // prompt (#1407). Later paused resumes before the same post-turn drain
+      // supersede earlier unfinished resumes; the slot is consumed before
+      // prompting so a pause/resume of the continuation turn can set it again.
+      let resumeContinuationPending = false;
       const hasActiveAskUserQuestion = (): boolean =>
         activeAskUserQuestionCalls.size > 0 || activeAskUserQuestionAnonymousCalls > 0;
       const unsubscribeAskUserQuestionWatcher = innerCtx.subscribe((event) => {
@@ -4421,6 +4449,18 @@ export async function run<TInputs extends WorkflowInputValues>(
           if (changed) {
             ensureReleaseBarrier(stageId);
             await cascadePauseFrom(stageId);
+            // Mark the run paused once no stage is still actively running,
+            // mirroring pauseRun() (runs/background/status.ts). This keeps a
+            // manual TUI/Escape pause updating run-level status — and therefore
+            // the main-chat status widget and `/workflow status` — identically
+            // to the `workflow` tool and `/workflow pause`. recordRunPaused is
+            // idempotent, so double-recording from the tool/slash path or from
+            // cascade re-entry is safe.
+            const run = activeStore.runs().find((candidate) => candidate.id === runId);
+            const stillActive = run?.stages.some(
+              (s) => s.status === "running" && s.id !== stageId,
+            ) ?? false;
+            if (!stillActive) activeStore.recordRunPaused(runId);
           }
           if (statusBeforePause === "pending" || statusBeforePause === "running" || innerCtx.isStreaming) {
             await innerCtx.__requestPause();
@@ -4429,13 +4469,30 @@ export async function run<TInputs extends WorkflowInputValues>(
         async resume(message?: string) {
           throwIfStageMutationBlocked();
           await ensureMessagingSession();
-          const changed = activeStore.recordStageResumed(runId, stageId);
-          if (changed) {
-            releaseStageBarrier(stageId);
-            await cascadeResumeFrom(stageId);
+          const wasPausedBeforeResume = innerCtx.__isPaused();
+          const hasResumeContinuationMessage = typeof message === "string" && message.trim().length > 0;
+          const previousResumeContinuationPending = resumeContinuationPending;
+          const queuedResumeContinuation = wasPausedBeforeResume && hasResumeContinuationMessage;
+          if (queuedResumeContinuation) {
+            resumeContinuationPending = true;
           }
           try {
+            const changed = activeStore.recordStageResumed(runId, stageId);
+            if (changed) {
+              releaseStageBarrier(stageId);
+              await cascadeResumeFrom(stageId);
+              // Restore run-level status so a manual resume updates the main chat
+              // like the `workflow` tool / `/workflow resume`. recordRunResumed is
+              // a no-op when the run is not paused, so this is safe under cascade
+              // and the tool/slash path.
+              activeStore.recordRunResumed(runId);
+            }
             await innerCtx.__resume(message);
+          } catch (err) {
+            if (queuedResumeContinuation) {
+              resumeContinuationPending = previousResumeContinuationPending;
+            }
+            throw err;
           } finally {
             captureStageSessionMeta();
           }
@@ -4584,7 +4641,44 @@ export async function run<TInputs extends WorkflowInputValues>(
         }
       };
 
-      const runTrackedStageCall = async (call: () => Promise<string>, eagerSession = false): Promise<string> => {
+      const suppressReadinessForCurrentTurn = (): void => {
+        askUserQuestionObservedThisTurn = false;
+        chatAnswerObservedThisTurn = false;
+      };
+
+      const skipResumeContinuationInjection = (): boolean => {
+        if (stageFinalized) return true;
+        if (skippedForParallelFailFast) return true;
+        if (stageSnapshot.status === "skipped" && stageSnapshot.skippedReason === "fail-fast") return true;
+        if (isTerminalStage(stageSnapshot)) return true;
+        if (stageFailFastScope?.failed === true && stageFailFastScope.activeStages.has(stageId)) return true;
+        // A schema-backed stage can finalize during the resumed answer turn by
+        // calling structured_output. That consumes the resume slot and
+        // suppresses readiness for the resume-answer turn, but a second prompt
+        // would violate the one-prompt schema contract.
+        if (innerCtx.__structuredOutputFinalized()) return true;
+        return false;
+      };
+
+      const drainResumeContinuations = async <T>(currentResult: T): Promise<T> => {
+        let result = currentResult;
+        while (resumeContinuationPending) {
+          resumeContinuationPending = false;
+          suppressReadinessForCurrentTurn();
+          if (!shouldInjectResumeContinuation({
+            resumeOccurred: true,
+            gateEnabled: readinessGateEnabled,
+            aborted: ownController.signal.aborted,
+          })) {
+            continue;
+          }
+          if (skipResumeContinuationInjection()) continue;
+          result = await raceAbort(innerCtx.prompt(RESUME_CONTINUATION_PROMPT), ownController.signal) as T;
+        }
+        return result;
+      };
+
+      const runTrackedStageCall = async <T>(call: () => Promise<T>, eagerSession = false): Promise<T> => {
         throwIfWorkflowExitSelected();
         await waitForStageRelease();
         if (stageFinalized) {
@@ -4661,12 +4755,13 @@ export async function run<TInputs extends WorkflowInputValues>(
           };
           if (ownController.signal.aborted) abortSession();
           else ownController.signal.addEventListener("abort", abortSession, { once: true });
-          let result = "";
+          let result: T;
           try {
             // Run the stage's initial agent turn.
             askUserQuestionObservedThisTurn = false;
             chatAnswerObservedThisTurn = false;
             result = await raceAbort(call(), ownController.signal);
+            result = await drainResumeContinuations(result);
 
             // Per-turn readiness gate (#1099). When an agent turn ENDS (control
             // returns to the user): if the turn issued no ask_user_question
@@ -4706,7 +4801,8 @@ export async function run<TInputs extends WorkflowInputValues>(
                     ownController.signal,
                   );
                   if (ownController.signal.aborted) break;
-                  result = innerCtx.__getLastAssistantText() ?? result;
+                  result = (innerCtx.__getLastAssistantText() ?? result) as T;
+                  result = await drainResumeContinuations(result);
                 }
               } finally {
                 resolveNextTurnEnd = null;

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

@@ -124,6 +124,8 @@ export interface StageRunnerOpts {
   models?: WorkflowModelCatalogPort;
   /** Runtime execution mode forwarded to stage session adapters. */
   executionMode?: WorkflowExecutionMode;
+  /** Host-resolved non-default session directory inherited by stages without explicit sessionDir. */
+  defaultSessionDir?: string;
   /** Internal: notifies the executor when an in-flight fallback changes model/fast metadata. */
   onModelFallbackMetaChange?: (meta: StageModelFallbackMeta) => void;
 }
@@ -168,10 +170,16 @@ export interface InternalStageContext extends StageContext {
   __resume(message?: string): Promise<void>;
   /** Internal: true while a controlled pause is in flight. */
   __isPaused(): boolean;
+  /** Internal: true once a schema-backed prompt captured its final structured output. */
+  __structuredOutputFinalized(): boolean;
 }
 
-function stripWorkflowOnlyOptions(options: StageOptions | undefined): CreateAgentSessionOptions {
-  if (!options) return {};
+function stripWorkflowOnlyOptions(options: StageOptions | undefined, defaultSessionDir?: string): CreateAgentSessionOptions {
+  if (!options) {
+    return defaultSessionDir === undefined
+      ? {}
+      : { sessionManager: SessionManager.create(process.cwd(), defaultSessionDir) };
+  }
   const {
     schema: _schema,
     mcp: _mcp,
@@ -186,10 +194,11 @@ function stripWorkflowOnlyOptions(options: StageOptions | undefined): CreateAgen
   } = options;
   if (sessionOptions.sessionManager === undefined) {
     const cwd = sessionOptions.cwd ?? process.cwd();
+    const effectiveSessionDir = sessionDir ?? defaultSessionDir;
     if (context === "fork" && forkFromSessionFile !== undefined) {
-      sessionOptions.sessionManager = SessionManager.forkFrom(forkFromSessionFile, cwd, sessionDir);
-    } else if (sessionDir !== undefined) {
-      sessionOptions.sessionManager = SessionManager.create(cwd, sessionDir);
+      sessionOptions.sessionManager = SessionManager.forkFrom(forkFromSessionFile, cwd, effectiveSessionDir);
+    } else if (effectiveSessionDir !== undefined) {
+      sessionOptions.sessionManager = SessionManager.create(cwd, effectiveSessionDir);
     }
   }
   return sessionOptions as CreateAgentSessionOptions;
@@ -645,7 +654,7 @@ async function finalizePromptOutput(
 }
 
 export function createStageContext(opts: StageRunnerOpts): InternalStageContext {
-  const { stageId, stageName, adapters, runId, signal, stageOptions, executionMode } = opts;
+  const { stageId, stageName, adapters, runId, signal, stageOptions, executionMode, defaultSessionDir } = opts;
   const structuredOutputCapture = stageOptions?.schema ? createStructuredOutputCapture<unknown>() : undefined;
   const effectiveStageOptions = stageOptionsWithStructuredOutput(stageOptions, structuredOutputCapture);
   const meta: StageExecutionMeta = { runId, stageId, stageName, signal, stageOptions: effectiveStageOptions, executionMode };
@@ -723,6 +732,18 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
   let candidatesPromise: Promise<WorkflowResolvedModelCandidate[]> | undefined;
   let activeCandidateIndex: number | undefined;
   let selectedModel: string | undefined;
+  // A single ModelRegistry (carrying its AuthStorage) reused across every model
+  // fallback candidate in this stage. Captured from the first created session
+  // and threaded into subsequent candidate sessions so fallback does not rebuild
+  // auth/model state per candidate — which can misreport configured providers as
+  // "No API key found" under auth.json lock contention (issue #1431).
+  let sharedModelRegistry: CreateAgentSessionOptions["modelRegistry"];
+  // When true, the next promptWithFallback() call first retries the model the
+  // session last settled on (a post-completion follow-up, a subsequent turn, or
+  // a reattached session) before replaying the chain from the primary. Set on
+  // every successful attempt and by ensureSession()'s reattach branch; cleared
+  // when the current session is disposed.
+  let resumeCurrentSession = false;
   const modelAttempts: WorkflowModelAttempt[] = [];
   const modelWarnings: string[] = [];
   const pendingFallbackWarnings: string[] = [];
@@ -748,7 +769,10 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
     return candidatesPromise;
   }
 
-  function stageOptionsForCandidate(candidate: WorkflowResolvedModelCandidate | undefined): StageOptions | undefined {
+  function stageOptionsForCandidate(
+    candidate: WorkflowResolvedModelCandidate | undefined,
+    resumeOptions?: { restoreSavedModel?: boolean },
+  ): StageOptions | undefined {
     const optionsForCandidate: StageOptions = candidate === undefined
       ? { ...(effectiveStageOptions ?? {}) }
       : {
@@ -763,6 +787,12 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
           fallbackModels: undefined,
           fallbackThinkingLevels: undefined,
         };
+    // When resuming a reattached session (a post-completion follow-up), drop any
+    // model override so the SDK restores the model the session last used — the
+    // one that actually worked — instead of forcing the primary/candidate model.
+    if (resumeOptions?.restoreSavedModel) {
+      delete optionsForCandidate.model;
+    }
     if (reattachSessionFile !== undefined && optionsForCandidate.sessionManager === undefined) {
       const cwd = optionsForCandidate.cwd ?? process.cwd();
       optionsForCandidate.sessionManager = SessionManager.open(
@@ -773,6 +803,11 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
       optionsForCandidate.context = undefined;
       optionsForCandidate.forkFromSessionFile = undefined;
     }
+    // Reuse the registry captured from the first session for later fallback
+    // candidates. A caller-supplied modelRegistry is preserved (issue #1431).
+    if (sharedModelRegistry !== undefined && optionsForCandidate.modelRegistry === undefined) {
+      optionsForCandidate.modelRegistry = sharedModelRegistry;
+    }
     return Object.keys(optionsForCandidate).length === 0 ? undefined : optionsForCandidate;
   }
 
@@ -829,6 +864,16 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
   function attachSession(created: StageSessionRuntime | StageSessionCreateResult): StageSessionRuntime {
     const result = normalizeSessionCreateResult(created);
     session = result.session;
+    // Capture the SDK ModelRegistry from the first real session so subsequent
+    // fallback candidates reuse the same already-loaded auth/model state instead
+    // of re-creating it per candidate (issue #1431). The test stub session has
+    // no modelRegistry, so capture is simply skipped there.
+    if (sharedModelRegistry === undefined) {
+      const withRegistry = result.session as Partial<Pick<AgentSession, "modelRegistry">>;
+      if (withRegistry.modelRegistry !== undefined) {
+        sharedModelRegistry = withRegistry.modelRegistry;
+      }
+    }
     sessionSettingsManager = result.settingsManager ?? result.session.settingsManager;
     if (pendingThinkingLevel !== undefined) {
       result.session.setThinkingLevel(pendingThinkingLevel);
@@ -851,12 +896,13 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
   async function createSession(
     candidate: WorkflowResolvedModelCandidate | undefined,
     consumer: AgentSessionConsumer,
+    resumeOptions?: { restoreSavedModel?: boolean },
   ): Promise<StageSessionRuntime> {
     applyCandidateThinking(candidate);
     const created = adapters.agentSession
-      ? await adapters.agentSession.create(stripWorkflowOnlyOptions(stageOptionsForCandidate(candidate)) as StageSessionCreateOptions, {
+      ? await adapters.agentSession.create(stripWorkflowOnlyOptions(stageOptionsForCandidate(candidate, resumeOptions), defaultSessionDir) as StageSessionCreateOptions, {
         ...meta,
-        stageOptions: stageOptionsForCandidate(candidate),
+        stageOptions: stageOptionsForCandidate(candidate, resumeOptions),
       })
       : missingAdapter(consumer);
     return attachSession(created);
@@ -864,12 +910,37 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
 
   async function ensureSession(consumer: AgentSessionConsumer = "prompt"): Promise<StageSessionRuntime> {
     if (disposed) throw new Error(`atomic-workflows: stage "${stageName}" session has been disposed`);
+    // Reuse an already-attached session. After model fallback settles, `session`
+    // is set but `sessionPromise` is left undefined; without this guard a
+    // follow-up's ensureSession() (via ctx.followUp / ctx.steer / __ensureSession)
+    // would create a brand-new session from the primary candidate and discard the
+    // working fallback session (issue #1431 follow-up).
+    if (session !== undefined) return session;
     if (!sessionPromise) {
       sessionPromise = (async () => {
         if (!hasExplicitModelFallbackConfig) return createSession(undefined, consumer);
         const candidates = await modelCandidates();
         const first = candidates[0];
         if (first === undefined) return createSession(undefined, consumer);
+
+        // Reattaching a previously-run session (e.g. a post-completion
+        // follow-up after the session was disposed): resume on the model the
+        // session last settled on — the one that actually worked — instead of
+        // replaying the fallback chain from an unavailable primary.
+        // promptWithFallback retries that model first; if it fails again it
+        // restarts the full chain from the primary.
+        if (reattachSessionFile !== undefined) {
+          const resumed = await createSession(undefined, consumer, { restoreSavedModel: true });
+          const restoredId = workflowModelId(resumed.model);
+          const restoredIndex = restoredId === undefined
+            ? -1
+            : candidates.findIndex((entry) => entry.id === restoredId);
+          activeCandidateIndex = restoredIndex >= 0 ? restoredIndex : undefined;
+          selectedModel = restoredId ?? first.id;
+          resumeCurrentSession = true;
+          return resumed;
+        }
+
         activeCandidateIndex = 0;
         selectedModel = first.id;
         return createSession(first, consumer);
@@ -889,6 +960,7 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
     session = undefined;
     sessionPromise = undefined;
     sessionSettingsManager = undefined;
+    resumeCurrentSession = false;
     for (const unsubscribe of listenerUnsubscribes.values()) unsubscribe();
     listenerUnsubscribes.clear();
     unsubscribeTerminateWatcher?.();
@@ -956,14 +1028,61 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
       return;
     }
 
-    let index = activeCandidateIndex ?? 0;
     const capturedStructuredOutputForAttempt = (): boolean =>
       structuredOutputCapture?.called === true && signal?.aborted !== true;
     const recordSuccessfulAttempt = (candidate: WorkflowResolvedModelCandidate): void => {
       modelAttempts.push({ model: candidate.id, success: true, ...modelAttemptReasoning(candidate) });
       pendingFallbackWarnings.length = 0;
+      // The session settled on a working model; a later follow-up/turn should
+      // resume on it rather than replaying the chain from the primary.
+      resumeCurrentSession = true;
     };
 
+    // Resume preamble: when the stage already settled on a working model (a
+    // post-completion follow-up, a subsequent turn, or a reattached session),
+    // retry that model first instead of replaying the chain from an unavailable
+    // primary. If that model now fails retryably, restart the full chain from
+    // the primary.
+    if (resumeCurrentSession && session !== undefined) {
+      resumeCurrentSession = false;
+      const resumedSession = session;
+      const resumedLabel = selectedModel ?? workflowModelId(resumedSession.model) ?? candidates[0]!.id;
+      notifyModelFallbackMetaChange();
+      try {
+        const { terminalScanStartIndex } = await promptWithPauseResume(resumedSession, text, sdkOptions);
+        const terminalFailure = latestTerminalAssistantFailureSince(resumedSession.messages, terminalScanStartIndex);
+        if (terminalFailure === undefined || capturedStructuredOutputForAttempt()) {
+          modelAttempts.push({ model: resumedLabel, success: true });
+          pendingFallbackWarnings.length = 0;
+          resumeCurrentSession = true;
+          return;
+        }
+        throw new WorkflowPromptModelFailure(terminalFailure);
+      } catch (err) {
+        if (capturedStructuredOutputForAttempt() && isRetryableModelFailure(err)) {
+          modelAttempts.push({ model: resumedLabel, success: true });
+          pendingFallbackWarnings.length = 0;
+          resumeCurrentSession = true;
+          return;
+        }
+        const message = errorMessage(err);
+        modelAttempts.push({ model: resumedLabel, success: false, error: message });
+        if (signal?.aborted || !isRetryableModelFailure(err)) {
+          modelWarnings.push(...pendingFallbackWarnings);
+          pendingFallbackWarnings.length = 0;
+          notifyModelFallbackMetaChange();
+          throw err;
+        }
+        // The resumed model failed retryably: restart the whole fallback chain
+        // from the primary. disposeCurrentSession clears resumeCurrentSession.
+        pendingFallbackWarnings.push(`[fallback] resume on ${resumedLabel} failed: ${message}. Restarting fallback from ${candidateLabel(candidates[0]!)}.`);
+        await disposeCurrentSession();
+        activeCandidateIndex = undefined;
+      }
+    }
+
+    let index = activeCandidateIndex ?? 0;
+
     while (index < candidates.length) {
       const candidate = candidates[index]!;
       const activeSession = session && activeCandidateIndex === index
@@ -1228,6 +1347,10 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
     __isPaused() {
       return pauseRequest !== null;
     },
+
+    __structuredOutputFinalized() {
+      return structuredOutputCapture?.called === true;
+    },
   };
 }
 

package/dist/builtin/workflows/src/shared/persistence-restore.ts

@@ -47,6 +47,8 @@ export interface SessionEntry {
 /** Structural type for pi's sessionManager (optional — degrades gracefully). */
 export interface SessionManager {
   getEntries?: () => SessionEntry[] | readonly SessionEntry[];
+  getSessionDir?: () => string;
+  usesDefaultSessionDir?: () => boolean;
 }
 
 // ---------------------------------------------------------------------------

package/dist/core/agent-session.d.ts

@@ -563,6 +563,31 @@ export declare class AgentSession {
      * Context overflow errors are NOT retryable (handled by compaction instead).
      */
     private _isRetryableError;
+    /**
+     * For GitHub Copilot Gemini, reconstruct flattened tool-call arguments
+     * (for example `edits[0].newText`) into the nested arrays/objects Gemini
+     * produced before the assistant message is persisted, so saved transcripts
+     * never carry the flattened CAPI wire shape and replays loaded from disk match
+     * the structure Gemini signed. In-place, gated to Copilot Gemini, and a no-op
+     * for well-formed arguments or any other provider/model. The outbound replay
+     * normalizer still heals already-persisted (legacy) sessions on the wire.
+     */
+    private _normalizePersistedGeminiToolArgs;
+    /**
+     * Detect a degenerate empty completion: the provider ended the stream with no
+     * usable content and zero output tokens. Seen with github-copilot Gemini models
+     * that emit finish_reason "stop" (or a tool-use stop) with an empty content array
+     * and 0 output tokens, leaving the turn dead instead of producing the next step.
+     *
+     * These are treated as retryable so the harness re-issues the request rather than
+     * silently stopping mid-task. Guarded tightly (no text, no tool call, no thinking,
+     * and output === 0) so legitimate non-empty turns are never matched.
+     *
+     * Intentionally provider-agnostic (not gated to Copilot Gemini): a degenerate
+     * empty turn is a transient failure for any provider. It is bounded by
+     * `maxRetries` and falls through to normal handling on exhaustion.
+     */
+    private _isEmptyCompletion;
     private _handleRetryableError;
     /**
      * Cancel in-progress retry.