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

package/dist/builtin/workflows/builtin/shared-prompts.ts

@@ -23,7 +23,7 @@ export function renderE2eQaVideoReviewGuidance(
   knownVideoPath?: string,
 ): string {
   const target = knownVideoPath === undefined || knownVideoPath.length === 0
-    ? "Look for QA E2E video references in the goal ledger, worker receipt, implementation notes, orchestrator report, or other review context artifacts."
+    ? "Look for QA E2E video references in the goal ledger, implementation receipt, implementation notes, orchestrator report, or other review context artifacts."
     : `Known QA E2E video path for this run: ${knownVideoPath}`;
   return [
     target,
@@ -31,7 +31,7 @@ export function renderE2eQaVideoReviewGuidance(
     "Use available video/file tooling such as `fetch_content` on the local video path with a prompt focused on whether the recording proves the required user scenario, or inspect representative frames/metadata when full video analysis is unavailable.",
     "Check that the video reflects the current repository/application state, exercises the objective-relevant user path, shows the expected final behavior, and does not visibly hide errors, stale UI, broken loading states, or skipped steps.",
     "For UI-applicable or full-stack changes, treat a missing, stale, unreadable, or inconclusive QA video as missing E2E evidence unless the receipt or implementation notes justify why no video applies and provide adequate alternate end-to-end proof.",
-    "Treat skipped E2E due to assumed-missing credentials, auth, or environment access as missing evidence unless the worker actually checked credential/auth state, attempted the launch/flow, and reported exact commands plus observed failure output.",
+    "Treat skipped E2E due to assumed-missing credentials, auth, or environment access as missing evidence unless the implementation agent actually checked credential/auth state, attempted the launch/flow, and reported exact commands plus observed failure output.",
   ].join("\n");
 }
 
@@ -55,7 +55,7 @@ export const REVIEWER_SPEC_VS_OBJECTIVE_GUARD =
   "Do not use external spec/standard conformance alone to flag a wide trigger surface for an error condition the objective/acceptance criteria enumerate; the contract prefers loud errors over silent reinterpretation of ambiguous inputs, so classify such spec-vs-objective tension as beyond_objective rather than a blocking defect.";
 
 export const REVIEWER_OVERIMPLEMENTATION_GUARD =
-  "Hunt over-implementation as seriously as gaps: any validation error, required field, uniqueness/format constraint, immutability wrapper, or normalization the contract does not require is a defect that rejects inputs or produces shapes the contract permits — classify it required_by_objective. Probe at least one contract-permitted input the worker's own tests do not exercise before approving.";
+  "Hunt over-implementation as seriously as gaps: any validation error, required field, uniqueness/format constraint, immutability wrapper, or normalization the contract does not require is a defect that rejects inputs or produces shapes the contract permits — classify it required_by_objective. Probe at least one contract-permitted input the implementation's own tests do not exercise before approving.";
 
 export const ACCEPTANCE_MATRIX_CONTRACT = [
   "Acceptance/contract matrix:",
@@ -87,10 +87,24 @@ export const REVIEWER_INTERCOM_COORDINATION_PROTOCOL = [
 
 export const REVIEWER_INDEPENDENT_VERIFICATION_CONTRACT = [
   "Independent verification derivation:",
-  "- Before relying on the worker receipt, worker-authored tests, or any prior reviewer output, derive your own adversarial check list from the literal objective and acceptance criteria alone: per-clause observable checks plus boundary, edge, negative, and invalid-input probes; contract-permitted-input probes (permissive inputs the implementation might wrongly reject: optional fields omitted, duplicates or aliases present, unusual-but-allowed values) and exact type/shape/text-identity probes for anything the contract names; and state/transition/invariant probes for stateful behavior.",
-  "- Execute or delegate the highest-value derived checks against the current repository state before mapping worker evidence to requirements.",
-  "- Worker-authored tests, snapshots, and receipts corroborate your derived checks; they never substitute for them. Passing worker-authored tests is circular evidence for the clauses those tests were written from.",
-  "- Keep derived checks inside the literal contract's scope; do not manufacture requirements beyond the objective/acceptance criteria.",
+  "- Before relying on the implementation receipt, implementation-authored tests, or any prior reviewer output, derive your own adversarial check list from the literal objective and acceptance criteria alone: per-clause observable checks plus boundary, edge, negative, and invalid-input probes; contract-permitted-input probes; exact type/shape/text-identity probes; and state/transition/invariant probes.",
+  "- Apply this conditional contract-probe playbook when supported by the contract and repository:",
+  "  - Exact public API/type contracts: create a minimal external-consumer compile or typecheck probe using the names, parameter types, return types, field types, pointer/value identity, and method shapes stated by the objective.",
+  "  - Build tags/features/configuration variants: exercise every named positive and negative build-tag, feature, or configuration variant; prove required symbols compile and forbidden symbols are unavailable.",
+  "  - Schemas and generated artifacts: regenerate or inspect the authoritative schema, probe omitted and zero-value fields, and verify required-versus-optional behavior and downstream representation match the literal contract.",
+  "  - Stateful behavior: enumerate relevant states and mutation paths and exercise the transition matrix, not only happy-path end states; for boolean membership or predicate behavior this includes false→false, false→true, true→false, and true→true when applicable.",
+  "  - Configurable paths and precedence: use temporary or injected paths, changed working directories, and relevant environment or configuration overrides; verify initialization and defaults do not overwrite caller-controlled state.",
+  "  - Low-level APIs versus feature flags: exercise direct loaders, parsers, or validators with the surrounding feature both enabled and disabled unless the literal low-level API contract explicitly makes that flag authoritative.",
+  "  - Permissive inputs and over-implementation: probe at least one contract-permitted omitted, empty, zero, duplicate, aliased, or unusual value that an implementation may have made unnecessarily invalid.",
+  "- Select only the risk classes supported by the literal objective and repository context. These are generic risk classes, not hidden test cases; do not manufacture requirements outside the literal contract.",
+  "- Execute or delegate every applicable material probe against the current repository state before mapping implementation evidence to requirements. Name each command or scenario and its observed result in the existing narrative and requirements_traceability fields.",
+  "- Implementation-authored tests, snapshots, and receipts corroborate your derived checks; they never substitute for them. Passing implementation-authored tests is circular evidence for the clauses those tests were written from. Repository-local or implementation-authored tests are not sufficient evidence for an exact API, build, or schema clause without the applicable independent compile, type, build-variant, or schema probe.",
+  "- A compile, type, build, or schema requirement without its applicable independent probe remains unverified: keep its requirements_traceability status missing, explain the gap, add an objective-aligned finding when the patch is materially deficient, and set stop_review_loop=false.",
+  "- When an applicable material probe is missing, blocked, or failed, record the command or scenario and its observed result or limitation in overall_explanation and requirements_traceability, use the workflow's existing remaining-verification or finding fields, and set stop_review_loop=false. When tools or dependencies prevent necessary verification after reasonable recovery, populate the existing reviewer_error field instead of approving around the limitation.",
+  "",
+  "Pre-verdict self-audit:",
+  "- Before returning stop_review_loop=true, confirm overall_correctness is patch is correct; every objective-relevant implementation and validation requirements_traceability entry is proven; no blocking objective-aligned finding remains; every applicable exact API, build, schema, state, configuration, and feature-flag risk has direct evidence or a clear explanation of why it does not apply; and reviewer_error is null or omitted.",
+  "- If any item in this self-audit is false or unverified, set stop_review_loop=false and report the gap through the existing fields; never make the structured verdict internally inconsistent.",
 ].join("\n");
 
 export const REGRESSION_EVIDENCE_CONTRACT = [
@@ -114,3 +128,19 @@ export const EVIDENCE_CLOSURE_POLICY = [
   "- Derive stop_review_loop=true when independent verification proves the implementation and validation requirements and everything left is non-blocking: consistent_with_objective P3 nice-to-haves, beyond_objective/contradicts_objective observations, an explicitly authorized post-approval final action such as PR/MR/review creation, or the multi-reviewer quorum process itself. Never hold the flag at false for those items — quorum is counted by the harness across reviewers and is not an implementation gap any single reviewer can prove.",
   "- The loop is bounded: when the turn budget ends before convergence, the run stops with the unresolved findings and remaining work recorded for a human instead of relabeling them away.",
 ].join("\n");
+
+export const WORKTREE_DISCIPLINE_CONTRACT = [
+  "Worktree discipline:",
+  "- Do all work in the working directory this stage was invoked in (the workflow-designated checkout/worktree).",
+  "- Never create additional git worktrees, clones, or repository copies unless the user's task explicitly requests them; a merge conflict, a locked file, a dirty tree, or a failed command is not such a request.",
+  "- If you discover required work stranded in another worktree, clone, or copy, bring it into the invoking checkout (apply, cherry-pick, or replay the changes) before continuing; work left outside the invoking checkout does not exist for review or delivery.",
+].join("\n");
+
+export const REVIEW_CODE_DELTA_CONTRACT = [
+  "Code delta presence and integrity:",
+  "- Review the actual code delta, and first prove that delta exists where the workflow delivers it: in the invoking working directory, or in the explicitly configured git worktree when the run was set up with one.",
+  "- Use the repository's version-control tooling to inspect state (for git: `git worktree list`, `git status --short`, and a diff against the baseline branch; use the equivalent commands for other systems). If receipts, implementation notes, or stage summaries claim implemented work but the review checkout shows no corresponding delta, that is a blocking [P0] required_by_objective finding: the work may be stranded in another worktree, clone, or unapplied state. Do not approve; require the work to be brought into the review checkout first.",
+  "- Never set stop_review_loop=true for an implementation objective when the review checkout's delta is empty or unrelated to that objective; an empty delta cannot satisfy an implementation objective regardless of what receipts claim.",
+  "- Unless the objective explicitly forbids committing, treat uncommitted work at claimed readiness as remaining work: require the implementation to be committed (or outstanding changes intentionally discarded) so the delivered state is durable.",
+  "- Treat any modification, rename, or deletion of pre-existing test files or test functions in the delta as a finding requiring explicit justification against the literal contract; validating against existing tests means running them, not editing them.",
+].join("\n");

package/dist/builtin/workflows/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/workflows",
-  "version": "0.9.11-alpha.3",
+  "version": "0.9.11-alpha.5",
   "private": true,
   "description": "Atomic extension for multi-stage workflow authoring and execution.",
   "contributors": [
@@ -67,7 +67,7 @@
   },
   "pi": {
     "extensions": [
-      "./src/extension/index.ts"
+      "./src/extension/index.bundle.mjs"
     ],
     "builtin": [
       "./builtin"

package/dist/builtin/workflows/src/authoring/workflow.ts

@@ -169,6 +169,7 @@ export function workflow<
     name,
     normalizedName,
     description: spec.description,
+    ...(spec.autoAttach === true ? { autoAttach: true } : {}),
     inputs: frozenInputs,
     outputs: frozenOutputs,
     ...(inputBindings !== undefined ? { inputBindings } : {}),

package/dist/builtin/workflows/src/durable/dbos-lifecycle.ts

@@ -15,7 +15,8 @@ export type DbosLifecycleState =
   | "launching"
   | "ready"
   | "failed"
-  | "shutting_down";
+  | "shutting_down"
+  | "shut_down";
 
 export class DbosDurabilityError extends Error {
   constructor(message: string, options?: ErrorOptions) {
@@ -30,6 +31,16 @@ export class DbosNotReadyError extends DbosDurabilityError {
     this.name = "DbosNotReadyError";
   }
 }
+
+export class DbosShutdownError extends DbosDurabilityError {
+  constructor() {
+    super(
+      "DBOS workflow durability has been shut down in this process. "
+      + "Durable workflows can no longer start; restart Atomic to restore durability.",
+    );
+    this.name = "DbosShutdownError";
+  }
+}
 type DbosConfigurator = () => Promise<ConfiguredDbosDurability>;
 type LocalDbosProvisioner = () => Promise<void>;
 
@@ -78,6 +89,10 @@ export async function configureDbosOnce(): Promise<ConfiguredDbosDurability> {
 
 export async function launchDbosOnce(): Promise<void> {
   if (failure !== undefined) throw failure;
+  // The executor is process-scoped and stops exactly once, at process exit.
+  // Post-shutdown launches must fail loudly instead of returning a backend
+  // whose SDK launched marker has been cleared.
+  if (state === "shutting_down" || state === "shut_down") throw new DbosShutdownError();
   const durability = await configureDbosOnce();
   launchPromise ??= (async () => {
     state = "launching";
@@ -133,6 +148,7 @@ export async function shutdownDbos(): Promise<void> {
     state = "shutting_down";
     await durability.backend.flush();
     await durability.shutdown();
+    state = "shut_down";
   })().catch((error: unknown) => {
     failure = durabilityFailure("shutdown", error);
     state = "failed";
@@ -141,6 +157,16 @@ export async function shutdownDbos(): Promise<void> {
   await shutdownPromise;
 }
 
+/**
+ * Flush queued durable writes without stopping the process-scoped executor.
+ * Used at process-preserving host-session boundaries (`/new`, `/resume`,
+ * `/fork`, `/reload`) where the DBOS executor must stay launched.
+ */
+export async function flushDbos(): Promise<void> {
+  if (state !== "ready" || active === undefined) return;
+  await active.backend.flush();
+}
+
 export function dbosLifecycleState(): DbosLifecycleState {
   return state;
 }

package/dist/builtin/workflows/src/durable/factory.ts

@@ -3,6 +3,8 @@
 import { InMemoryDurableBackend, type DurableWorkflowBackend } from "./backend.js";
 import {
   DbosNotReadyError,
+  DbosShutdownError,
+  dbosLifecycleState,
   getReadyDbosBackend,
   getReadyDbosBackendSync,
 } from "./dbos-lifecycle.js";
@@ -11,9 +13,22 @@ let injectedBackend: DurableWorkflowBackend | undefined;
 let initializedBackend: DurableWorkflowBackend | undefined;
 let initializing: Promise<DurableWorkflowBackend> | undefined;
 
+/**
+ * A memoized backend is only reusable while its lifecycle generation is
+ * healthy. The in-memory degraded backend has no external lifecycle; a
+ * persistent (DBOS) backend is usable only while the process-scoped DBOS
+ * executor is still `ready` — never after shutdown.
+ */
+function isMemoizedBackendUsable(backend: DurableWorkflowBackend): boolean {
+  return !backend.persistent || dbosLifecycleState() === "ready";
+}
+
 /** Return the injected test backend or the process-wide initialized backend. */
 export function getDurableBackend(): DurableWorkflowBackend {
-  const backend = injectedBackend ?? initializedBackend ?? getReadyDbosBackendSync();
+  const memoized = initializedBackend !== undefined && isMemoizedBackendUsable(initializedBackend)
+    ? initializedBackend
+    : undefined;
+  const backend = injectedBackend ?? memoized ?? getReadyDbosBackendSync();
   if (backend === undefined) throw new DbosNotReadyError();
   return backend;
 }
@@ -44,9 +59,20 @@ export function createInMemoryTestBackend(): InMemoryDurableBackend {
  */
 export async function initializeDurableBackend(): Promise<DurableWorkflowBackend> {
   if (injectedBackend !== undefined) return injectedBackend;
-  if (initializedBackend !== undefined) return initializedBackend;
+  if (initializedBackend !== undefined) {
+    if (isMemoizedBackendUsable(initializedBackend)) return initializedBackend;
+    // Never hand out a backend from a stopped lifecycle generation.
+    initializedBackend = undefined;
+    initializing = undefined;
+  }
   initializing ??= getReadyDbosBackend()
-    .catch((error: unknown) => degradeToNonDurableBackend(error))
+    .catch((error: unknown) => {
+      // Post-shutdown initialization is a process-exit race, not a
+      // provisioning failure: fail loudly instead of silently degrading to a
+      // non-durable backend.
+      if (error instanceof DbosShutdownError) throw error;
+      return degradeToNonDurableBackend(error);
+    })
     .then((backend) => {
       initializedBackend = backend;
       return backend;

package/dist/builtin/workflows/src/durable/index.ts

@@ -26,9 +26,11 @@ export {
 export {
   DbosDurabilityError,
   DbosNotReadyError,
+  DbosShutdownError,
   configureDbosOnce,
   launchDbosOnce,
   getReadyDbosBackend,
+  flushDbos,
   shutdownDbos,
 } from "./dbos-lifecycle.js";
 export {

package/dist/builtin/workflows/src/engine/run-durable-admission.ts

@@ -0,0 +1,50 @@
+/**
+ * Durable root-run registration and startup admission.
+ *
+ * Root registration/status must be durably persisted before startup admission
+ * or workflow code runs: a stopped or unhealthy backend fails here, before
+ * any side effects execute (issue #1957).
+ */
+
+import type { DurableWorkflowBackend, WorkflowRegistrationInput } from "../durable/backend.js";
+import type { WorkflowSerializableValue } from "../shared/types.js";
+
+/** Build the root registration handle, or `undefined` when the run must not (re-)register. */
+export function durableRootRegistrationForRun(args: {
+  readonly runId: string;
+  readonly name: string;
+  readonly inputs: Readonly<Record<string, unknown>>;
+  readonly createdAt: number;
+  readonly hasPersistence: boolean;
+  readonly isChildRun: boolean;
+  readonly continuationSourceId: string | undefined;
+}): WorkflowRegistrationInput | undefined {
+  const shouldRegister = !args.isChildRun
+    && (args.continuationSourceId === undefined || args.continuationSourceId !== args.runId);
+  if (!shouldRegister) return undefined;
+  return {
+    workflowId: args.runId,
+    name: args.name,
+    inputs: args.inputs as Record<string, WorkflowSerializableValue>,
+    createdAt: args.createdAt,
+    status: "running" as const,
+    rootWorkflowId: args.runId,
+    resumable: true,
+    ...(args.hasPersistence ? { sessionFile: undefined } : {}),
+  };
+}
+
+/** Register/mark the root run and flush so admission requires healthy durable persistence. */
+export async function admitDurableRootRun(args: {
+  readonly backend: DurableWorkflowBackend;
+  readonly runId: string;
+  readonly isChildRun: boolean;
+  readonly registration: WorkflowRegistrationInput | undefined;
+}): Promise<void> {
+  if (args.registration !== undefined) {
+    args.backend.registerWorkflow(args.registration);
+  } else if (!args.isChildRun) {
+    args.backend.setWorkflowStatus(args.runId, "running");
+  }
+  if (!args.isChildRun) await args.backend.flush();
+}

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

@@ -47,6 +47,7 @@ import { finalizeDurableTerminalStatus } from "./run-durable-finalize.js";
 import { createDurableStageSessionRecorder } from "./run-durable-stage-session.js";
 import type { DurableWorkflowBackend } from "../durable/backend.js";
 import { createDurableCachedStageRecorder, createDurableStageDeps } from "./run-durable-topology.js";
+import { admitDurableRootRun, durableRootRegistrationForRun } from "./run-durable-admission.js";
 
 type WorkflowRunInputArgument = Parameters<typeof resolveAndValidateInputs>[1];
 
@@ -312,18 +313,11 @@ export async function run<
     },
     runWorkflow: run,
   });
-  const durableRootWorkflowRegistration = {
-    workflowId: runId,
-    name: def.name,
-    inputs: resolvedInputs as Record<string, import("../shared/types.js").WorkflowSerializableValue>,
-    createdAt: runSnapshot.startedAt,
-    status: "running" as const,
-    rootWorkflowId: runId,
-    resumable: true,
-    ...(opts.persistence !== undefined ? { sessionFile: undefined } : {}),
-  };
-  const shouldRegisterDurableRoot = opts.parentRun === undefined
-    && (opts.continuation === undefined || opts.continuation.source.id !== runId);
+  const durableRootRegistration = durableRootRegistrationForRun({
+    runId, name: def.name, inputs: resolvedInputs, createdAt: runSnapshot.startedAt,
+    hasPersistence: opts.persistence !== undefined, isChildRun: opts.parentRun !== undefined,
+    continuationSourceId: opts.continuation?.source.id,
+  });
   const tool = createToolPrimitive({
     workflowId: runId,
     backend: durableBackend,
@@ -394,6 +388,7 @@ export async function run<
     parallel: createParallelPrimitive({ runtime, task: durableTask }),
     workflow: durableWorkflow,
     tool,
+    ...(opts.models !== undefined ? { models: opts.models } : {}),
   };
 
   try {
@@ -408,11 +403,11 @@ export async function run<
       }
     }
 
-    if (shouldRegisterDurableRoot) {
-      durableBackend.registerWorkflow({ ...durableRootWorkflowRegistration, ...workflowInvocationMetadata(inputRuntimeDefaults, workflowInvocationCwd, gitWorktreeSetupCache) });
-    } else if (opts.parentRun === undefined) {
-      durableBackend.setWorkflowStatus(runId, "running");
-    }
+    await admitDurableRootRun({
+      backend: durableBackend, runId, isChildRun: opts.parentRun !== undefined,
+      registration: durableRootRegistration === undefined ? undefined
+        : { ...durableRootRegistration, ...workflowInvocationMetadata(inputRuntimeDefaults, workflowInvocationCwd, gitWorktreeSetupCache) },
+    });
     if (opts.deferWorkflowStart === true) opts.onWorkflowStartReady?.();
     const rawResult = await runWorkflowDefinitionCallback(def.name, runId, () => def.run(ctx));
     if (ownController.signal.aborted) {

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

@@ -20,6 +20,7 @@ import type { PostMortemHandleResolution } from "../tui/workflow-attach-pane-typ
 import { registerWorkflowTool } from "./workflow-tool-registration.js";
 import { registerWorkflowSlashCommand } from "./workflow-command-registration.js";
 import { installInputInterceptor, type WorkflowCommandHandler } from "./workflow-command-utils.js";
+import { workflowPolicyFromContext } from "./workflow-policy.js";
 import { overlaySurfaceFromContext } from "./workflow-targets.js";
 
 function registerWorkflowMessageRenderers(pi: ExtensionAPI): void {
@@ -91,8 +92,22 @@ function factory(pi: ExtensionAPI): void {
     runtimeState.ensureWorkflowResourcesLoaded,
     { resolvePostMortemDeps: (runId) => postMortemDepsForRun(runId, postMortemResolverDeps) },
   );
+  const executeWorkflowToolWithAutoAttach: typeof executeWorkflowTool = async (args, ctx) => {
+    const result = await executeWorkflowTool(args, ctx);
+    if (
+      workflowPolicyFromContext(ctx).mode === "interactive" &&
+      typeof args.workflow === "string" &&
+      result.action === "run" &&
+      result.status === "running" &&
+      result.runId.length > 0 &&
+      runtimeState.runtimeProxy.registry.get(args.workflow)?.autoAttach === true
+    ) {
+      overlay.open(result.runId, overlaySurfaceFromContext(ctx));
+    }
+    return result;
+  };
 
-  registerWorkflowTool(pi, executeWorkflowTool, runtimeState.runWithLifecycleSuppressedForPolicy);
+  registerWorkflowTool(pi, executeWorkflowToolWithAutoAttach, runtimeState.runWithLifecycleSuppressedForPolicy);
   registerWorkflowSlashCommand(pi, workflowCommands, {
     runtimeProxy: runtimeState.runtimeProxy,
     runtimeForContext: runtimeState.runtimeForContext,

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

@@ -12,7 +12,7 @@ import type { ExtensionAPI } from "./public-types.js";
 import type { WorkflowExtensionRuntimeState } from "./extension-runtime-state.js";
 import { deAdvertiseAskUserQuestionWhenHeadless, formatStartupDiagnostics } from "./workflow-command-surfaces.js";
 import { inFlightRunCount } from "./workflow-targets.js";
-import { shutdownDbos } from "../durable/dbos-lifecycle.js";
+import { flushDbos, shutdownDbos } from "../durable/dbos-lifecycle.js";
 
 let processShutdownInstalled = false;
 
@@ -28,6 +28,19 @@ function shutdownDbosQuietly(): Promise<void> {
   });
 }
 
+/**
+ * Process-preserving host-session boundaries (`/new`, `/resume`, `/fork`,
+ * `/reload`) must NOT stop the process-scoped DBOS executor: the replacement
+ * session reuses it for subsequent workflow runs. Flush pending durable
+ * writes instead, and reserve SDK shutdown for actual process exit.
+ */
+function flushDbosQuietly(): Promise<void> {
+  return flushDbos().catch((error: unknown) => {
+    const detail = error instanceof Error ? error.message : String(error);
+    console.error(`atomic-workflows: DBOS durability flush failed: ${detail}`);
+  });
+}
+
 function installDbosProcessShutdown(): void {
   if (processShutdownInstalled) return;
   processShutdownInstalled = true;
@@ -135,6 +148,7 @@ export function registerWorkflowLifecycleHandlers(
     deps.storeWidgetRef.current = null;
     runtimeState.resetWorkflowDiscoveryForSession();
     runtimeState.setNotificationsActive(false);
-    await shutdownDbosQuietly();
+    if (reason === "quit") await shutdownDbosQuietly();
+    else await flushDbosQuietly();
   });
 }