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

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