@bastani/atomic 0.9.8 → 0.9.9-alpha.1

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

@@ -10,6 +10,7 @@
  */
 
 import type { WorkflowModelAttempt, WorkflowSerializableValue } from "../shared/types.js";
+import type { DURABLE_FORMAT_VERSION } from "./format-version.js";
 
 // ---------------------------------------------------------------------------
 // Top-level workflow identity
@@ -156,6 +157,8 @@ export type WorkflowSerializableObject = Readonly<Record<string, WorkflowSeriali
  * the minimal top-level metadata needed for `/workflow resume` discovery.
  */
 export interface DurableCheckpointEntry {
+  /** Durable metadata schema version used to reject incompatible discovery rows. */
+  readonly formatVersion: typeof DURABLE_FORMAT_VERSION;
   readonly type: "workflow.durable.checkpoint";
   readonly workflowId: string;
   readonly name: string;

package/dist/builtin/workflows/src/engine/primitives/task.ts

@@ -86,6 +86,7 @@ function createTaskPrimitive(runtime: EngineRuntime): WorkflowTaskPrimitive {
       { ...options, worktree: true },
       `${runtime.runId}-${name}-${crypto.randomUUID()}`,
       name,
+      runtime.workflowInvocationCwd,
     );
     const preparedTask = prepared.tasks[0]!;
     try {

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

@@ -19,7 +19,7 @@ import { stageControlRegistry as defaultStageControlRegistry } from "../runs/for
 import type { RunOpts, RunResult } from "../runs/foreground/executor-types.js";
 import { unknownErrorMessage, findWorkflowExitSignal, parentWorkflowExitAbortReason } from "../runs/foreground/executor-abort.js";
 import { resolveAndValidateInputs, resolveInputConcurrency, resolveInputRuntimeDefaults } from "../runs/foreground/executor-inputs.js";
-import { createGitWorktreeSetupCache, workflowCwdWithInputWorktree, workflowInvocationMetadata } from "../runs/foreground/executor-direct-helpers.js";
+import { createGitWorktreeSetupCacheOwner, workflowCwdWithInputWorktree, workflowInvocationMetadata } from "../runs/foreground/executor-direct-helpers.js";
 import { createStageScheduler } from "../runs/foreground/executor-scheduler.js";
 import { createRunFinalizers } from "../runs/foreground/executor-run-finalizers.js";
 import { buildPromptNodeUiAdapter } from "../runs/foreground/executor-prompt-nodes.js";
@@ -152,7 +152,8 @@ export async function run<
 
   const tracker = new GraphFrontierTracker();
   const inputConcurrency = resolveInputConcurrency(def.inputs, resolvedInputs);
-  const inputRuntimeDefaults = resolveInputRuntimeDefaults(def, resolvedInputs), gitWorktreeSetupCache = createGitWorktreeSetupCache();
+  const inputRuntimeDefaults = resolveInputRuntimeDefaults(def, resolvedInputs), gitWorktreeSetupCacheOwner = createGitWorktreeSetupCacheOwner(opts.gitWorktreeSetupCache);
+  const gitWorktreeSetupCache = gitWorktreeSetupCacheOwner.cache;
   const workflowInvocationCwd = opts.cwd ?? process.cwd();
   let workflowCwd: string | undefined;
   const resolveWorkflowCwd = (): string => {
@@ -484,17 +485,16 @@ export async function run<
     });
     return reconcileTerminalRunResult(runId, runSnapshot, activeStore, { status: "failed", error: metadata.errorMessage }, opts.onRunEnd);
   } finally {
-    // Persist final durable status for cross-session resume discovery.
-    // Covers ctx.exit terminal states and failure/kill paths; normal
-    // completion is handled in the try block.
-    // cross-ref: issue #1498
-    await finalizeDurableTerminalStatus({
-      runId,
-      runSnapshot,
-      isRoot: opts.parentRun === undefined,
-      durableBackend,
-      persistence: opts.persistence,
-    });
-    opts.cancellation?.unregister(runId);
+    try {
+      await finalizeDurableTerminalStatus({
+        runId,
+        runSnapshot,
+        isRoot: opts.parentRun === undefined,
+        durableBackend,
+        persistence: opts.persistence,
+      });
+    } finally {
+      gitWorktreeSetupCacheOwner.release(() => opts.cancellation?.unregister(runId));
+    }
   }
 }

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

@@ -4,6 +4,7 @@ import { cancellationRegistry } from "../runs/background/cancellation-registry.j
 import { stageControlRegistry } from "../runs/foreground/stage-control-registry.js";
 import { store } from "../shared/store.js";
 import { restoreOnSessionStart } from "../shared/persistence-restore.js";
+import { findResumableWorkflowNotices } from "../shared/resumable-workflow-notices.js";
 import { installCompactionHook } from "../shared/persistence-compaction-policy.js";
 import { clearForms } from "../tui/inline-form-store.js";
 import { installStoreWidget } from "../tui/store-widget-installer.js";
@@ -57,7 +58,7 @@ export function registerWorkflowLifecycleHandlers(
     return { cancel: true };
   });
 
-  pi.on("session_start", async (_event, ctx) => {
+  pi.on("session_start", async (event, ctx) => {
     runtimeState.resetWorkflowDiscoveryForSession();
     deAdvertiseAskUserQuestionWhenHeadless(pi, ctx?.hasUI);
     await runtimeState.ensureWorkflowConfigLoaded();
@@ -85,16 +86,45 @@ export function registerWorkflowLifecycleHandlers(
     if (sessionManager) {
       const cfg = runtimeState.configLoadRef.current?.config;
       withWorkflowLifecycleNotificationsSuppressed(runtimeState.lifecycleNotificationState, () => {
-        restoreOnSessionStart(
-          sessionManager,
-          {
-            resumeInFlight: cfg?.resumeInFlight ?? "ask",
-            persistRuns: cfg?.persistRuns ?? true,
-          },
-          store,
-        );
+        try {
+          restoreOnSessionStart(
+            sessionManager,
+            {
+              resumeInFlight: cfg?.resumeInFlight ?? "ask",
+              persistRuns: cfg?.persistRuns ?? true,
+            },
+            store,
+          );
+        } catch {
+          // Host session-entry failures must not prevent the session from starting.
+        }
         seedWorkflowLifecycleNotificationState(runtimeState.lifecycleNotificationState, store.snapshot());
       });
+      const reason = typeof event === "object" && event !== null && "reason" in event
+        ? (event as { readonly reason?: string }).reason
+        : undefined;
+      if (reason === "startup" || reason === "resume") {
+        const getEntries = sessionManager.getEntries;
+        if (typeof getEntries === "function") {
+          let authoritativeCatalog: Awaited<ReturnType<typeof runtimeState.runtimeProxy.prepareDurableResumable>> = [];
+          try {
+            authoritativeCatalog = await runtimeState.runtimeProxy.prepareDurableResumable();
+          } catch {
+            // A resume-catalog failure must not prevent the host session from starting.
+          }
+          try {
+            const resumable = findResumableWorkflowNotices(getEntries.call(sessionManager), authoritativeCatalog);
+            if (resumable.length > 0) {
+              const commands = resumable
+                .map((workflow) => `\`${workflow.name}\` (${workflow.workflowId.slice(0, 8)}): /workflow resume ${workflow.workflowId}`)
+                .join("\n");
+              ctx?.ui?.notify?.(`This session has resumable workflows:\n${commands}`, "info");
+            }
+          } catch {
+            // Host session-entry failures must not prevent the session from starting.
+          }
+        }
+      }
     }
   });
 

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

@@ -148,6 +148,16 @@ export function createWorkflowExtensionRuntimeState(
     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); },
+    prepareCompletedDurable() {
+      return runtimeRef.current.prepareCompletedDurable?.() ?? Promise.resolve([]);
+    },
+    openCompletedDurableWorkflow(workflowIdOrPrefix, catalog) {
+      const open = runtimeRef.current.openCompletedDurableWorkflow;
+      if (open === undefined) {
+        return { ok: false, reason: "not_found", message: `No completed durable workflow found for id/prefix: ${workflowIdOrPrefix}` };
+      }
+      return open(workflowIdOrPrefix, catalog);
+    },
   };
 
   function workflowModelCatalogFromContext(ctx?: PiModelContext): WorkflowModelCatalogPort | undefined {

package/dist/builtin/workflows/src/extension/runtime-durable-resume.ts

@@ -0,0 +1,133 @@
+import type { WorkflowExecutionPolicy } from "../shared/types.js";
+import type { StageAdapters } from "../runs/foreground/stage-runner.js";
+import type { RunOpts } from "../runs/foreground/executor.js";
+import type { Store } from "../shared/store.js";
+import type { WorkflowRegistry } from "../workflows/registry.js";
+import {
+  prepareRuntimeDurableResumable,
+  purgeSuppressedWorkflowRuns,
+  resumeDurableWorkflow as resumeDurableWorkflowAdapter,
+  type ResumeDurableDeps,
+  type ResumeDurableResult,
+} from "../durable/resume-runtime.js";
+import { getDurableBackend } from "../durable/factory.js";
+import { scanResumableWorkflows } from "../durable/resume-catalog.js";
+import { isDurableWorkflowResumable } from "../durable/resume-eligibility.js";
+import { listOpenableCompletedWorkflows } from "../durable/completed-catalog.js";
+import {
+  openCompletedDurableWorkflow as openCompletedSnapshot,
+  type OpenCompletedDurableResult,
+} from "../durable/completed-inspection.js";
+import type { ResumableWorkflowEntry } from "../durable/types.js";
+
+export interface DurableResumeRuntime {
+  resumeDurableWorkflow(
+    workflowIdOrPrefix: string,
+    options?: { readonly policy?: WorkflowExecutionPolicy },
+  ): ResumeDurableResult;
+  listDurableResumable(sessionDir?: string): readonly ResumableWorkflowEntry[];
+  prepareDurableResumable(
+    workflowIdOrPrefix?: string,
+    sessionDir?: string,
+  ): Promise<readonly ResumableWorkflowEntry[]>;
+  prepareCompletedDurable?(): Promise<readonly ResumableWorkflowEntry[]>;
+  openCompletedDurableWorkflow?(
+    workflowIdOrPrefix: string,
+    catalog?: readonly ResumableWorkflowEntry[],
+  ): OpenCompletedDurableResult;
+}
+
+export interface DurableResumeRuntimeDeps {
+  readonly registry: WorkflowRegistry;
+  readonly store: Store;
+  readonly adapters?: StageAdapters;
+  readonly runtimeCwd: string;
+  readonly ensureReady: () => Promise<void>;
+  readonly resolveDefaultStageSessionDir?: () => string | undefined;
+  readonly baseRunOpts: (policy?: WorkflowExecutionPolicy) => RunOpts;
+}
+
+export function createDurableResumeRuntime(
+  deps: DurableResumeRuntimeDeps,
+): DurableResumeRuntime {
+  const hydrateStoredWorkflowCandidates = async (backend: ReturnType<typeof getDurableBackend>, target?: string): Promise<void> => {
+    if (backend.hydrateWorkflow === undefined) return;
+    const ids = deps.store.runs()
+      .map((run) => run.id)
+      .filter((id) => target === undefined || id === target || id.startsWith(target));
+    for (const id of ids) await backend.hydrateWorkflow(id);
+  };
+  let preparedCatalog: readonly ResumableWorkflowEntry[] = [];
+  return {
+    resumeDurableWorkflow(workflowIdOrPrefix, options): ResumeDurableResult {
+      const adapterDeps: ResumeDurableDeps = {
+        registry: deps.registry,
+        baseRunOpts: deps.baseRunOpts(options?.policy),
+        durableBackend: getDurableBackend(),
+      };
+      return resumeDurableWorkflowAdapter(workflowIdOrPrefix, adapterDeps, preparedCatalog);
+    },
+    listDurableResumable(sessionDir): readonly ResumableWorkflowEntry[] {
+      const backend = getDurableBackend();
+      const live = backend.listResumableWorkflows();
+      const dir = sessionDir ?? deps.resolveDefaultStageSessionDir?.();
+      if (dir === undefined) return live;
+      const scanned = scanResumableWorkflows(dir);
+      const liveIds = new Set(live.map((entry) => entry.workflowId));
+      const compatible = scanned.filter((entry) => {
+        const handle = backend.getWorkflow(entry.workflowId);
+        return !liveIds.has(entry.workflowId) && handle !== undefined && isDurableWorkflowResumable(handle);
+      });
+      return [...live, ...compatible];
+    },
+    async prepareDurableResumable(workflowIdOrPrefix, sessionDir) {
+      await deps.ensureReady();
+      const backend = getDurableBackend();
+      try {
+        await hydrateStoredWorkflowCandidates(backend, workflowIdOrPrefix);
+        preparedCatalog = await prepareRuntimeDurableResumable(
+          () => backend,
+          () => deps.resolveDefaultStageSessionDir?.(),
+          workflowIdOrPrefix,
+          sessionDir,
+        );
+        return preparedCatalog;
+      } finally {
+        purgeSuppressedWorkflowRuns(backend, deps.store);
+      }
+    },
+    async prepareCompletedDurable() {
+      await deps.ensureReady();
+      const backend = getDurableBackend();
+      try {
+        await backend.hydrateResumableWorkflows?.();
+        await hydrateStoredWorkflowCandidates(backend);
+        return listOpenableCompletedWorkflows(backend);
+      } finally {
+        purgeSuppressedWorkflowRuns(backend, deps.store);
+      }
+    },
+    openCompletedDurableWorkflow(workflowIdOrPrefix, catalog) {
+      const backend = getDurableBackend();
+      const entry = resolveCatalogEntry(workflowIdOrPrefix, catalog ?? []);
+      const handle = backend.getWorkflow(entry?.workflowId ?? workflowIdOrPrefix);
+      return openCompletedSnapshot(workflowIdOrPrefix, {
+        durableBackend: backend,
+        store: deps.store,
+        adapters: deps.adapters,
+        cwd: handle?.workflowCwd ?? handle?.invocationCwd ?? deps.runtimeCwd,
+        defaultSessionDir: deps.resolveDefaultStageSessionDir?.(),
+      }, catalog);
+    },
+  };
+}
+
+function resolveCatalogEntry(
+  workflowIdOrPrefix: string,
+  catalog: readonly ResumableWorkflowEntry[],
+): ResumableWorkflowEntry | undefined {
+  const exact = catalog.find((entry) => entry.workflowId === workflowIdOrPrefix);
+  if (exact !== undefined) return exact;
+  const matches = catalog.filter((entry) => entry.workflowId.startsWith(workflowIdOrPrefix));
+  return matches.length === 1 ? matches[0] : undefined;
+}

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

@@ -43,11 +43,12 @@ 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 { initializeDbosDurableBackendFromEnv } from "../durable/factory.js";
 import { directMode, directModelRequests, directOptions, directProgressTotal } from "./runtime-direct.js";
+import {
+  createDurableResumeRuntime,
+  type DurableResumeRuntime,
+} from "./runtime-durable-resume.js";
 
 // ---------------------------------------------------------------------------
 // Options
@@ -98,7 +99,7 @@ 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 };
 
-export interface ExtensionRuntime {
+export interface ExtensionRuntime extends DurableResumeRuntime {
   /**
    * Live registry — read-only reference.
    * Reflects all definitions registered at startup.
@@ -117,16 +118,6 @@ 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;
@@ -163,7 +154,6 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
   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 =
@@ -471,30 +461,15 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
     },
 
     resumeFailedRun,
+    ...createDurableResumeRuntime({
+      registry,
+      store: activeStore,
+      adapters,
+      runtimeCwd,
+      ensureReady: ensureDbosReady,
+      resolveDefaultStageSessionDir,
+      baseRunOpts: (policy) => runOptions({ workflow: "", inputs: {} }, policy),
+    }),
 
-    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

@@ -140,14 +140,17 @@ async function createTestAgentSession(_options?: CreateAgentSessionOptions): Pro
     },
     async compact(): ReturnType<StageSessionRuntime["compact"]> {
       return {
-        promptVersion: 1,
+        compactedText: "[User]: retained",
+        firstKeptEntryId: "kept",
+        tokensBefore: 0,
+        promptVersion: 3,
         parameters: { compression_ratio: 0.5, preserve_recent: 2, query: "auto-detected" },
-        deletedTargets: [],
-        protectedEntryIds: [],
+        rung: "planned",
         stats: {
-          objectsBefore: 0,
-          objectsAfter: 0,
-          objectsDeleted: 0,
+          linesBefore: 0,
+          linesDeleted: 0,
+          linesKept: 0,
+          rangeCount: 0,
           tokensBefore: 0,
           tokensAfter: 0,
           percentReduction: 0,

package/dist/builtin/workflows/src/extension/workflow-durable-resume-command.ts

@@ -0,0 +1,226 @@
+import type { WorkflowPersistencePort } from "../shared/types.js";
+import { store } from "../shared/store.js";
+import type { RunSnapshot } from "../shared/store-types.js";
+import { openWorkflowResumeSelector } from "../tui/workflow-resume-selector.js";
+import type { GraphOverlayPort } from "../tui/overlay-adapter.js";
+import { formatResumableWorkflowList } from "../durable/resume-catalog.js";
+import { getDurableBackend } from "../durable/factory.js";
+import { listOpenableCompletedWorkflows } from "../durable/completed-catalog.js";
+import { openCompletedDurableWorkflow } from "../durable/completed-inspection.js";
+import type { ResumableWorkflowEntry } from "../durable/types.js";
+import type { ExtensionRuntime } from "./runtime.js";
+import type { ExtensionAPI, PiCommandContext } from "./public-types.js";
+import type { WorkflowCommandReporter } from "./workflow-command-utils.js";
+import { workflowPolicyFromContext } from "./workflow-policy.js";
+import { formatWorkflowResourceLoadWarning } from "./workflow-command-surfaces.js";
+import { overlaySurfaceFromContext } from "./workflow-targets.js";
+
+export interface WorkflowRunControlDeps {
+  pi: ExtensionAPI;
+  overlay: GraphOverlayPort;
+  getPersistence: () => WorkflowPersistencePort | undefined;
+  runtimeForContext: (ctx?: PiCommandContext) => ExtensionRuntime;
+  ensureWorkflowResourcesLoaded: () => Promise<void> | void;
+}
+
+export interface WorkflowResumeCatalog {
+  readonly resumable: readonly ResumableWorkflowEntry[];
+  readonly completed: readonly ResumableWorkflowEntry[];
+}
+
+export interface WorkflowResumeTarget {
+  readonly kind: "live" | "durable" | "completed";
+  readonly workflowId: string;
+  readonly name: string;
+}
+
+export type WorkflowResumeTargetResolution = WorkflowResumeTarget
+  | { readonly kind: "ambiguous"; readonly matches: readonly WorkflowResumeTarget[] }
+  | { readonly kind: "not_found" };
+
+export async function prepareWorkflowResumeCatalog(
+  runtime: ExtensionRuntime,
+  activeLiveIds: ReadonlySet<string>,
+  target?: string,
+): Promise<WorkflowResumeCatalog> {
+  const prepared = await runtime.prepareDurableResumable(target);
+  const backend = getDurableBackend();
+  const resumable = filterSelectorDurableEntries(runtime, prepared)
+    .filter((entry) => !activeLiveIds.has(entry.workflowId) && backend.isWorkflowLoadable(entry.workflowId));
+  const completed = runtime.prepareCompletedDurable !== undefined
+    ? await runtime.prepareCompletedDurable()
+    : listOpenableCompletedWorkflows(backend);
+  return {
+    resumable,
+    completed: completed.filter((entry) => !activeLiveIds.has(entry.workflowId) && backend.isWorkflowLoadable(entry.workflowId)),
+  };
+}
+
+export async function handleDurableResume(
+  target: string | undefined,
+  ctx: PiCommandContext,
+  reporter: WorkflowCommandReporter,
+  deps: WorkflowRunControlDeps,
+): Promise<boolean> {
+  const print = (message: string): void => reporter.info(message);
+  const fail = (message: string): void => reporter.error(message);
+  try {
+    await deps.ensureWorkflowResourcesLoaded();
+  } catch (error) {
+    ctx.ui?.notify(formatWorkflowResourceLoadWarning(error), "warning");
+  }
+  const runtime = deps.runtimeForContext(ctx);
+  const policy = workflowPolicyFromContext(ctx);
+  const catalog = await prepareWorkflowResumeCatalog(runtime, new Set(), target);
+  const allOpenable = [...catalog.resumable, ...catalog.completed];
+
+  if (target !== undefined) {
+    const resolved = resolveWorkflowResumeTarget(
+      target,
+      [],
+      catalog.resumable,
+      getDurableBackend().listCompletedWorkflows(),
+    );
+    if (resolved.kind === "ambiguous") {
+      fail(`Ambiguous workflow prefix "${target}" matches: ${formatMatches(resolved.matches)}`);
+      return true;
+    }
+    if (resolved.kind === "completed") {
+      return openCompletedTarget(resolved.workflowId, catalog.completed, ctx, reporter, deps, runtime);
+    }
+    if (resolved.kind === "durable") {
+      return resumeDurableTarget(resolved.workflowId, ctx, reporter, deps, runtime);
+    }
+
+    const completedAttempt = openCompleted(runtime, target, catalog.completed);
+    if (!completedAttempt.ok && completedAttempt.reason !== "not_found") {
+      fail(completedAttempt.message);
+      return true;
+    }
+    const result = runtime.resumeDurableWorkflow(target, { policy });
+    fail(allOpenable.length === 0
+      ? result.message
+      : `${result.message}\n\n${formatResumableWorkflowList(allOpenable)}`);
+    return true;
+  }
+
+  if (allOpenable.length === 0) {
+    fail("No resumable or completed durable workflows found. Usage: /workflow resume <id> (or /resume for Atomic sessions).");
+    return true;
+  }
+  if (!policy.allowInputPicker) {
+    const instruction = catalog.completed.length === 0 ? "Resume with" : "Resume/open with";
+    print(`${formatResumableWorkflowList(allOpenable)}\n\n${instruction}: /workflow resume <id>`);
+    return true;
+  }
+  const picked = await openWorkflowResumeSelector(ctx.ui, [], catalog.resumable, catalog.completed);
+  if (picked.kind === "durable") {
+    return resumeDurableTarget(picked.workflowId, ctx, reporter, deps, runtime);
+  }
+  if (picked.kind === "completed") {
+    return openCompletedTarget(picked.workflowId, catalog.completed, ctx, reporter, deps, runtime);
+  }
+  return true;
+}
+
+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 requiresDefinition = entry.status === "running" || entry.status === "failed" || entry.status === "blocked";
+    return !requiresDefinition || registry.has(entry.name);
+  });
+}
+
+export function resolveWorkflowResumeTarget(
+  target: string,
+  liveRuns: readonly RunSnapshot[],
+  resumable: readonly ResumableWorkflowEntry[],
+  completed: readonly ResumableWorkflowEntry[],
+): WorkflowResumeTargetResolution {
+  const targets = new Map<string, WorkflowResumeTarget>();
+  for (const entry of resumable) {
+    targets.set(entry.workflowId, { kind: "durable", workflowId: entry.workflowId, name: entry.name });
+  }
+  for (const entry of completed) {
+    targets.set(entry.workflowId, { kind: "completed", workflowId: entry.workflowId, name: entry.name });
+  }
+  for (const run of liveRuns.filter(isExplicitResumeCandidate)) {
+    targets.set(run.id, {
+      kind: run.status === "completed" ? "completed" : "live",
+      workflowId: run.id,
+      name: run.name,
+    });
+  }
+  const exact = targets.get(target);
+  if (exact !== undefined) return exact;
+  const matches = [...targets.values()].filter((candidate) => candidate.workflowId.startsWith(target));
+  if (matches.length === 0) return { kind: "not_found" };
+  if (matches.length === 1) return matches[0]!;
+  return { kind: "ambiguous", matches };
+}
+
+function isExplicitResumeCandidate(run: RunSnapshot): boolean {
+  if (run.status === "completed" || run.status === "paused" || run.exitReason === "quit") return true;
+  if (run.stages.some((stage) => stage.status === "paused")) return true;
+  if (run.status === "failed") return run.resumable !== false;
+  if (run.endedAt !== undefined) return false;
+  if (run.status === "running") return true;
+  return run.resumable === true && run.failureRecoverability === "recoverable";
+}
+
+function resumeDurableTarget(
+  workflowId: string,
+  ctx: PiCommandContext,
+  reporter: WorkflowCommandReporter,
+  deps: WorkflowRunControlDeps,
+  runtime: ExtensionRuntime,
+): boolean {
+  const result = runtime.resumeDurableWorkflow(workflowId, { policy: workflowPolicyFromContext(ctx) });
+  if (!result.ok) reporter.error(result.message);
+  else {
+    reporter.info(result.message);
+    if (workflowPolicyFromContext(ctx).allowInputPicker) {
+      deps.overlay.open(result.runId, overlaySurfaceFromContext(ctx));
+    }
+  }
+  return true;
+}
+
+function openCompletedTarget(
+  workflowId: string,
+  catalog: readonly ResumableWorkflowEntry[],
+  ctx: PiCommandContext,
+  reporter: WorkflowCommandReporter,
+  deps: WorkflowRunControlDeps,
+  runtime: ExtensionRuntime,
+): boolean {
+  const result = openCompleted(runtime, workflowId, catalog);
+  if (!result.ok) reporter.error(result.message);
+  else {
+    reporter.info(result.message);
+    if (workflowPolicyFromContext(ctx).allowInputPicker) {
+      deps.overlay.open(result.runId, overlaySurfaceFromContext(ctx));
+    }
+  }
+  return true;
+}
+
+function openCompleted(
+  runtime: ExtensionRuntime,
+  workflowIdOrPrefix: string,
+  catalog: readonly ResumableWorkflowEntry[],
+) {
+  return runtime.openCompletedDurableWorkflow?.(workflowIdOrPrefix, catalog)
+    ?? openCompletedDurableWorkflow(workflowIdOrPrefix, {
+      durableBackend: getDurableBackend(),
+      store,
+    }, catalog);
+}
+
+function formatMatches(entries: readonly WorkflowResumeTarget[]): string {
+  return entries.map((entry) => `${entry.name} (${entry.workflowId.slice(0, 8)})`).join(", ");
+}

package/dist/builtin/workflows/src/extension/workflow-prompts.ts

@@ -23,6 +23,7 @@ export const DEFAULT_PROMPT_GUIDANCE: string[] = [
   `**Workflow discovery and lifecycle**:
   - For unfamiliar named workflows, discover with \`action: "list"\`, inspect with \`action: "get"\` or \`action: "inputs"\`, and run with \`action: "run"\`, \`workflow\`, and validated \`inputs\`; do not invent workflow names or input keys.
   - In interactive chat, launch every workflow in the background. Named workflow launches are already detached; direct \`task\`, \`tasks\`, and \`chain\` launches must set top-level \`async: true\`. This applies only to launches, not inspection or control calls (\`status\`, \`stages\`, \`stage\`, \`transcript\`, \`send\`, \`pause\`, \`resume\`, \`interrupt\`, \`kill\`). Use foreground execution only when the user explicitly requests it or it is technically required, and tell the user before launching it.
+  - Natural-language instructions to create or use a worktree do not enable runner isolation. For write-capable direct tasks, set \`worktree: true\` or \`gitWorktreeDir\`; \`cwd\` only selects the starting directory and runs in that checkout. For independent queues, prefer one run per independent item with its own reusable worktree.
   - Once you run a workflow, end the current turn and wait for user input or a lifecycle notice. Do not use sleep/status polling loops: key start, finish, and failure events arrive automatically. Use targeted \`status\`/\`stages\`/\`stage\` checks only when the user asks or the next step needs them, and use \`send\`/\`pause\`/\`resume\`/\`interrupt\`/\`kill\` only to answer, steer, or honor control requests.
   - For transcripts, avoid whole-file reads. Get \`sessionFile\`/\`transcriptPath\` from \`stages\` or \`stage\`, preserve the exact path and platform separators, search with \`rg\`/\`grep\`, and read small relevant ranges; use explicit \`tail\` or \`limit\` only for a bounded preview.`,
   `**Workflow authoring and handoffs**: