@bastani/atomic 0.9.2 → 0.9.3-alpha.2

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

@@ -8,7 +8,7 @@
  *   Project-local:
  *     <projectRoot>/.atomic/extensions/workflow/config.json
  *   User-global:
- *     <homeDir>/.atomic/agent/extensions/workflow/config.json
+ *     <agentDir>/extensions/workflow/config.json
  * Invalid JSON or invalid shape → CONFIG_INVALID diagnostic (not silent success).
  * Missing file → silently skipped (not an error).
  *
@@ -17,8 +17,7 @@
  */
 
 import { join, isAbsolute } from "node:path";
-import { homedir } from "node:os";
-import { CONFIG_DIR_NAME, CONFIG_DIR_NAMES, getProjectConfigPaths } from "@bastani/atomic";
+import { CONFIG_DIR_NAME, CONFIG_DIR_NAMES, getAgentDir, getAgentDirs, getProjectConfigPaths } from "@bastani/atomic";
 import type { WorkflowLifecycleNoticeKind } from "./lifecycle-notifications.js";
 import { loadConfigFile } from "./config-file-loader.js";
 
@@ -82,7 +81,7 @@ export interface ConfigLoadResult {
    */
   readonly config: WorkflowExtensionConfig | null;
   /**
-   * Pre-merge global config (from <homeDir>/.atomic/agent/extensions/workflow/config.json).
+   * Pre-merge global config (from <agentDir>/extensions/workflow/config.json).
    * null when the global file is absent or invalid. Absent on results from callers
    * that constructed ConfigLoadResult before this field was added.
    */
@@ -108,10 +107,15 @@ export interface LoadWorkflowConfigOpts {
    */
   readonly projectRoot?: string;
   /**
-   * User home directory. Defaults to os.homedir().
-   * Global config is resolved relative to this path.
+   * User home directory. When set, preserves legacy test/compat resolution
+   * relative to <homeDir>/.atomic/agent and <homeDir>/.pi/agent.
    */
   readonly homeDir?: string;
+  /**
+   * User agent config directories in precedence order. Defaults to Atomic's
+   * configured agent directories, honoring ATOMIC_CODING_AGENT_DIR.
+   */
+  readonly agentDirs?: readonly string[];
 }
 
 // ---------------------------------------------------------------------------
@@ -242,10 +246,15 @@ export interface ScopedDiscoveryConfigOpts {
    */
   readonly projectRoot: string;
   /**
-   * User home directory. Relative paths in globalConfig.workflows are
-   * resolved relative to <homeDir>/.atomic/agent.
+   * User home directory. When set, relative paths in globalConfig.workflows
+   * resolve relative to <homeDir>/.atomic/agent.
+   */
+  readonly homeDir?: string;
+  /**
+   * User agent config directory. Defaults to Atomic's configured agent dir,
+   * honoring ATOMIC_CODING_AGENT_DIR.
    */
-  readonly homeDir: string;
+  readonly agentDir?: string;
 }
 
 export interface ScopedDiscoveryConfig {
@@ -275,12 +284,21 @@ function resolveWorkflowPaths(
   );
 }
 
+function workflowAgentDirs(opts: Pick<LoadWorkflowConfigOpts, "agentDirs" | "homeDir">): readonly string[] {
+  if (opts.agentDirs !== undefined) return opts.agentDirs;
+  if (opts.homeDir !== undefined) {
+    const homeDir = opts.homeDir;
+    return CONFIG_DIR_NAMES.map((name) => join(homeDir, name, "agent"));
+  }
+  return getAgentDirs();
+}
+
 /**
  * Build a scope-aware DiscoveryConfig from the pre-merge global and project configs.
  *
  * Scope rules:
  *   - globalConfig.workflows entries → DiscoveryConfig.globalWorkflows
- *     Relative paths are resolved under <homeDir>/.atomic/agent.
+ *     Relative paths are resolved under the configured Atomic agent dir.
  *   - projectConfig.workflows entries → DiscoveryConfig.projectWorkflows
  *     Relative paths are resolved under projectRoot.
  *   - When both configs define the same workflow key, the project entry wins
@@ -294,7 +312,8 @@ export function toScopedDiscoveryConfig(
   projectConfig: WorkflowExtensionConfig | null,
   opts: ScopedDiscoveryConfigOpts,
 ): ScopedDiscoveryConfig {
-  const globalBase = join(opts.homeDir, CONFIG_DIR_NAME, "agent");
+  const globalBase = opts.agentDir
+    ?? (opts.homeDir === undefined ? getAgentDir() : join(opts.homeDir, CONFIG_DIR_NAME, "agent"));
   const projectBase = opts.projectRoot;
 
   const result: ScopedDiscoveryConfig = {};
@@ -328,7 +347,7 @@ export function toScopedDiscoveryConfig(
  *
  * Candidate paths (in resolution order):
  *   Global (lowest priority):
- *     <homeDir>/.atomic/agent/extensions/workflow/config.json
+ *     <agentDir>/extensions/workflow/config.json
  *   Project-local (highest priority, first existing wins):
  *     <projectRoot>/.atomic/extensions/workflow/config.json
  * Merge: project-local overrides global. Key-level merge for `workflows` map.
@@ -338,12 +357,13 @@ export async function loadWorkflowConfig(
   opts: LoadWorkflowConfigOpts = {},
 ): Promise<ConfigLoadResult> {
   const projectRoot = opts.projectRoot ?? process.cwd();
-  const home = opts.homeDir ?? homedir();
 
   const diagnostics: ConfigDiagnostic[] = [];
 
-  // Global config paths (primary Atomic first, then legacy pi)
-  const globalCandidates = CONFIG_DIR_NAMES.map((name) => join(home, name, "agent", "extensions", "workflow", "config.json"));
+  // Global config paths (primary Atomic first, then legacy pi/defaults).
+  const globalCandidates = workflowAgentDirs(opts).map((agentDir) =>
+    join(agentDir, "extensions", "workflow", "config.json")
+  );
 
   // Project-local config paths (primary Atomic first, then legacy pi)
   const projectCandidates: string[] = getProjectConfigPaths(projectRoot, "extensions", "workflow", "config.json");

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

@@ -11,17 +11,17 @@
  *   1. settings-project — paths listed in config.projectWorkflows
  *   2. project-local    — {cwd}/.atomic/workflows/*.{ts,js,mjs,cjs}
  *   3. settings-global  — paths listed in config.globalWorkflows
- *   4. user-global      — {homeDir}/.atomic/agent/workflows/*.{ts,js,mjs,cjs}
+ *   4. user-global      — {agentDir}/workflows/*.{ts,js,mjs,cjs}
  *   5. package          — workflow files supplied by Atomic/pi packages
  *   6. bundled          — shipped workflows (skipped when includeBundled=false)
  *
  * Usage:
  *   // Full discovery (all sources):
- *   const result = await discoverWorkflows({ cwd: process.cwd(), homeDir: os.homedir() });
+ *   const result = await discoverWorkflows({ cwd: process.cwd() });
  */
 
 import { join } from "node:path";
-import { CONFIG_DIR_NAMES, getProjectConfigPaths } from "@bastani/atomic";
+import { CONFIG_DIR_NAMES, getAgentDirs, getProjectConfigPaths } from "@bastani/atomic";
 import type { WorkflowDefinition } from "../shared/types.js";
 import { createRegistry } from "../workflows/registry.js";
 import type { WorkflowRegistry } from "../workflows/registry.js";
@@ -38,7 +38,7 @@ import { loadFromDir, loadFromPaths, type WorkflowModuleCandidateRecord } from "
  *
  *   bundled          — shipped with the workflows package
  *   project-local    — found in {cwd}/.atomic/workflows/
- *   user-global      — found in {homeDir}/.atomic/agent/workflows/
+ *   user-global      — found in {agentDir}/workflows/
  *   settings-project — listed in DiscoveryConfig.projectWorkflows
  *   settings-global  — listed in DiscoveryConfig.globalWorkflows
  *   package          — supplied by Atomic/pi package workflow resources
@@ -121,8 +121,10 @@ export interface DiscoveryConfig {
 export interface DiscoveryOptions {
   /** Working directory; used as root for project-local discovery. Default: process.cwd() */
   cwd: string;
-  /** User's home directory; used as root for user-global discovery. Default: os.homedir() */
+  /** User's home directory; when set, preserves legacy test/compat user-global discovery roots. */
   homeDir: string;
+  /** User agent config directories in precedence order. Defaults to Atomic's configured agent directories. */
+  agentDirs?: readonly string[];
   /** Optional extra paths from project/global config. */
   config?: DiscoveryConfig;
   /** Workflow files supplied by installed Atomic/pi packages. */
@@ -145,6 +147,15 @@ export interface DiscoveryResult {
 // Internal helpers
 // ---------------------------------------------------------------------------
 
+function workflowAgentDirs(options: Partial<DiscoveryOptions> | undefined): readonly string[] {
+  if (options?.agentDirs !== undefined) return options.agentDirs;
+  if (options?.homeDir !== undefined) {
+    const homeDir = options.homeDir;
+    return CONFIG_DIR_NAMES.map((name) => join(homeDir, name, "agent"));
+  }
+  return getAgentDirs();
+}
+
 /**
  * Validate DiscoveryConfig shape.
  * Returns null when valid, or a description of the problem.
@@ -273,7 +284,7 @@ function applyBatchShapeOnly(
  *   1. settings-project — config.projectWorkflows paths
  *   2. project-local    — {cwd}/.atomic/workflows/*.{ts,js,mjs,cjs}
  *   3. settings-global  — config.globalWorkflows paths
- *   4. user-global      — {homeDir}/.atomic/agent/workflows/*.{ts,js,mjs,cjs}
+ *   4. user-global      — {agentDir}/workflows/*.{ts,js,mjs,cjs}
  *   5. package          — package-supplied workflow files
  *   6. bundled          — shipped workflows (omitted when includeBundled=false)
  */
@@ -282,6 +293,7 @@ export async function discoverWorkflows(
 ): Promise<DiscoveryResult> {
   const cwd = options?.cwd ?? process.cwd();
   const homeDir = options?.homeDir ?? (await defaultHomeDir());
+  const agentDirs = workflowAgentDirs(options);
   const config = options?.config;
   const packageWorkflowPaths = options?.packageWorkflowPaths;
   const includeBundled = options?.includeBundled !== false;
@@ -332,8 +344,8 @@ export async function discoverWorkflows(
     }
   }
 
-  // 4. user-global — canonical Atomic path plus legacy pi path
-  for (const dir of CONFIG_DIR_NAMES.map((name) => join(homeDir, name, "agent", "workflows")).reverse()) {
+  // 4. user-global — configured Atomic agent dir plus legacy/defaults when applicable.
+  for (const dir of agentDirs.map((agentDir) => join(agentDir, "workflows")).reverse()) {
     const candidates = await loadFromDir(dir, "user-global", diagnostics);
     registry = await applyBatch(candidates, registry, sources, diagnostics);
   }

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

@@ -1,5 +1,4 @@
-import { killRun } from "../runs/background/status.js";
-import { cancellationRegistry } from "../runs/background/cancellation-registry.js";
+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";
@@ -7,9 +6,8 @@ import { installStoreWidget, installToolExecutionHooks } from "../tui/store-widg
 import { buildGraphOverlayAdapter } from "../tui/overlay-adapter.js";
 import type { GraphOverlayPort } from "../tui/overlay-adapter.js";
 import { registerInlineFormRenderer } from "../tui/inline-form-overlay.js";
-import { registerChatSurfaceRenderer, emitChatSurface } from "../tui/chat-surface-message.js";
+import { registerChatSurfaceRenderer } from "../tui/chat-surface-message.js";
 import { deriveGraphTheme } from "../tui/graph-theme.js";
-import type { WorkflowPersistencePort } from "../shared/types.js";
 import { renderRunBanner, renderRunSummary, type RunEndPayload, type RunStartPayload } from "./renderers.js";
 import { buildRuntimeAdapters } from "./wiring.js";
 import type { ExtensionAPI, PiCommandContext } from "./public-types.js";
@@ -36,15 +34,11 @@ function registerWorkflowMessageRenderers(pi: ExtensionAPI): void {
 
 function buildWorkflowOverlay(
   pi: ExtensionAPI,
-  getPersistence: () => WorkflowPersistencePort | undefined,
 ): GraphOverlayPort {
   return buildGraphOverlayAdapter(pi, store, {
-    onKillRun: (runId) => {
-      const run = store.runs().find((r) => r.id === runId);
-      const result = killRun(runId, { cancellation: cancellationRegistry, persistence: getPersistence() });
-      if (run && result.ok) {
-        emitChatSurface(pi, { kind: "killed", run, previousStatus: result.previousStatus });
-      }
+    onQuitRun: (runId) => {
+      quitRun(runId, { store });
+      pi.ui?.notify?.(`Workflow quit; resume with /workflow resume.`, "info");
     },
   });
 }
@@ -83,7 +77,7 @@ function registerIntercomControl(
 function factory(pi: ExtensionAPI): void {
   const adapters = buildRuntimeAdapters(pi);
   const runtimeState = createWorkflowExtensionRuntimeState(pi, adapters);
-  const overlay = buildWorkflowOverlay(pi, () => runtimeState.persistenceRef.current);
+  const overlay = buildWorkflowOverlay(pi);
   const workflowCommands = new Map<string, WorkflowCommandHandler>();
   const storeWidgetRef: { current: (() => void) | null } = { current: null };
   const intercomControlRef: { current: (() => void) | null } = { current: null };

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

@@ -1,4 +1,5 @@
 import { killAllRuns } from "../runs/background/status.js";
+import { quitAllRuns } from "../runs/background/quit.js";
 import { cancellationRegistry } from "../runs/background/cancellation-registry.js";
 import { stageControlRegistry } from "../runs/foreground/stage-control-registry.js";
 import { store } from "../shared/store.js";
@@ -99,7 +100,10 @@ export function registerWorkflowLifecycleHandlers(
     deps.intercomControlRef.current?.();
     deps.intercomControlRef.current = null;
     if (reason === "quit") {
-      killAllRuns({ store, cancellation: cancellationRegistry, persistence: runtimeState.persistenceRef.current });
+      // CLI/orchestrator quit is a resumable process boundary, not explicit
+      // `/workflow kill`. Durable-progress workflows stay available through
+      // `/workflow resume`; stage handles are disposed after being paused.
+      quitAllRuns({ store, stageControlRegistry });
       stageControlRegistry.clear();
     }
     deps.storeWidgetRef.current?.();

package/dist/builtin/workflows/src/extension/extension-runtime-state.ts

@@ -141,6 +141,9 @@ export function createWorkflowExtensionRuntimeState(
     dispatch(args, options) { return runtimeRef.current.dispatch(args, options); },
     runDirect(args, options) { return runtimeRef.current.runDirect(args, options); },
     resumeFailedRun(sourceRunId, stageId, options) { return runtimeRef.current.resumeFailedRun(sourceRunId, stageId, options); },
+    resumeDurableWorkflow(workflowIdOrPrefix, options) { return runtimeRef.current.resumeDurableWorkflow(workflowIdOrPrefix, options); },
+    listDurableResumable(sessionDir) { return runtimeRef.current.listDurableResumable(sessionDir); },
+    prepareDurableResumable(workflowIdOrPrefix, sessionDir) { return runtimeRef.current.prepareDurableResumable(workflowIdOrPrefix, sessionDir); },
   };
 
   function workflowModelCatalogFromContext(ctx?: PiModelContext): WorkflowModelCatalogPort | undefined {
@@ -201,11 +204,10 @@ export function createWorkflowExtensionRuntimeState(
     }
     const configResult = await loadWorkflowConfig();
     configLoadRef.current = configResult;
-    const { homedir } = await import("node:os");
     const hasGlobal = configResult.globalConfig != null;
     const hasProject = configResult.projectConfig != null;
     const discoveryConfig = hasGlobal || hasProject
-      ? toScopedDiscoveryConfig(configResult.globalConfig ?? null, configResult.projectConfig ?? null, { projectRoot: process.cwd(), homeDir: homedir() })
+      ? toScopedDiscoveryConfig(configResult.globalConfig ?? null, configResult.projectConfig ?? null, { projectRoot: process.cwd() })
       : undefined;
     const result = await discoverWorkflows({ config: discoveryConfig, packageWorkflowPaths: await loadPackageWorkflowPaths() });
     discoveryRef.current = result;

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

@@ -43,6 +43,10 @@ import { runDetached } from "../runs/background/runner.js";
 import type { JobTracker } from "../runs/background/job-tracker.js";
 import { appendRunEnd } from "../shared/persistence-session-entries.js";
 import { classifyWorkflowFailure } from "../shared/workflow-failures.js";
+import { resumeDurableWorkflow as resumeDurableWorkflowAdapter, prepareRuntimeDurableResumable, isBackendTerminal, type ResumeDurableDeps, type ResumeDurableResult } from "../durable/resume-runtime.js";
+import { getDurableBackend, initializeDbosDurableBackendFromEnv } from "../durable/factory.js";
+import { scanResumableWorkflows } from "../durable/resume-catalog.js";
+import type { ResumableWorkflowEntry } from "../durable/types.js";
 import { directMode, directModelRequests, directOptions, directProgressTotal } from "./runtime-direct.js";
 
 // ---------------------------------------------------------------------------
@@ -87,11 +91,9 @@ export interface ExtensionRuntimeOpts {
   /** Resolve the host's non-default session directory for workflow stage transcripts. */
   resolveDefaultStageSessionDir?: () => string | undefined;
 }
-
 // ---------------------------------------------------------------------------
 // Public interface
 // ---------------------------------------------------------------------------
-
 export type ResumeFailedRunResult =
   | { ok: true; runId: string; sourceRunId: string; resumeFromStageId: string; message: string }
   | { ok: false; reason: "run_not_found" | "not_resumable" | "workflow_not_found" | "insufficient_state"; message: string };
@@ -114,12 +116,21 @@ export interface ExtensionRuntime {
 
   /** Start a linked continuation for a failed resumable named workflow run. */
   resumeFailedRun(sourceRunId: string, stageId?: string, options?: RuntimeDispatchOptions): ResumeFailedRunResult;
-}
 
+  /**
+   * Resume a durable workflow by top-level workflow id when no live run exists.
+   * Re-dispatches the workflow with the cached inputs and original workflow id
+   * so durable checkpoints replay (skipping completed side effects).
+   *
+   * cross-ref: issue #1498 — cross-session /workflow resume selector.
+   */
+  resumeDurableWorkflow(workflowIdOrPrefix: string, options?: RuntimeDispatchOptions): import("../durable/resume-runtime.js").ResumeDurableResult;
+  listDurableResumable(sessionDir?: string): readonly import("../durable/types.js").ResumableWorkflowEntry[];
+  prepareDurableResumable(workflowIdOrPrefix?: string, sessionDir?: string): Promise<readonly import("../durable/types.js").ResumableWorkflowEntry[]>;
+}
 export interface RuntimeDispatchOptions {
   readonly policy?: WorkflowExecutionPolicy;
 }
-
 // ---------------------------------------------------------------------------
 // Factory
 // ---------------------------------------------------------------------------
@@ -150,6 +161,9 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
   const jobs = opts.jobs;
   const runtimeCwd = opts.cwd ?? process.cwd();
   const resolveDefaultStageSessionDir = opts.resolveDefaultStageSessionDir;
+  const dbosReady = initializeDbosDurableBackendFromEnv().catch((err) => process.emitWarning(`Atomic workflow DBOS durability unavailable; using file-backed durability: ${err instanceof Error ? err.message : String(err)}`));
+  const ensureDbosReady = async (): Promise<void> => { await dbosReady; };
+  let preparedDurableCatalog: readonly ResumableWorkflowEntry[] = [];
 
   function runOptions(args: WorkflowToolArgs, policy?: WorkflowExecutionPolicy): RunOpts {
     const argConcurrency =
@@ -182,14 +196,12 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
       cwd: runtimeCwd,
     };
   }
-
   function explicitIntercomDelivery(args: WorkflowToolArgs): WorkflowIntercomDelivery | undefined {
     if (args.intercom?.enabled === false) return "off";
     if (args.intercom?.delivery !== undefined) return args.intercom.delivery;
     if (args.intercom?.enabled === true) return "control-and-result";
     return undefined;
   }
-
   function effectiveIntercomDelivery(args: WorkflowToolArgs, mode: WorkflowDetails["mode"]): WorkflowIntercomDelivery {
     const explicit = explicitIntercomDelivery(args);
     if (explicit !== undefined) return explicit;
@@ -202,7 +214,6 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
     }
     return "off";
   }
-
   function intercomParentSession(args: WorkflowToolArgs): string | undefined {
     if (args.intercom?.parentSession !== undefined) return args.intercom.parentSession;
     if (typeof intercom?.parentSession === "function") return intercom.parentSession();
@@ -371,6 +382,7 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
   }
 
   async function runDirectAsync(args: WorkflowToolArgs, policy?: WorkflowExecutionPolicy): Promise<WorkflowDetails> {
+    await ensureDbosReady();
     const runId = crypto.randomUUID();
     const mode = directMode(args);
     const delivery = effectiveIntercomDelivery(args, mode);
@@ -423,7 +435,8 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
       return registry;
     },
 
-    dispatch(args: WorkflowToolArgs, options?: RuntimeDispatchOptions): Promise<WorkflowToolResult> {
+    async dispatch(args: WorkflowToolArgs, options?: RuntimeDispatchOptions): Promise<WorkflowToolResult> {
+      await ensureDbosReady();
       const defaultSessionDir = resolveDefaultStageSessionDir?.();
       return dispatch(args, {
         registry,
@@ -441,7 +454,8 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
       });
     },
 
-    runDirect(args: WorkflowToolArgs, options?: RuntimeDispatchOptions): Promise<WorkflowDetails> {
+    async runDirect(args: WorkflowToolArgs, options?: RuntimeDispatchOptions): Promise<WorkflowDetails> {
+      await ensureDbosReady();
       const policy = options?.policy ?? INTERACTIVE_WORKFLOW_POLICY;
       if (args.async === true && policy.awaitTerminalRun !== true) {
         return runDirectAsync(args, policy);
@@ -457,5 +471,30 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
     },
 
     resumeFailedRun,
+
+    resumeDurableWorkflow(workflowIdOrPrefix: string, options?: RuntimeDispatchOptions): ResumeDurableResult {
+      const adapterDeps: ResumeDurableDeps = {
+        registry,
+        baseRunOpts: runOptions({ workflow: "", inputs: {} }, options?.policy),
+        durableBackend: getDurableBackend(),
+      };
+      return resumeDurableWorkflowAdapter(workflowIdOrPrefix, adapterDeps, preparedDurableCatalog);
+    },
+    listDurableResumable(sessionDir?: string): readonly ResumableWorkflowEntry[] {
+      const backend = getDurableBackend();
+      const live = backend.listResumableWorkflows();
+      const dir = sessionDir ?? resolveDefaultStageSessionDir?.();
+      if (dir === undefined) return live;
+      const scanned = scanResumableWorkflows(dir);
+      const liveIds = new Set(live.map((e) => e.workflowId));
+      const compatible = scanned.filter((e) => !liveIds.has(e.workflowId) && backend.getWorkflow(e.workflowId) !== undefined && !isBackendTerminal(backend, e.workflowId));
+      return [...live, ...compatible];
+    },
+
+    async prepareDurableResumable(workflowIdOrPrefix?: string, sessionDir?: string): Promise<readonly ResumableWorkflowEntry[]> {
+      await ensureDbosReady();
+      preparedDurableCatalog = await prepareRuntimeDurableResumable(getDurableBackend, () => resolveDefaultStageSessionDir?.(), workflowIdOrPrefix, sessionDir);
+      return preparedDurableCatalog;
+    },
   };
 }

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

@@ -179,7 +179,7 @@ function makeWorkflowStageOrchestrationContext(meta: StageExecutionMeta): NonNul
     workflowStageName: meta.stageName,
     constraints: {
       disableWorkflowTool: true,
-      maxSubagentDepth: 2,
+      maxSubagentDepth: 5,
     },
   };
 }

package/dist/builtin/workflows/src/extension/workflow-run-control-command.ts

@@ -5,6 +5,7 @@ import { store } from "../shared/store.js";
 import { topLevelWorkflowRuns } from "../shared/run-visibility.js";
 import { renderSessionList } from "../tui/session-list.js";
 import { openKillConfirm, openSessionPicker } from "../tui/session-overlays.js";
+import { openWorkflowResumeSelector } from "../tui/workflow-resume-selector.js";
 import { deriveGraphTheme } from "../tui/graph-theme.js";
 import { emitChatSurface } from "../tui/chat-surface-message.js";
 import type { GraphOverlayPort } from "../tui/overlay-adapter.js";
@@ -13,6 +14,8 @@ import type { ExtensionAPI, PiCommandContext } from "./public-types.js";
 import type { WorkflowCommandReporter } from "./workflow-command-utils.js";
 import { stripYesFlag } from "./workflow-command-utils.js";
 import { workflowPolicyFromContext } from "./workflow-policy.js";
+import { formatResumableWorkflowList } from "../durable/resume-catalog.js";
+import type { ResumableWorkflowEntry } from "../durable/types.js";
 import {
   formatAlreadyEndedRetainedMessage,
   overlaySurfaceFromContext,
@@ -37,6 +40,75 @@ function resolveAttachStageId(runId: string, stageTarget: string | undefined): s
   return byName?.id ?? false;
 }
 
+function filterSelectorDurableEntries(
+  runtime: ExtensionRuntime,
+  entries: readonly ResumableWorkflowEntry[],
+): readonly ResumableWorkflowEntry[] {
+  const registry = runtime.registry as { has(name: string): boolean } | undefined;
+  if (registry === undefined) return entries;
+  return entries.filter((entry) => {
+    const requiresCurrentDefinition = entry.status === "running" || entry.status === "failed" || entry.status === "blocked";
+    return !requiresCurrentDefinition || registry.has(entry.name);
+  });
+}
+
+
+async function handleDurableResume(
+  target: string | undefined,
+  ctx: PiCommandContext,
+  reporter: WorkflowCommandReporter,
+  deps: WorkflowRunControlDeps,
+): Promise<boolean> {
+  const print = (msg: string): void => reporter.info(msg);
+  const fail = (msg: string): void => reporter.error(msg);
+  const runtime = deps.runtimeForContext(ctx);
+  const policy = workflowPolicyFromContext(ctx);
+  // Hydrate the durable backend from DBOS (if configured) before listing so a
+  // fresh process discovers workflows persisted by a prior session.
+  const prepared = await runtime.prepareDurableResumable(target);
+  const durable = filterSelectorDurableEntries(runtime, prepared);
+  if (target !== undefined) {
+    // Attempt resume by id/prefix against the durable catalog.
+    const result = runtime.resumeDurableWorkflow(target, { policy });
+    if (result.ok) {
+      print(result.message);
+      // Open/connect the overlay to the resumed run, analogous to live resume.
+      if (policy.allowInputPicker) deps.overlay.open(result.runId, overlaySurfaceFromContext(ctx));
+      return true;
+    }
+    // Not a durable workflow either — surface the catalog for discovery.
+    if (durable.length > 0) {
+      fail(`${result.message}\n\n${formatResumableWorkflowList(durable)}`);
+    } else {
+      fail(result.message);
+    }
+    return true;
+  }
+  // No target: show the durable selector when interactive, otherwise print.
+  if (durable.length === 0) {
+    fail("No resumable durable workflows found. Usage: /workflow resume <id> (or /resume for Atomic sessions).");
+    return true;
+  }
+  if (!policy.allowInputPicker) {
+    print(`${formatResumableWorkflowList(durable)}\n\nResume with: /workflow resume <id>`);
+    return true;
+  }
+  const picked = await openWorkflowResumeSelector(ctx.ui, [], durable);
+  if (picked.kind === "durable") {
+    const result = runtime.resumeDurableWorkflow(picked.workflowId, { policy });
+    if (result.ok) {
+      print(result.message);
+      if (policy.allowInputPicker) deps.overlay.open(result.runId, overlaySurfaceFromContext(ctx));
+    } else {
+      fail(result.message);
+    }
+  }
+  if (picked.kind !== "durable") {
+    print(`${formatResumableWorkflowList(durable)}\n\nResume with: /workflow resume <id>`);
+  }
+  return true;
+}
+
 export async function handleRunControlCommand(
   action: "connect" | "interrupt" | "kill" | "attach" | "pause" | "resume",
   rest: string[],
@@ -115,7 +187,7 @@ export async function handleRunControlCommand(
     }
     if (failHeadlessAttachCommand("connect", resolved.runId)) return true;
     if (policy.allowInputPicker) deps.overlay.open(resolved.runId, overlaySurfaceFromContext(ctx));
-    print(`Attached to ${resolved.runId.slice(0, 8)}. h/ctrl+d hide · q kill · esc close.`);
+    print(`Attached to ${resolved.runId.slice(0, 8)}. h/ctrl+d hide · q quit (resumable via /workflow resume) · esc close.`);
     return true;
   }
 
@@ -206,10 +278,64 @@ export async function handleRunControlCommand(
         if (action === "pause") {
           const active = topLevelWorkflowRuns(store.runs()).filter((r) => r.endedAt === undefined);
           fail(active.length === 0 ? "No active runs to pause." : `Picker requires an interactive UI surface. Active runs:\n${active.map((r) => `  ${r.id.slice(0, 8)}  ${r.name}`).join("\n")}\n\nUsage: /workflow pause <runId> [stageId]`);
+        } else if (action === "attach") {
+          fail(`${renderSessionList(store.runs(), { theme, includeAll: true })}\n\nPicker requires an interactive UI surface. Pass a runId: /workflow attach <id> [stageId]`);
         } else {
-          fail(action === "attach"
-            ? `${renderSessionList(store.runs(), { theme, includeAll: true })}\n\nPicker requires an interactive UI surface. Pass a runId: /workflow attach <id> [stageId]`
-            : "Usage: /workflow resume <runId> [stageId] [message…]");
+          // resume: show cross-session durable catalog in headless/print mode.
+          return await handleDurableResume(undefined, ctx, reporter, deps);
+        }
+        return true;
+      }
+      if (action === "resume") {
+        // Only inactive workflows belong in the resume selector. Live runs:
+        // show paused (quit) or recoverably-failed runs; actively-running live
+        // runs are hidden (resuming one that is executing would double-dispatch).
+        const liveRuns = topLevelWorkflowRuns(store.runs()).filter((run) =>
+          run.status === "paused" || (run.status === "failed" && run.resumable !== false),
+        );
+        // Durable entries: a `running` durable handle may be a crashed process
+        // (cross-session crash recovery), so it stays selectable UNLESS it
+        // matches an actively-executing live run in this session.
+        const activeLiveIds = new Set(
+          topLevelWorkflowRuns(store.runs())
+            .filter((run) => run.endedAt === undefined && run.status === "running" && run.exitReason !== "quit")
+            .map((run) => run.id),
+        );
+        const runtime = deps.runtimeForContext(ctx);
+        let durableEntries: readonly ResumableWorkflowEntry[] = [];
+        try {
+          const prepared = await runtime.prepareDurableResumable(undefined);
+          durableEntries = filterSelectorDurableEntries(runtime, prepared)
+            .filter((entry) => !activeLiveIds.has(entry.workflowId));
+        } catch (error) {
+          if (liveRuns.length === 0) {
+            const message = error instanceof Error ? error.message : String(error);
+            fail(`Failed to list resumable workflows: ${message}`);
+            return true;
+          }
+        }
+        const picked = await openWorkflowResumeSelector(ctx.ui, liveRuns, durableEntries);
+        if (picked.kind === "durable") return await handleDurableResume(picked.workflowId, ctx, reporter, deps);
+        if (picked.kind === "live") {
+          const resolved = resolveRunIdPrefix(picked.runId);
+          if (resolved.kind !== "exact") {
+            fail(`Run not found: ${picked.runId}`);
+            return true;
+          }
+          const run = store.runs().find((r) => r.id === resolved.runId);
+          const isPaused = run?.status === "paused" || (run?.stages.some((s) => s.status === "paused") ?? false);
+          const isResumableContinuation = run !== undefined && !isPaused && ((run.status === "failed" && run.endedAt !== undefined && run.resumable !== false) || (run.endedAt === undefined && run.resumable === true && run.failureRecoverability === "recoverable"));
+          if (isResumableContinuation) {
+            const continuation = deps.runtimeForContext(ctx).resumeFailedRun(resolved.runId, undefined, { policy });
+            continuation.ok ? print(continuation.message) : fail(continuation.message);
+          } else {
+            const result = resumeRun(resolved.runId, {});
+            if (result.ok && result.mode === "snapshot" && run?.exitReason === "quit") {
+              return await handleDurableResume(resolved.runId, ctx, reporter, deps);
+            }
+            if (result.ok && policy.allowInputPicker) deps.overlay.open(result.runId, overlaySurfaceFromContext(ctx));
+            result.ok ? print(result.message ?? `Resumed ${result.runId.slice(0, 8)}`) : fail(`Run not found: ${picked.runId}`);
+          }
         }
         return true;
       }
@@ -220,6 +346,11 @@ export async function handleRunControlCommand(
     } else {
       const resolved = resolveRunIdPrefix(target);
       if (resolved.kind === "not_found") {
+        // Not a live run — fall back to the cross-session durable resume catalog.
+        // cross-ref: issue #1498 — /workflow resume by top-level workflow id.
+        if (action === "resume") {
+          return await handleDurableResume(target, ctx, reporter, deps);
+        }
         fail(`Run not found: ${target}`);
         return true;
       }
@@ -260,6 +391,11 @@ export async function handleRunControlCommand(
     const run = store.runs().find((r) => r.id === stageRunId);
     const isPaused = run?.status === "paused" || (run?.stages.some((s) => s.status === "paused") ?? false);
     const isResumableContinuation = run !== undefined && !isPaused && ((run.status === "failed" && run.endedAt !== undefined && run.resumable !== false) || (run.endedAt === undefined && run.resumable === true && run.failureRecoverability === "recoverable"));
+    const isActivelyRunning = run !== undefined && run.endedAt === undefined && run.status === "running" && !isPaused && run.exitReason !== "quit";
+    if (isActivelyRunning && action === "resume") {
+      fail(`Workflow ${stageRunId.slice(0, 8)} is already running in this session. Attach with \`/workflow connect ${stageRunId.slice(0, 8)}\` instead of resuming.`);
+      return true;
+    }
     if (isResumableContinuation) {
       const continuation = deps.runtimeForContext(ctx).resumeFailedRun(stageRunId, stageId, { policy });
       continuation.ok ? print(continuation.message) : fail(continuation.message);
@@ -270,6 +406,9 @@ export async function handleRunControlCommand(
       fail(`Run not found: ${stageRunId.slice(0, 8)}`);
       return true;
     }
+    if (result.mode === "snapshot" && run?.exitReason === "quit" && action === "resume") {
+      return await handleDurableResume(stageRunId, ctx, reporter, deps);
+    }
     if (!isPaused) {
       if (policy.allowInputPicker) deps.overlay.open(result.runId, overlaySurfaceFromContext(ctx));
       print(result.message ?? `Snapshot available: run ${result.runId} (${result.snapshot.name}) — status: ${result.snapshot.status}, stages: ${result.snapshot.stages.length}`);