@bastani/atomic 0.9.9 → 0.9.10

package/dist/builtin/workflows/src/engine/run.ts

@@ -1,3 +1,4 @@
+import { nextEventLoopTurn, runWorkflowDefinitionCallback } from "./workflow-activity.js";
 import type { RunSnapshot, StageSnapshot } from "../shared/store-types.js";
 import type { WorkflowDefinition, WorkflowInputValues, WorkflowOutputValues, WorkflowRunContext } from "../shared/types.js";
 import type { WorkflowFailure } from "../shared/workflow-failures.js";
@@ -29,6 +30,7 @@ import {
   finalizeKilled,
   finalizeKilledByFailure,
   recordActiveBlockedFailure,
+  normalizeStageLessFailureMetadata,
   reconcileTerminalRunResult,
   selectRunFailureDisposition,
 } from "../runs/foreground/executor-lifecycle.js";
@@ -37,8 +39,8 @@ import { isWorkflowDefinition, workflowDefinitionRequirementMessage } from "../r
 import { getDurableBackend } from "../durable/factory.js";
 import { classifyReturnedRunStatus } from "./run-returned-status.js";
 import { createToolPrimitive, createCheckpointIdGenerator } from "../durable/tool-primitive.js";
-import { persistDurableCacheEntry } from "../durable/resume-catalog.js";
 import { createDurableStagePrimitive, createDurableTaskPrimitive, recordStageCheckpoint, createStageReplayKeyGenerator, recordCachedStageWithTracker } from "../durable/stage-primitive.js";
+import { inheritedRunElapsedMs } from "../durable/run-timing.js";
 import type { DurableCompletedStageCheckpoint } from "../durable/stage-primitive.js";
 import { createDurableChildWorkflowPrimitive } from "../durable/child-primitive.js";
 import { ScopedDurableBackend, type DurableScope } from "../durable/scoped-backend.js";
@@ -46,10 +48,6 @@ import { finalizeDurableTerminalStatus } from "./run-durable-finalize.js";
 import { createDurableStageSessionRecorder } from "./run-durable-stage-session.js";
 import type { DurableWorkflowBackend } from "../durable/backend.js";
 
-function nextEventLoopTurn(): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, 0));
-}
-
 type WorkflowRunInputArgument = Parameters<typeof resolveAndValidateInputs>[1];
 
 export function run<
@@ -100,6 +98,19 @@ export async function run<
     else callerSignal.addEventListener("abort", () => { ownController.abort(callerSignal.reason); }, { once: true });
   }
   const exit = createWorkflowExitManager({ runId, exitScope, controller: ownController });
+  // Durable workflow backend — registers this run and wires ctx.tool/ui/stage.
+  // Declared early so the stage-end recorder can attach to stageOptions and so
+  // resume can seed inherited elapsed time. Child runs with a durable scope
+  // route their internal side-effect checkpoints under the root workflow so
+  // interrupted children do not re-execute completed side effects on parent
+  // resume. cross-ref: issue #1498 — DBOS-backed cross-session resumability.
+  const rootBackend: DurableWorkflowBackend = opts.durableBackend ?? getDurableBackend();
+  const durableBackend: DurableWorkflowBackend = opts.durableScope !== undefined
+    ? new ScopedDurableBackend(rootBackend, opts.durableScope)
+    : rootBackend;
+  const inheritedElapsedMs = opts.parentRun === undefined
+    ? inheritedRunElapsedMs({ backend: durableBackend, runId, continuationSource: opts.continuation?.source })
+    : undefined;
 
   const runSnapshot: RunSnapshot = {
     id: runId,
@@ -117,6 +128,7 @@ export async function run<
       resumedFromRunId: opts.continuation.source.id,
       resumeFromStageId: opts.continuation.resumeFromStageId,
     } : {}),
+    ...(inheritedElapsedMs !== undefined ? { accumulatedDurationMs: inheritedElapsedMs } : {}),
   };
 
   const classifiedFailures = new Map<unknown, WorkflowFailure>();
@@ -146,6 +158,7 @@ export async function run<
       ...(runSnapshot.rootRunId !== undefined ? { rootRunId: runSnapshot.rootRunId } : {}),
       ...(runSnapshot.resumedFromRunId !== undefined ? { resumedFromRunId: runSnapshot.resumedFromRunId } : {}),
       ...(runSnapshot.resumeFromStageId !== undefined ? { resumeFromStageId: runSnapshot.resumeFromStageId } : {}),
+      ...(runSnapshot.accumulatedDurationMs !== undefined ? { accumulatedDurationMs: runSnapshot.accumulatedDurationMs } : {}),
       ts: runSnapshot.startedAt,
     });
   }
@@ -185,16 +198,6 @@ export async function run<
     classifyExecutorFailure,
     drainWorkflowExitCleanups: exit.drainWorkflowExitCleanups,
   });
-  // Durable workflow backend — registers this run and wires ctx.tool/ui/stage.
-  // Declared early so the stage-end recorder can attach to stageOptions.
-  // cross-ref: issue #1498 — DBOS-backed cross-session resumability.
-  // Child runs with a durable scope route their internal side-effect
-  // checkpoints under the root workflow so interrupted children do not
-  // re-execute completed side effects on parent resume.
-  const rootBackend: DurableWorkflowBackend = opts.durableBackend ?? getDurableBackend();
-  const durableBackend: DurableWorkflowBackend = opts.durableScope !== undefined
-    ? new ScopedDurableBackend(rootBackend, opts.durableScope)
-    : rootBackend;
   const checkpointIdGenerator = createCheckpointIdGenerator();
   const stageReplayKeyGenerator = createStageReplayKeyGenerator(runId);
   const completedStageReplayKeys = new Map<string, string>();
@@ -209,14 +212,13 @@ export async function run<
   const durableOnStageEnd = async (stageRunId: string, snapshot: StageSnapshot): Promise<void> => {
     if (stageRunId === runId && snapshot.status === "completed") {
       await recordStageCheckpoint(durableStageDeps, snapshot);
-      if (opts.persistence && durableBackend.persistent) {
-        const cacheEntry = durableBackend.toCacheEntry(runId);
-        if (cacheEntry) persistDurableCacheEntry(opts.persistence, cacheEntry);
-      }
     }
     await userOnStageEnd?.(stageRunId, snapshot);
   };
-  const durableOnStageSession = createDurableStageSessionRecorder({ runId, deps: durableStageDeps, backend: durableBackend, persistence: opts.persistence, onStageSession: opts.onStageSession });
+  const durableOnStageSession = createDurableStageSessionRecorder({
+    runId, deps: durableStageDeps, onStageSession: opts.onStageSession,
+    ...(opts.parentRun === undefined ? { runSnapshot } : {}),
+  });
   const stageOptions: EngineStageRuntimeOptions = {
     continuation: opts.continuation,
     models: opts.models,
@@ -273,6 +275,7 @@ export async function run<
     inputRuntimeDefaults,
     workflowInvocationCwd,
     stageRegistry, gitWorktreeSetupCache,
+    worktreeSymlinkDirectories: opts.config?.worktree?.symlinkDirectories,
     exit,
     classifyExecutorFailure,
   });
@@ -321,11 +324,8 @@ export async function run<
     resumable: true,
     ...(opts.persistence !== undefined ? { sessionFile: undefined } : {}),
   };
-  if (opts.continuation === undefined && opts.parentRun === undefined) {
-    durableBackend.registerWorkflow({ ...durableRootWorkflowRegistration, invocationCwd: workflowInvocationCwd });
-  } else if (opts.parentRun === undefined) {
-    durableBackend.setWorkflowStatus(runId, "running");
-  }
+  const shouldRegisterDurableRoot = opts.parentRun === undefined
+    && (opts.continuation === undefined || opts.continuation.source.id !== runId);
   const tool = createToolPrimitive({
     workflowId: runId,
     backend: durableBackend,
@@ -365,6 +365,7 @@ export async function run<
         runId,
         activeStore,
         opts,
+        stageControlRegistry: stageRegistry,
         tracker,
         replayIndex,
         signal: ownController.signal,
@@ -406,11 +407,13 @@ export async function run<
       }
     }
 
-    if (opts.continuation === undefined && opts.parentRun === undefined) {
+    if (shouldRegisterDurableRoot) {
       durableBackend.registerWorkflow({ ...durableRootWorkflowRegistration, ...workflowInvocationMetadata(inputRuntimeDefaults, workflowInvocationCwd, gitWorktreeSetupCache) });
+    } else if (opts.parentRun === undefined) {
+      durableBackend.setWorkflowStatus(runId, "running");
     }
-
-    const rawResult = await def.run(ctx);
+    if (opts.deferWorkflowStart === true) opts.onWorkflowStartReady?.();
+    const rawResult = await runWorkflowDefinitionCallback(def.name, runId, () => def.run(ctx));
     if (ownController.signal.aborted) {
       const selectedExit = findWorkflowExitSignal(ownController.signal.reason, exitScope);
       if (selectedExit !== undefined) return await finalizers.finalizeWorkflowExit(selectedExit);
@@ -422,16 +425,12 @@ export async function run<
     const result = normalizeWorkflowRunOutput(def.name, rawResult);
     assertWorkflowRunOutputs(def.name, result, def.outputs);
     assertWorkflowCreatedStage(runSnapshot);
-    await durableBackend.flush?.();
+    await durableBackend.flush();
     const returned = classifyReturnedRunStatus(result, runSnapshot);
     const recorded = activeStore.recordRunEnd(runId, returned.status, result, returned.error, returned.metadata);
     appendRunEndWhenRecorded(opts.persistence, recorded, { runId, status: returned.status, result, ...(returned.error !== undefined ? { error: returned.error } : {}), ...(returned.metadata ?? {}), ...(runSnapshot.endedAt !== undefined ? { endedAt: runSnapshot.endedAt } : {}), ...(runSnapshot.durationMs !== undefined ? { durationMs: runSnapshot.durationMs } : {}), ts: Date.now() });
     durableBackend.setWorkflowStatus(runId, returned.status, undefined, returned.metadata?.resumable);
-    await durableBackend.flush?.();
-    if (opts.persistence && durableBackend.persistent) {
-      const cacheEntry = durableBackend.toCacheEntry(runId);
-      if (cacheEntry) persistDurableCacheEntry(opts.persistence, cacheEntry);
-    }
+    await durableBackend.flush();
     return reconcileTerminalRunResult(runId, runSnapshot, activeStore, { status: returned.status, result, error: returned.error }, opts.onRunEnd);
   } catch (err) {
     const selectedExit = findWorkflowExitSignal(err, exitScope) ?? findWorkflowExitSignal(ownController.signal.reason, exitScope);
@@ -444,12 +443,12 @@ export async function run<
     }
 
     const failure = classifyExecutorFailure(err);
-    const metadata = selectRunFailureDisposition({
+    const metadata = normalizeStageLessFailureMetadata(selectRunFailureDisposition({
       outerFailure: failure,
       thrownError: err,
       stages: runSnapshot.stages,
       classifyFailure: classifyExecutorFailure,
-    });
+    }), runSnapshot.stages.length);
 
     if (metadata.failureDisposition === "terminal_killed") {
       for (const failedStageId of metadata.failedStageIds) scheduler.blockKnownNonTerminalDescendants(failedStageId);
@@ -491,7 +490,6 @@ export async function run<
         runSnapshot,
         isRoot: opts.parentRun === undefined,
         durableBackend,
-        persistence: opts.persistence,
       });
     } finally {
       gitWorktreeSetupCacheOwner.release(() => opts.cancellation?.unregister(runId));

package/dist/builtin/workflows/src/engine/runtime.ts

@@ -33,6 +33,7 @@ export interface EngineRuntimeInput {
   readonly inputRuntimeDefaults: Partial<StageOptions>;
   readonly workflowInvocationCwd: string;
   readonly gitWorktreeSetupCache: GitWorktreeSetupCache;
+  readonly worktreeSymlinkDirectories?: readonly string[];
   readonly stageRegistry: StageControlRegistry;
   readonly exit: WorkflowExitManager;
   readonly classifyExecutorFailure: LiveStageRuntime["classifyExecutorFailure"];
@@ -76,6 +77,7 @@ export class EngineRuntime {
   readonly inputRuntimeDefaults: Partial<StageOptions>;
   readonly workflowInvocationCwd: string;
   readonly gitWorktreeSetupCache: GitWorktreeSetupCache;
+  readonly worktreeSymlinkDirectories?: readonly string[];
 
   private readonly spawnAgentStage: (
     name: string,
@@ -97,6 +99,7 @@ export class EngineRuntime {
     this.inputRuntimeDefaults = input.inputRuntimeDefaults;
     this.workflowInvocationCwd = input.workflowInvocationCwd;
     this.gitWorktreeSetupCache = input.gitWorktreeSetupCache;
+    this.worktreeSymlinkDirectories = input.worktreeSymlinkDirectories;
 
     // The runtime only wires host-injected ports; stage sessions are still
     // created lazily by the stage runner through input.adapters.agentSession.

package/dist/builtin/workflows/src/engine/workflow-activity.ts

@@ -0,0 +1,9 @@
+import { runCallback } from "@bastani/atomic";
+
+export function nextEventLoopTurn(): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+export function runWorkflowDefinitionCallback<T>(name: string, runId: string, callback: () => T | Promise<T>): Promise<T> {
+  return runCallback({ kind: "workflow.run", name, runId }, callback);
+}

package/dist/builtin/workflows/src/extension/completed-stage-intercom-ask.ts

@@ -0,0 +1,155 @@
+import type { StageControlHandle } from "../runs/foreground/stage-control-registry.js";
+import type {
+  EnsurePostMortemStageHandleResult,
+  PostMortemUnavailableReason,
+} from "../runs/foreground/postmortem-stage-chat.js";
+
+const LATE_STAGE_MESSAGE_EVENT = "atomic:workflow-stage-late-message";
+const POST_MORTEM_ATTACH_TIMEOUT_MS = 10_000;
+
+interface IntercomAskMessage {
+  readonly customType: "intercom_message";
+  readonly content: string;
+  readonly details?: {
+    readonly message?: {
+      readonly expectsReply?: boolean;
+    };
+  };
+}
+
+interface CompletedStageAskEvent {
+  handled: boolean;
+  completion?: Promise<void>;
+  readonly batch: boolean;
+  readonly workflowRunId?: string;
+  readonly workflowStageId?: string;
+  readonly messages: readonly IntercomAskMessage[];
+}
+
+interface WorkflowEventSurface {
+  readonly events?: {
+    on?(event: string, listener: (payload: unknown) => void): (() => void) | void;
+  };
+  on?(event: "session_shutdown", listener: () => void): void;
+}
+
+export type CompletedStageHandleResolver = (
+  runId: string,
+  stageId: string,
+) => EnsurePostMortemStageHandleResult | undefined;
+
+/**
+ * Claims late blocking Intercom asks for completed workflow stages and runs one
+ * post-mortem turn in the retained conversation. Ordinary late notifications
+ * keep using the existing parent-chat route.
+ */
+export function registerCompletedStageIntercomAskRouter(
+  pi: WorkflowEventSurface,
+  resolveHandle: CompletedStageHandleResolver,
+): () => void {
+  const queues = new Map<string, Promise<void>>();
+  let disposed = false;
+  const unsubscribe = pi.events?.on?.(LATE_STAGE_MESSAGE_EVENT, (payload) => {
+    if (disposed || !isCompletedStageAskEvent(payload) || payload.handled === true) return;
+    payload.handled = true;
+    payload.completion = enqueueTargetTurn(
+      queues,
+      `${payload.workflowRunId}:${payload.workflowStageId}`,
+      () => deliverAsPostMortemTurn(payload, resolveHandle),
+    );
+  });
+  const dispose = (): void => {
+    disposed = true;
+    queues.clear();
+    unsubscribe?.();
+  };
+  pi.on?.("session_shutdown", dispose);
+  return dispose;
+}
+
+function isCompletedStageAskEvent(payload: unknown): payload is CompletedStageAskEvent & {
+  readonly workflowRunId: string;
+  readonly workflowStageId: string;
+} {
+  if (typeof payload !== "object" || payload === null) return false;
+  const event = payload as Partial<CompletedStageAskEvent>;
+  return typeof event.workflowRunId === "string"
+    && event.workflowRunId.length > 0
+    && typeof event.workflowStageId === "string"
+    && event.workflowStageId.length > 0
+    && Array.isArray(event.messages)
+    && event.messages.length > 0
+    && event.messages.every((message) =>
+      message?.customType === "intercom_message"
+      && typeof message.content === "string"
+      && message.details?.message?.expectsReply === true,
+    );
+}
+
+function enqueueTargetTurn(
+  queues: Map<string, Promise<void>>,
+  key: string,
+  deliver: () => Promise<void>,
+): Promise<void> {
+  const previous = queues.get(key) ?? Promise.resolve();
+  const current = previous.catch(() => {}).then(deliver);
+  queues.set(key, current);
+  void current.finally(() => {
+    if (queues.get(key) === current) queues.delete(key);
+  }).catch(() => {});
+  return current;
+}
+
+async function deliverAsPostMortemTurn(
+  event: CompletedStageAskEvent & { readonly workflowRunId: string; readonly workflowStageId: string },
+  resolveHandle: CompletedStageHandleResolver,
+): Promise<void> {
+  const resolution = resolveHandle(event.workflowRunId, event.workflowStageId);
+  if (resolution === undefined) {
+    throw new Error(
+      `Intercom ask target is unavailable: completed workflow stage ${event.workflowRunId}/${event.workflowStageId} was deleted or is no longer retained.`,
+    );
+  }
+  if (!resolution.ok) {
+    throw new Error(unavailableReason(event.workflowRunId, event.workflowStageId, resolution.reason));
+  }
+  const handle = resolution.handle;
+  if (handle.status !== "completed" || handle.isDisposed === true) {
+    throw new Error(
+      `Intercom ask target is not resumable: workflow stage ${event.workflowRunId}/${event.workflowStageId} has no retained completed conversation.`,
+    );
+  }
+  await attachWithTimeout(handle);
+  for (const message of event.messages) {
+    if (handle.isStreaming) await handle.followUp(message.content);
+    else await handle.prompt(message.content);
+  }
+}
+
+async function attachWithTimeout(handle: StageControlHandle): Promise<void> {
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  const bounded = new Promise<never>((_, reject) => {
+    timeout = setTimeout(() => reject(new Error(
+      `Intercom ask target failed to resume within ${POST_MORTEM_ATTACH_TIMEOUT_MS}ms: retained stage conversation ${handle.runId}/${handle.stageId}.`,
+    )), POST_MORTEM_ATTACH_TIMEOUT_MS);
+  });
+  try {
+    await Promise.race([handle.ensureAttached(), bounded]);
+  } finally {
+    if (timeout !== undefined) clearTimeout(timeout);
+  }
+}
+
+function unavailableReason(runId: string, stageId: string, reason: PostMortemUnavailableReason): string {
+  const target = `${runId}/${stageId}`;
+  switch (reason) {
+    case "not_terminal":
+      return `Intercom ask target is not resumable: workflow stage ${target} is not a completed stage with a retained conversation.`;
+    case "no_session":
+      return `Intercom ask target is unavailable: completed workflow stage ${target} has no retained conversation.`;
+    case "invalid_session":
+      return `Intercom ask target is unavailable: retained conversation for completed workflow stage ${target} is missing, deleted, or invalid.`;
+    case "no_adapter":
+      return `Intercom ask target is not resumable: no workflow stage session adapter can reopen ${target}.`;
+  }
+}

package/dist/builtin/workflows/src/extension/config-file-loader.ts

@@ -73,6 +73,19 @@ function validateConfig(value: unknown): string | null {
       }
     }
   }
+  if ("worktree" in c) {
+    const worktree = c["worktree"];
+    if (worktree === null || typeof worktree !== "object" || Array.isArray(worktree)) {
+      return `"worktree" must be a JSON object, got ${JSON.stringify(typeof worktree)}`;
+    }
+    const config = worktree as Record<string, unknown>;
+    if ("symlinkDirectories" in config) {
+      const directories = config["symlinkDirectories"];
+      if (!Array.isArray(directories) || directories.some((entry) => typeof entry !== "string")) {
+        return `"worktree.symlinkDirectories" must be an array of strings`;
+      }
+    }
+  }
 
   if ("workflows" in c) {
     if (c["workflows"] === null || typeof c["workflows"] !== "object" || Array.isArray(c["workflows"])) {

package/dist/builtin/workflows/src/extension/config-loader.ts

@@ -42,6 +42,10 @@ export interface WorkflowNotificationsConfig {
   readonly notifyOn?: readonly WorkflowLifecycleNoticeKind[];
 }
 
+export interface WorkflowWorktreeConfig {
+  /** Main-root directories symlinked into temporary worktrees. */
+  readonly symlinkDirectories?: readonly string[];
+}
 export interface WorkflowExtensionConfig {
   /** Explicit named workflows to register by module path. */
   readonly workflows?: Readonly<Record<string, WorkflowConfigEntry>>;
@@ -57,6 +61,8 @@ export interface WorkflowExtensionConfig {
   readonly resumeInFlight?: "ask" | "auto" | "never";
   /** Main-chat workflow lifecycle notices. */
   readonly workflowNotifications?: WorkflowNotificationsConfig;
+  /** Temporary-worktree post-creation settings. */
+  readonly worktree?: WorkflowWorktreeConfig;
 }
 
 /** Severity of a config diagnostic. */
@@ -159,6 +165,9 @@ function mergeConfigs(
           },
         }
       : {}),
+    ...(base.worktree !== undefined || override.worktree !== undefined
+      ? { worktree: { ...(base.worktree ?? {}), ...(override.worktree ?? {}) } }
+      : {}),
     ...(workflows !== undefined ? { workflows } : {}),
   };
 }
@@ -184,6 +193,9 @@ export const WORKFLOW_CONFIG_DEFAULTS = {
     enabled: true,
     notifyOn: ["completed", "failed", "blocked", "awaiting_input"] as const,
   },
+  worktree: {
+    symlinkDirectories: ["node_modules"] as readonly string[],
+  },
 } as const;
 
 /**
@@ -200,6 +212,9 @@ export interface WorkflowEffectiveConfig {
     readonly enabled: boolean;
     readonly notifyOn: readonly WorkflowLifecycleNoticeKind[];
   };
+  readonly worktree: {
+    readonly symlinkDirectories: readonly string[];
+  };
   readonly workflows?: Readonly<Record<string, WorkflowConfigEntry>>;
 }
 
@@ -228,6 +243,11 @@ export function withWorkflowDefaults(
         config.workflowNotifications?.notifyOn
         ?? WORKFLOW_CONFIG_DEFAULTS.workflowNotifications.notifyOn,
     },
+    worktree: {
+      symlinkDirectories:
+        config.worktree?.symlinkDirectories
+        ?? WORKFLOW_CONFIG_DEFAULTS.worktree.symlinkDirectories,
+    },
     ...(config.workflows !== undefined ? { workflows: config.workflows } : {}),
   };
 }

package/dist/builtin/workflows/src/extension/dispatcher.ts

@@ -13,10 +13,12 @@ import { store as defaultStore, type Store } from "../shared/store.js";
 import type { CancellationRegistry } from "../runs/background/cancellation-registry.js";
 import { jobTracker as defaultJobTracker, type JobTracker } from "../runs/background/job-tracker.js";
 import { resolveAndValidateInputs } from "../runs/foreground/executor.js";
-import { runDetached } from "../runs/background/runner.js";
+import { launchDetachedUntilStartup, workflowStartupFailureMessage } from "../runs/background/startup-admission.js";
 import type { WorkflowToolResult, WorkflowInputEntry } from "./render-result.js";
 import { deriveInputFields, schemaIsRequired } from "../shared/schema-introspection.js";
+import { effectiveRunStatus } from "../shared/returned-run-status.js";
 import type { WorkflowToolArgs } from "./index.js";
+import { getDurableBackend } from "../durable/factory.js";
 import {
   INTERACTIVE_WORKFLOW_POLICY,
   type WorkflowExecutionPolicy,
@@ -38,6 +40,19 @@ function failedRunResult(name: string | undefined, runId: string, error: string)
     stages: [],
   };
 }
+async function discardUnadmittedRun(runId: string, activeStore: Store): Promise<void> {
+  activeStore.removeRun(runId);
+  const backend = getDurableBackend();
+  const handle = backend.getWorkflow(runId);
+  if (handle?.status === "running") {
+    backend.setWorkflowStatus(runId, "failed", handle.pendingPrompts, false);
+    await backend.flush();
+  }
+  const deleted = await backend.deleteWorkflowIfInactive(runId);
+  if (!deleted.ok && deleted.reason !== "not_found") {
+    throw new Error(`workflow ${runId} remained ${deleted.reason}`);
+  }
+}
 
 // ---------------------------------------------------------------------------
 // Options
@@ -163,20 +178,44 @@ export async function dispatch(
         );
       }
 
-      const accepted = runDetached(def, inputs, {
-        registry: opts.registry,
-        adapters: opts.adapters,
-        store: opts.store,
-        cancellation: opts.cancellation,
-        jobs: opts.jobs,
-        persistence: opts.persistence,
-        mcp: opts.mcp,
-        config: opts.config,
-        models: opts.models,
-        executionMode: policy.mode,
-        cwd: opts.cwd,
-        defaultSessionDir: opts.defaultSessionDir,
-      });
+      const runId = crypto.randomUUID();
+      let launch: ReturnType<typeof launchDetachedUntilStartup>;
+      try {
+        launch = launchDetachedUntilStartup(def, inputs, {
+          registry: opts.registry,
+          adapters: opts.adapters,
+          store: opts.store,
+          cancellation: opts.cancellation,
+          jobs: opts.jobs,
+          persistence: opts.persistence,
+          mcp: opts.mcp,
+          config: opts.config,
+          models: opts.models,
+          executionMode: policy.mode,
+          cwd: opts.cwd,
+          defaultSessionDir: opts.defaultSessionDir,
+          runId,
+        });
+      } catch (error) {
+        return failedRunResult(def.name, runId, error instanceof Error ? error.message : String(error));
+      }
+      const { accepted } = launch;
+      const admission = await launch.wait;
+      if (!admission.started) {
+        const activeStore = opts.store ?? defaultStore;
+        const snapshot = activeStore.runs().find((run) => run.id === accepted.runId);
+        const error = workflowStartupFailureMessage(
+          admission,
+          snapshot?.error,
+          `Workflow run ${accepted.runId} ended before startup admission`,
+        );
+        try {
+          await discardUnadmittedRun(accepted.runId, activeStore);
+        } catch (cleanupError) {
+          return failedRunResult(accepted.name, accepted.runId, `${error}; startup cleanup failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+        }
+        return failedRunResult(accepted.name, accepted.runId, error);
+      }
       if (policy.awaitTerminalRun === true) {
         const tracker = opts.jobs ?? defaultJobTracker;
         const job = tracker.get(accepted.runId);
@@ -201,7 +240,7 @@ export async function dispatch(
           action: "run",
           name: snapshot.name,
           runId: snapshot.id,
-          status: snapshot.status,
+          status: effectiveRunStatus(snapshot),
           result: snapshot.result,
           error: snapshot.error,
           exited: snapshot.exited,
@@ -220,7 +259,7 @@ export async function dispatch(
     }
 
     default:
-      // status/kill/resume are not routed here; unknown actions are bugs.
+      // Status and run-control actions are not routed here; unknown actions are bugs.
       throw new Error(`WorkflowDispatcher: unknown action "${action}"`);
   }
 }

package/dist/builtin/workflows/src/extension/extension-factory.ts

@@ -1,4 +1,3 @@
-import { quitRun } from "../runs/background/quit.js";
 import { store } from "../shared/store.js";
 import { subscribeIntercomControl } from "../intercom/result-intercom.js";
 import { buildIntercomCallbacks } from "../intercom/intercom-routing.js";
@@ -15,6 +14,9 @@ import { createWorkflowExtensionRuntimeState } from "./extension-runtime-state.j
 import { registerWorkflowLifecycleHandlers } from "./extension-lifecycle.js";
 import { dynamicTextRenderComponent } from "./render-component.js";
 import { makeExecuteWorkflowTool } from "./workflow-tool.js";
+import { createPostMortemHandleResolver, postMortemDepsForRun } from "./postmortem-deps.js";
+import { registerCompletedStageIntercomAskRouter } from "./completed-stage-intercom-ask.js";
+import type { PostMortemHandleResolution } from "../tui/workflow-attach-pane-types.js";
 import { registerWorkflowTool } from "./workflow-tool-registration.js";
 import { registerWorkflowSlashCommand } from "./workflow-command-registration.js";
 import { installInputInterceptor, type WorkflowCommandHandler } from "./workflow-command-utils.js";
@@ -34,13 +36,9 @@ function registerWorkflowMessageRenderers(pi: ExtensionAPI): void {
 
 function buildWorkflowOverlay(
   pi: ExtensionAPI,
+  resolvePostMortemHandle: (runId: string, stageId: string) => PostMortemHandleResolution,
 ): GraphOverlayPort {
-  return buildGraphOverlayAdapter(pi, store, {
-    onQuitRun: (runId) => {
-      quitRun(runId, { store });
-      pi.ui?.notify?.(`Workflow quit; resume with /workflow resume.`, "info");
-    },
-  });
+  return buildGraphOverlayAdapter(pi, store, { resolvePostMortemHandle });
 }
 
 function registerWorkflowShortcut(pi: ExtensionAPI, overlay: GraphOverlayPort): void {
@@ -77,15 +75,21 @@ function registerIntercomControl(
 function factory(pi: ExtensionAPI): void {
   const adapters = buildRuntimeAdapters(pi);
   const runtimeState = createWorkflowExtensionRuntimeState(pi, adapters);
-  const overlay = buildWorkflowOverlay(pi);
+  const postMortemResolverDeps = {
+    adapters,
+    resolveDefaultStageSessionDir: runtimeState.resolveDefaultStageSessionDir,
+  };
+  const postMortemHandleResolver = createPostMortemHandleResolver(postMortemResolverDeps);
+  const overlay = buildWorkflowOverlay(pi, postMortemHandleResolver);
+  registerCompletedStageIntercomAskRouter(pi, postMortemHandleResolver);
   const workflowCommands = new Map<string, WorkflowCommandHandler>();
   const storeWidgetRef: { current: (() => void) | null } = { current: null };
   const intercomControlRef: { current: (() => void) | null } = { current: null };
   const executeWorkflowTool = makeExecuteWorkflowTool(
     (ctx) => runtimeState.runtimeForContext(ctx),
-    () => runtimeState.persistenceRef.current,
     runtimeState.reloadWorkflowResources,
     runtimeState.ensureWorkflowResourcesLoaded,
+    { resolvePostMortemDeps: (runId) => postMortemDepsForRun(runId, postMortemResolverDeps) },
   );
 
   registerWorkflowTool(pi, executeWorkflowTool, runtimeState.runWithLifecycleSuppressedForPolicy);
@@ -99,7 +103,6 @@ function factory(pi: ExtensionAPI): void {
     runControl: {
       pi,
       overlay,
-      getPersistence: () => runtimeState.persistenceRef.current,
       runtimeForContext: runtimeState.runtimeForContext,
       ensureWorkflowResourcesLoaded: runtimeState.ensureWorkflowResourcesLoaded,
     },