@bastani/atomic 0.9.9 → 0.9.10

package/dist/builtin/workflows/src/extension/public-types.ts

@@ -4,14 +4,8 @@ import type {
 } from "@bastani/atomic";
 import type { SessionManager } from "../shared/persistence-restore.js";
 import type { StageSessionRuntime } from "../runs/foreground/stage-runner.js";
-import type { StageStatus } from "../shared/store-types.js";
-import type {
-  StageOptions,
-  WorkflowChainStep,
-  WorkflowDirectTaskItem,
-  WorkflowInputValues,
-  WorkflowMaxOutput,
-} from "../shared/types.js";
+import type { RunStatus, StageStatus } from "../shared/store-types.js";
+import type { WorkflowInputValues } from "../shared/types.js";
 import type { WidgetFactory } from "../tui/store-widget-installer.js";
 import type { RenderResultOpts, WorkflowToolResult } from "./render-result.js";
 import type { PiUISurface } from "./wiring.js";
@@ -148,6 +142,10 @@ export interface WorkflowResourceInfo {
   };
 }
 
+type StageLateMessageRouter = NonNullable<
+  NonNullable<CreateAgentSessionOptions["orchestrationContext"]>["lateMessageRouter"]
+>;
+
 export interface ExtensionAPI {
   registerTool?: <TArgs, TResult>(opts: PiToolOpts<TArgs, TResult>) => void;
   registerCommand?: (name: string, options: PiCommandOptions) => void;
@@ -155,20 +153,8 @@ export interface ExtensionAPI {
     event: string,
     renderer: PiMessageRenderer,
   ) => void;
-  sendMessage?: <T = unknown>(
-    message: {
-      customType: string;
-      content?: string;
-      display?: boolean;
-      details?: T;
-    },
-    options?: {
-      triggerTurn?: boolean;
-      deliverAs?: "steer" | "followUp" | "nextTurn" | "interrupt";
-      excludeFromContext?: boolean;
-      interruptAbortMessage?: string;
-    },
-  ) => void | Promise<void>;
+  sendMessage?: StageLateMessageRouter["routeMessage"];
+  sendMessages?: StageLateMessageRouter["routeMessages"];
   registerFlag?: (name: string, opts: PiFlagNamedOpts) => void;
   getWorkflowResources?: () => readonly WorkflowResourceInfo[];
   refreshWorkflowResources?: () => Promise<readonly WorkflowResourceInfo[]>;
@@ -232,7 +218,7 @@ export interface ExtensionAPI {
   [key: string]: unknown;
 }
 
-export interface WorkflowToolArgs extends StageOptions {
+export interface WorkflowToolArgs {
   workflow?: string;
   inputs?: WorkflowInputValues;
   action?:
@@ -246,7 +232,7 @@ export interface WorkflowToolArgs extends StageOptions {
     | "send"
     | "pause"
     | "interrupt"
-    | "kill"
+    | "quit"
     | "resume"
     | "reload"
     | "inputs";
@@ -254,7 +240,7 @@ export interface WorkflowToolArgs extends StageOptions {
   all?: boolean;
   stageId?: string;
   message?: string;
-  statusFilter?: StageStatus | "all";
+  statusFilter?: StageStatus | RunStatus | "all";
   format?: "text" | "json";
   limit?: number;
   tail?: number;
@@ -264,32 +250,6 @@ export interface WorkflowToolArgs extends StageOptions {
   delivery?: "auto" | "answer" | "prompt" | "steer" | "followUp" | "resume";
   promptId?: string;
   reason?: string;
-  task?: WorkflowDirectTaskItem | string;
-  tasks?: WorkflowDirectTaskItem[];
-  chain?: WorkflowChainStep[];
-  chainName?: string;
-  context?: "fresh" | "fork";
-  forkFromSessionFile?: string;
-  concurrency?: number;
-  failFast?: boolean;
-  async?: boolean;
-  intercom?: {
-    enabled?: boolean;
-    delivery?: "off" | "notify" | "result" | "control-and-result";
-    parentSession?: string;
-    notifyOn?: Array<
-      "active_long_running" | "needs_attention" | "completed" | "failed"
-    >;
-  };
-  output?: string | false;
-  outputMode?: "inline" | "file-only";
-  reads?: readonly string[] | false;
-  chainDir?: string;
-  maxOutput?: WorkflowMaxOutput;
-  artifacts?: boolean;
-  worktree?: boolean;
-  gitWorktreeDir?: string;
-  baseBranch?: string;
 }
 
 export type WorkflowExecuteToolResult = PiAgentToolResult<WorkflowToolResult>;

package/dist/builtin/workflows/src/extension/render-call.ts

@@ -21,22 +21,16 @@ export interface WorkflowToolArgs {
     | "send"
     | "pause"
     | "interrupt"
-    | "kill"
+    | "quit"
     | "resume"
     | "reload"
     | "inputs";
   runId?: string;
-  task?: { name?: string; prompt?: string; task?: string } | string;
-  tasks?: readonly unknown[];
-  chain?: readonly unknown[];
 }
 
 function runTarget(args: WorkflowToolArgs): string | undefined {
   if (args.workflow !== undefined && args.workflow.trim().length > 0) return args.workflow;
   if (args.runId !== undefined && args.runId.trim().length > 0) return args.runId;
-  if (args.task !== undefined) return "direct-task";
-  if (args.tasks !== undefined) return "direct-parallel";
-  if (args.chain !== undefined) return "direct-chain";
   return undefined;
 }
 
@@ -101,8 +95,8 @@ export function renderCall(args: WorkflowToolArgs, opts: RenderCallOpts = {}): s
         ? "workflow: interrupt run"
         : `workflow: interrupt run ${quoted(name)}`;
       break;
-    case "kill":
-      line = name === undefined ? "workflow: kill run" : `workflow: kill run ${quoted(name)}`;
+    case "quit":
+      line = name === undefined ? "workflow: quit run" : `workflow: quit run ${quoted(name)}`;
       break;
     case "resume":
       line = name === undefined

package/dist/builtin/workflows/src/extension/render-result.ts

@@ -12,6 +12,7 @@
  */
 
 import type { PendingPrompt, RunSnapshot, StageInputRequest, StageSnapshot, StageStatus } from "../shared/store-types.js";
+import type { WorkflowRunStatusFilter, WorkflowRunStatusSummary } from "./workflow-status-summary.js";
 import type { WorkflowDetails } from "../shared/types.js";
 import type { RunDetail } from "../runs/background/status.js";
 import { renderInputsSchema } from "../shared/render-inputs-schema.js";
@@ -64,7 +65,11 @@ type ListResult = {
 };
 type StatusResult = {
   action: "status";
-  /** Live snapshots from the in-process store. */
+  /** Applied run-status filter; "all" when unfiltered. */
+  filter: WorkflowRunStatusFilter;
+  /** Concise per-run summaries (in-flight runs first) for agent consumption. */
+  runs: WorkflowRunStatusSummary[];
+  /** Live snapshots from the in-process store, filtered like `runs`. */
   snapshots: RunSnapshot[];
 };
 type StatusDetailResult =
@@ -142,7 +147,7 @@ type SendResult = { action: "send"; runId: string; stageId: string; delivery: st
 type PauseResult = { action: "pause"; runId: string; status: string; message: string };
 type ReloadResult = WorkflowReloadReport & { action: "reload"; status: "ok" | "noop"; message: string };
 type InterruptResult = { action: "interrupt"; runId: string; status: string; message: string };
-type KillResult = { action: "kill"; runId: string; status: string; message: string };
+type QuitResult = { action: "quit"; runId: string; status: string; message: string };
 type ResumeResult = { action: "resume"; runId: string; status: string; message: string };
 
 export type WorkflowToolResult =
@@ -159,7 +164,7 @@ export type WorkflowToolResult =
   | PauseResult
   | ReloadResult
   | InterruptResult
-  | KillResult
+  | QuitResult
   | ResumeResult;
 
 export interface RenderResultOpts {
@@ -339,8 +344,18 @@ export function renderResult(result: WorkflowToolResult, opts?: RenderResultOpts
         return renderNotice("WORKFLOW RUN", `${r.runId}${label}: ${r.status} — ${r.error}`, opts, themed);
       }
       if (r.details) {
+        if (r.details.status === "accepted" && r.name && r.runId) {
+          return renderDispatchConfirm({
+            workflowName: r.name,
+            runId: r.runId,
+            inputs: opts?.runInputs ?? {},
+            theme: themed ? deriveGraphTheme({}) : undefined,
+            width: opts?.width,
+          });
+        }
         const label = r.name ? ` (${r.name})` : "";
-        return renderNotice("WORKFLOW RUN", `${r.runId}${label}: ${r.details.mode} ${r.details.status}`, opts, themed);
+        const guidance = r.details.message === undefined ? "" : ` — ${r.details.message}`;
+        return renderNotice("WORKFLOW RUN", `${r.runId}${label}: ${r.details.mode} ${r.details.status}${guidance}`, opts, themed);
       }
       if (r.status === "completed" || r.status === "skipped" || r.status === "cancelled" || r.status === "blocked" || r.status === "killed") {
         const label = r.name ? ` (${r.name})` : "";
@@ -407,9 +422,9 @@ export function renderResult(result: WorkflowToolResult, opts?: RenderResultOpts
       return renderNotice("WORKFLOW INTERRUPT", `${r.runId}: ${r.message}`, opts, themed);
     }
 
-    case "kill": {
-      const r = result as KillResult;
-      return renderNotice("WORKFLOW KILL", `${r.runId}: ${r.message}`, opts, themed);
+    case "quit": {
+      const r = result as QuitResult;
+      return renderNotice("WORKFLOW QUIT", `${r.runId}: ${r.message}`, opts, themed);
     }
 
     case "resume": {

package/dist/builtin/workflows/src/extension/runtime-active-block-claim.ts

@@ -0,0 +1,78 @@
+import type { DurableWorkflowBackend } from "../durable/backend.js";
+import type { Store } from "../shared/store.js";
+import type { RunSnapshot } from "../shared/store-types.js";
+import type { WorkflowPersistencePort } from "../shared/types.js";
+import { appendRunEnd } from "../shared/persistence-session-entries.js";
+
+/**
+ * Source ids whose active-block resume is currently in flight in this process.
+ * Held across the dispatch+finalize window so a concurrent same-session resume
+ * cannot double-dispatch; released once the local source is killed (after
+ * which same-session routing refuses it). Cross-process concurrent resume is
+ * not guarded here — it is the same recoverable, idempotent-replay edge that
+ * exists for any durable failed/blocked run.
+ */
+const inFlightActiveBlockResumes = new Set<string>();
+
+/**
+ * Claim the right to resume an active recoverable block in this process. The
+ * durable source is intentionally NOT mutated: it stays `blocked`/resumable so
+ * it remains discoverable and recoverable — including a zero-checkpoint
+ * first-stage block — if the process dies before the continuation settles.
+ */
+export function claimActiveBlockedResume(_backend: DurableWorkflowBackend, sourceId: string): boolean {
+  if (inFlightActiveBlockResumes.has(sourceId)) return false;
+  inFlightActiveBlockResumes.add(sourceId);
+  return true;
+}
+
+/** Release an in-flight claim (dispatch failed, or the source was finalized). */
+export function releaseActiveBlockedClaim(sourceId: string): void {
+  inFlightActiveBlockResumes.delete(sourceId);
+}
+
+/** Remove a continuation that settled before startup admission completed. */
+export async function discardFailedActiveBlockedContinuation(
+  backend: DurableWorkflowBackend,
+  runId: string,
+  store: Store,
+): Promise<void> {
+  store.removeRun(runId);
+  const handle = backend.getWorkflow(runId);
+  if (handle?.status === "running") {
+    backend.setWorkflowStatus(runId, "failed", handle.pendingPrompts, false);
+    await backend.flush();
+  }
+  const deleted = await backend.deleteWorkflowIfInactive(runId);
+  if (!deleted.ok && deleted.reason !== "not_found") {
+    throw new Error(`continuation ${runId} remained ${deleted.reason}`);
+  }
+}
+/**
+ * Mark the resumed source killed locally so the same session will not re-resume
+ * it. The durable source is intentionally left `blocked`/resumable for
+ * cross-session/crash recoverability; killing only the in-session snapshot is
+ * safe because same-session resume resolution consults that snapshot.
+ */
+export function finalizeResumedActiveBlockedSourceRun(
+  source: RunSnapshot,
+  continuationRunId: string,
+  store: Store,
+  persistence?: WorkflowPersistencePort,
+): void {
+  const error = source.error ?? source.failureMessage ?? `workflow resumed in new run ${continuationRunId}`;
+  const metadata = {
+    ...(source.failureKind !== undefined ? { failureKind: source.failureKind } : {}),
+    ...(source.failureCode !== undefined ? { failureCode: source.failureCode } : {}),
+    failureRecoverability: "non_recoverable" as const,
+    failureDisposition: "terminal_killed" as const,
+    ...(source.failureMessage !== undefined ? { failureMessage: source.failureMessage } : {}),
+    ...(source.failedStageId !== undefined ? { failedStageId: source.failedStageId } : {}),
+    resumable: false,
+    ...(source.retryAfterMs !== undefined ? { retryAfterMs: source.retryAfterMs } : {}),
+  };
+  const recorded = store.recordRunEnd(source.id, "killed", undefined, error, metadata);
+  if (recorded && persistence !== undefined) {
+    appendRunEnd(persistence, { runId: source.id, status: "killed", error, ...metadata, ts: Date.now() });
+  }
+}

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

@@ -2,33 +2,38 @@ 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 { JobTracker } from "../runs/background/job-tracker.js";
 import type { WorkflowRegistry } from "../workflows/registry.js";
 import {
   prepareRuntimeDurableResumable,
+  prepareTargetedDurableResumable,
   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";
+import type { DurableWorkflowCatalogEntries } from "../durable/backend.js";
 
 export interface DurableResumeRuntime {
   resumeDurableWorkflow(
     workflowIdOrPrefix: string,
     options?: { readonly policy?: WorkflowExecutionPolicy },
-  ): ResumeDurableResult;
-  listDurableResumable(sessionDir?: string): readonly ResumableWorkflowEntry[];
+  ): Promise<ResumeDurableResult>;
+  listDurableResumable(): readonly ResumableWorkflowEntry[];
   prepareDurableResumable(
     workflowIdOrPrefix?: string,
-    sessionDir?: string,
+  ): Promise<readonly ResumableWorkflowEntry[]>;
+  prepareDurableCatalog?(): Promise<DurableWorkflowCatalogEntries>;
+  /** Hydrate a bounded set of known DBOS workflow ids. */
+  prepareDurableResumableForIds?(
+    workflowIds: readonly string[],
   ): Promise<readonly ResumableWorkflowEntry[]>;
   prepareCompletedDurable?(): Promise<readonly ResumableWorkflowEntry[]>;
   openCompletedDurableWorkflow?(
@@ -45,13 +50,13 @@ export interface DurableResumeRuntimeDeps {
   readonly ensureReady: () => Promise<void>;
   readonly resolveDefaultStageSessionDir?: () => string | undefined;
   readonly baseRunOpts: (policy?: WorkflowExecutionPolicy) => RunOpts;
+  readonly jobs?: JobTracker;
 }
 
 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));
@@ -59,38 +64,54 @@ export function createDurableResumeRuntime(
   };
   let preparedCatalog: readonly ResumableWorkflowEntry[] = [];
   return {
-    resumeDurableWorkflow(workflowIdOrPrefix, options): ResumeDurableResult {
+    async resumeDurableWorkflow(workflowIdOrPrefix, options): Promise<ResumeDurableResult> {
+      await deps.ensureReady();
+      const backend = getDurableBackend();
+      if (preparedCatalog.length === 0) {
+        preparedCatalog = await prepareRuntimeDurableResumable(() => backend, workflowIdOrPrefix);
+      }
+      const resolved = resolveCatalogEntry(workflowIdOrPrefix, preparedCatalog);
+      if (resolved !== undefined) await backend.hydrateWorkflow(resolved.workflowId);
       const adapterDeps: ResumeDurableDeps = {
         registry: deps.registry,
         baseRunOpts: deps.baseRunOpts(options?.policy),
-        durableBackend: getDurableBackend(),
+        durableBackend: backend,
+        ...(deps.jobs !== undefined ? { jobs: deps.jobs } : {}),
       };
-      return resumeDurableWorkflowAdapter(workflowIdOrPrefix, adapterDeps, preparedCatalog);
+      return await 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];
+    listDurableResumable(): readonly ResumableWorkflowEntry[] {
+      return getDurableBackend().listResumableWorkflows();
     },
-    async prepareDurableResumable(workflowIdOrPrefix, sessionDir) {
+    async prepareDurableResumable(workflowIdOrPrefix) {
       await deps.ensureReady();
       const backend = getDurableBackend();
       try {
         await hydrateStoredWorkflowCandidates(backend, workflowIdOrPrefix);
-        preparedCatalog = await prepareRuntimeDurableResumable(
-          () => backend,
-          () => deps.resolveDefaultStageSessionDir?.(),
-          workflowIdOrPrefix,
-          sessionDir,
-        );
+        preparedCatalog = await prepareRuntimeDurableResumable(() => backend, workflowIdOrPrefix);
+        return preparedCatalog;
+      } finally {
+        purgeSuppressedWorkflowRuns(backend, deps.store);
+      }
+    },
+    async prepareDurableCatalog() {
+      await deps.ensureReady();
+      const backend = getDurableBackend();
+      try {
+        await backend.hydrateResumableWorkflows();
+        await hydrateStoredWorkflowCandidates(backend);
+        const catalog = await backend.prepareWorkflowCatalog();
+        preparedCatalog = catalog.resumable;
+        return catalog;
+      } finally {
+        purgeSuppressedWorkflowRuns(backend, deps.store);
+      }
+    },
+    async prepareDurableResumableForIds(workflowIds) {
+      await deps.ensureReady();
+      const backend = getDurableBackend();
+      try {
+        preparedCatalog = await prepareTargetedDurableResumable(backend, workflowIds);
         return preparedCatalog;
       } finally {
         purgeSuppressedWorkflowRuns(backend, deps.store);
@@ -100,7 +121,7 @@ export function createDurableResumeRuntime(
       await deps.ensureReady();
       const backend = getDurableBackend();
       try {
-        await backend.hydrateResumableWorkflows?.();
+        await backend.hydrateResumableWorkflows();
         await hydrateStoredWorkflowCandidates(backend);
         return listOpenableCompletedWorkflows(backend);
       } finally {