@bastani/atomic 0.8.21 → 0.8.22-0

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

@@ -1,7 +1,7 @@
 import type {
   ExtensionAPI,
   PiMessageRenderComponent,
-  PiMessageRendererResult,
+  PiMessageRenderer,
 } from "./index.js";
 import type { Store } from "../shared/store.js";
 import type {
@@ -9,11 +9,14 @@ import type {
   PromptKind,
   RunSnapshot,
   RunStatus,
+  StageInputKind,
   StageSnapshot,
   StageStatus,
   StoreSnapshot,
 } from "../shared/store-types.js";
-import { wrapPlainText } from "../tui/text-helpers.js";
+import { isTopLevelWorkflowRun } from "../shared/run-visibility.js";
+import { deriveGraphThemeFromPiTheme, type GraphTheme } from "../tui/graph-theme.js";
+import { renderWorkflowNoticeCard, type WorkflowNoticeTone } from "../tui/workflow-notice-card.js";
 
 export const LIFECYCLE_NOTICE_CUSTOM_TYPE = "workflows:lifecycle-notice";
 export const LIFECYCLE_NOTICE_SNIPPET_LIMIT = 240;
@@ -40,7 +43,7 @@ export interface WorkflowLifecycleNoticeDetails {
   readonly stageId?: string;
   readonly stageName?: string;
   readonly promptId?: string;
-  readonly promptKind?: PromptKind;
+  readonly promptKind?: PromptKind | StageInputKind;
   readonly promptMessage?: string;
   readonly error?: string;
   readonly failedStageId?: string;
@@ -64,7 +67,7 @@ export interface WorkflowLifecycleNotificationOptions {
   readonly seedExisting?: boolean;
 }
 
-type RawRenderer = (payload: unknown) => PiMessageRendererResult;
+type RawRenderer = PiMessageRenderer;
 
 // Process-lifetime registration dedupe: extension hosts are object identities
 // and may be garbage-collected, but renderer registrations are not unregistered.
@@ -91,6 +94,7 @@ export function seedWorkflowLifecycleNotificationState(
   snapshot: StoreSnapshot,
 ): void {
   for (const run of snapshot.runs) {
+    if (!isTopLevelWorkflowRun(run)) continue;
     if ((run.status === "completed" || run.status === "failed") && run.endedAt !== undefined) {
       state.deliveredTerminalRuns.add(terminalRunKey(run.status, run.id));
     }
@@ -124,6 +128,24 @@ export function withWorkflowLifecycleNotificationsSuppressed<T>(
   }
 }
 
+/**
+ * Async-safe companion to {@link withWorkflowLifecycleNotificationsSuppressed}.
+ * Keeps suppression active until the awaited operation settles, so terminal
+ * store updates produced by background jobs cannot race an awaited headless
+ * workflow dispatch and trigger an extra steer turn before the caller returns.
+ */
+export async function withWorkflowLifecycleNotificationsSuppressedAsync<T>(
+  state: WorkflowLifecycleNotificationState,
+  fn: () => Promise<T>,
+): Promise<T> {
+  state.suppressionDepth += 1;
+  try {
+    return await fn();
+  } finally {
+    state.suppressionDepth -= 1;
+  }
+}
+
 export function installWorkflowLifecycleNotifications(
   options: WorkflowLifecycleNotificationOptions,
 ): () => void {
@@ -141,6 +163,7 @@ export function installWorkflowLifecycleNotifications(
 
   const emit = (details: WorkflowLifecycleNoticeDetails): void => {
     const content = formatWorkflowLifecycleNoticeText(details);
+    const deliveryOptions = { triggerTurn: true, deliverAs: "steer" as const };
     try {
       // Store subscribers are notified in a tight loop. A lifecycle notice
       // failure must never abort sibling subscribers such as status writers.
@@ -152,7 +175,7 @@ export function installWorkflowLifecycleNotifications(
             display: true,
             details,
           },
-          { triggerTurn: true, deliverAs: "steer" },
+          deliveryOptions,
         ),
       ).catch((error: unknown) => warnLifecycleSendFailure(error));
     } catch (error) {
@@ -187,8 +210,9 @@ export function installWorkflowLifecycleNotifications(
     if (state.deliveredInputPrompts.has(key)) return;
 
     state.deliveredInputPrompts.add(key);
-    if (state.suppressionDepth > 0) return;
-    emit(makeStageAwaitingInputNotice(run, stage));
+    // Awaiting-input states are tracked for dedupe/restore, but must not enqueue
+    // a main-chat steer turn. Waking the active agent with an actionable prompt
+    // can let the model answer workflow HIL without a deliberate user action.
   };
 
   const emitRunAwaitingInputNoticeOnce = (run: RunSnapshot): void => {
@@ -198,12 +222,13 @@ export function installWorkflowLifecycleNotifications(
     if (state.deliveredInputPrompts.has(key)) return;
 
     state.deliveredInputPrompts.add(key);
-    if (state.suppressionDepth > 0) return;
-    emit(makeRunAwaitingInputNotice(run, run.pendingPrompt));
+    // See stage-level awaiting-input handling above: prompt state remains visible
+    // through workflow status/connect surfaces instead of the main chat context.
   };
 
   const inspect = (snapshot: StoreSnapshot): void => {
     for (const run of snapshot.runs) {
+      if (!isTopLevelWorkflowRun(run)) continue;
       emitTerminalNoticeOnce(run, "completed");
       emitTerminalNoticeOnce(run, "failed");
 
@@ -227,10 +252,10 @@ export function registerLifecycleNoticeRenderer(
   const host = options.rendererHost ?? register;
   if (rendererRegisteredHosts.has(host)) return;
 
-  const renderer: RawRenderer = (raw) => {
+  const renderer: RawRenderer = (raw, _options, piTheme) => {
     const message = raw as { details?: WorkflowLifecycleNoticeDetails };
     if (!message.details) return undefined;
-    return makeNoticeComponent(message.details);
+    return makeNoticeComponent(message.details, themeFromRenderer(piTheme));
   };
 
   register(LIFECYCLE_NOTICE_CUSTOM_TYPE, renderer);
@@ -240,23 +265,23 @@ export function registerLifecycleNoticeRenderer(
 export function formatWorkflowLifecycleNoticeText(details: WorkflowLifecycleNoticeDetails): string {
   const workflowName = escapeQuotedText(details.workflowName);
   if (details.kind === "completed") {
-    return `✅ Workflow "${workflowName}" completed (run ${details.runId}). Inspect: /workflow status ${details.runId}`;
+    return `✓ Workflow "${workflowName}" completed (run ${details.runId}). Inspect: /workflow status ${details.runId}`;
   }
   if (details.kind === "failed") {
     const stage = details.stageName ?? details.failedStageId;
     const stageText = stage ? `, stage ${stage}` : "";
     const errorText = details.error ? `: ${details.error}` : "";
-    return `❌ Workflow "${workflowName}" failed (run ${details.runId}${stageText})${errorText}. Inspect: /workflow status ${details.runId}`;
+    return `✗ Workflow "${workflowName}" failed (run ${details.runId}${stageText})${errorText}. Inspect: /workflow status ${details.runId}`;
   }
   const prompt = details.promptMessage ? ` Prompt: ${details.promptMessage}` : "";
   if (details.scope === "run") {
-    return `❓ Workflow "${workflowName}" needs input (run ${details.runId}).${prompt} Respond: /workflow connect ${details.runId} to answer this run-level prompt.`;
+    return `？ Workflow "${workflowName}" needs input (run ${details.runId}).${prompt} Respond: /workflow connect ${details.runId} to answer this run-level prompt.`;
   }
   const stage = details.stageName ?? details.stageId ?? "unknown";
   const responseHint = details.stageId && details.promptId
     ? `/workflow connect ${details.runId} or workflow({ action: "send", runId: ${jsonString(details.runId)}, stageId: ${jsonString(details.stageId)}, promptId: ${jsonString(details.promptId)}, response: ... })`
     : `/workflow connect ${details.runId}`;
-  return `❓ Workflow "${workflowName}" needs input (run ${details.runId}, stage ${stage}).${prompt} Respond: ${responseHint}.`;
+  return `？ Workflow "${workflowName}" needs input (run ${details.runId}, stage ${stage}).${prompt} Respond: ${responseHint}.`;
 }
 
 function makeTerminalNotice(
@@ -281,34 +306,6 @@ function makeTerminalNotice(
   };
 }
 
-function makeStageAwaitingInputNotice(run: RunSnapshot, stage: StageSnapshot): WorkflowLifecycleNoticeDetails {
-  const prompt = stage.pendingPrompt;
-  return {
-    kind: "awaiting_input",
-    scope: "stage",
-    runId: run.id,
-    workflowName: run.name,
-    status: stage.status,
-    stageId: stage.id,
-    stageName: stage.name,
-    ...(prompt ? promptFields(prompt) : {}),
-    // Normal store paths stamp awaitingInputSince; Date.now() is defensive for malformed restored snapshots.
-    createdAt: prompt?.createdAt ?? stage.awaitingInputSince ?? Date.now(),
-  };
-}
-
-function makeRunAwaitingInputNotice(run: RunSnapshot, prompt: PendingPrompt): WorkflowLifecycleNoticeDetails {
-  return {
-    kind: "awaiting_input",
-    scope: "run",
-    runId: run.id,
-    workflowName: run.name,
-    status: run.status,
-    ...promptFields(prompt),
-    createdAt: prompt.createdAt,
-  };
-}
-
 function warnLifecycleSendFailure(error: unknown): void {
   if (process.env.ATOMIC_WORKFLOW_DEBUG !== "1") return;
   const message = error instanceof Error ? error.message : String(error);
@@ -327,18 +324,8 @@ function terminalRunKey(kind: "completed" | "failed", runId: string): string {
   return `${kind}:${runId}`;
 }
 
-function promptFields(
-  prompt: PendingPrompt,
-): Pick<WorkflowLifecycleNoticeDetails, "promptId" | "promptKind" | "promptMessage"> {
-  return {
-    promptId: prompt.id,
-    promptKind: prompt.kind,
-    promptMessage: truncateSnippet(prompt.message),
-  };
-}
-
 function awaitingInputKey(runId: string, stage: StageSnapshot): string {
-  const promptId = stage.pendingPrompt?.id;
+  const promptId = stage.pendingPrompt?.id ?? stage.inputRequest?.id;
   if (promptId) return `awaiting_input:${runId}:stage:${stage.id}:${promptId}`;
   return `awaiting_input:${runId}:stage:${stage.id}:${stage.awaitingInputSince ?? "active"}`;
 }
@@ -353,20 +340,70 @@ function truncateSnippet(value: string): string {
   return `${normalized.slice(0, LIFECYCLE_NOTICE_SNIPPET_LIMIT - 1)}…`;
 }
 
-function makeNoticeComponent(details: WorkflowLifecycleNoticeDetails): PiMessageRenderComponent {
+function makeNoticeComponent(
+  details: WorkflowLifecycleNoticeDetails,
+  theme: GraphTheme | undefined,
+): PiMessageRenderComponent {
   const text = formatWorkflowLifecycleNoticeText(details);
   return {
     render(width: number): string[] {
-      // Wrap to the render width so a long run id / workflow name never emits a
-      // line wider than the terminal. pi-tui hard-throws ("Rendered line N
-      // exceeds terminal width") on any over-wide rendered line, which would
-      // crash the whole TUI on narrow terminals or after a resize (#1109).
-      // `wrapPlainText` hard-breaks long unbreakable tokens (e.g. UUIDs), so
-      // every returned line is guaranteed to fit within `width`.
-      return wrapPlainText(text, width);
+      // Width < 32 cannot carry rounded card chrome without exceeding the
+      // terminal, so the card helper falls back to wrapped plain text there.
+      return renderLifecycleNoticeCard(details, { width, theme, fallbackText: text });
     },
     invalidate() {
       /* stored lifecycle notices are immutable */
     },
   };
 }
+
+function renderLifecycleNoticeCard(
+  details: WorkflowLifecycleNoticeDetails,
+  opts: { width: number; theme?: GraphTheme; fallbackText: string },
+): string[] {
+  const tone: WorkflowNoticeTone = details.kind === "failed" ? "error" : details.kind === "awaiting_input" ? "warning" : "success";
+  const title = details.kind === "failed"
+    ? "WORKFLOW FAILED"
+    : details.kind === "awaiting_input"
+      ? "WORKFLOW INPUT"
+      : "WORKFLOW COMPLETE";
+  const glyph = details.kind === "failed" ? "✗" : details.kind === "awaiting_input" ? "？" : "✓";
+  const stage = details.stageName ?? details.failedStageId ?? details.stageId;
+  const headline = details.kind === "failed"
+    ? `Workflow "${details.workflowName}" failed`
+    : details.kind === "awaiting_input"
+      ? `Workflow "${details.workflowName}" needs input`
+      : `Workflow "${details.workflowName}" completed`;
+  return renderWorkflowNoticeCard({
+    title,
+    glyph,
+    headline,
+    tone,
+    fields: [
+      { label: "workflow", value: details.workflowName },
+      { label: "run", value: details.runId },
+      { label: "stage", value: stage },
+      { label: "prompt", value: details.promptMessage, tone: "muted" },
+      { label: "error", value: details.error, tone: "error" },
+      { label: "duration", value: formatDurationMs(details.durationMs), tone: "muted" },
+    ],
+    hints: [details.kind === "awaiting_input" ? `/workflow connect ${details.runId}` : `/workflow status ${details.runId}`],
+    fallbackText: opts.fallbackText,
+    width: opts.width,
+    ...(opts.theme ? { theme: opts.theme } : {}),
+  });
+}
+
+function formatDurationMs(durationMs: number | undefined): string | undefined {
+  if (durationMs === undefined) return undefined;
+  if (durationMs < 1000) return `${durationMs}ms`;
+  const seconds = durationMs / 1000;
+  if (seconds < 60) return `${seconds.toFixed(seconds < 10 ? 1 : 0)}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainder = Math.round(seconds % 60);
+  return `${minutes}m ${remainder}s`;
+}
+
+function themeFromRenderer(piTheme: unknown): GraphTheme | undefined {
+  return piTheme === undefined ? undefined : deriveGraphThemeFromPiTheme(piTheme);
+}

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

@@ -4,11 +4,12 @@
  */
 
 import { truncateToWidth } from "../tui/text-helpers.js";
+import type { WorkflowInputValues } from "../shared/types.js";
 
 /** Renderer-only subset of the canonical WorkflowToolArgs from index.ts. */
 export interface WorkflowToolArgs {
   workflow?: string;
-  inputs?: Record<string, unknown>;
+  inputs?: WorkflowInputValues;
   action?:
     | "run"
     | "list"

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

@@ -20,6 +20,7 @@ import { renderRunDetail } from "../tui/run-detail.js";
 import { renderWorkflowList } from "../tui/workflow-list.js";
 import { deriveGraphTheme } from "../tui/graph-theme.js";
 import { renderDispatchConfirm } from "../tui/dispatch-confirm.js";
+import type { WorkflowInputValues, WorkflowOutputValues } from "../shared/types.js";
 import { renderRoundedBox } from "../tui/chat-surface.js";
 import { truncateToWidth } from "../tui/text-helpers.js";
 
@@ -87,7 +88,7 @@ type RunResult = {
   name?: string;
   runId: string;
   status: string;
-  result?: Record<string, unknown>;
+  result?: WorkflowOutputValues;
   details?: WorkflowDetails;
   error?: string;
   stages?: StageSnapshot[];
@@ -104,13 +105,15 @@ type StageListItem = {
   status: StageStatus;
   sessionId?: string;
   sessionFile?: string;
+  transcriptPath?: string;
   error?: string;
   awaitingInputSince?: number;
   pendingPrompt?: PendingPrompt;
   inputRequest?: StageInputRequest;
 };
 type StageListResult = { action: "stages"; runId: string; filter: string; stages: StageListItem[]; error?: string };
-type StageDetailResult = { action: "stage"; runId: string; stage?: StageSnapshot; error?: string };
+type StageDetailItem = StageSnapshot & { transcriptPath?: string };
+type StageDetailResult = { action: "stage"; runId: string; stage?: StageDetailItem; error?: string };
 type TranscriptEntry = { role: string; text?: string; toolName?: string; output?: string; timestamp?: number };
 type TranscriptResult = {
   action: "transcript";
@@ -119,8 +122,11 @@ type TranscriptResult = {
   source: "live" | "snapshot" | "error";
   entries: TranscriptEntry[];
   truncated: boolean;
+  entryCount?: number;
+  entryLimit?: number;
   sessionId?: string;
   sessionFile?: string;
+  transcriptPath?: string;
 };
 type SendResult = { action: "send"; runId: string; stageId: string; delivery: string; status: "ok" | "noop"; message: string };
 type PauseResult = { action: "pause"; runId: string; status: string; message: string };
@@ -156,7 +162,7 @@ export interface RenderResultOpts {
   width?: number;
   /** Original workflow inputs from the tool call, used to render the same
    * dispatch confirmation card as `/workflow <name> ...` for background runs. */
-  runInputs?: Readonly<Record<string, unknown>>;
+  runInputs?: Readonly<WorkflowInputValues>;
   /**
    * Suppress ANSI colour output (CLI flag paths / non-TTY consumers).
    * When false/undefined the canonical Catppuccin chrome is rendered.

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

@@ -8,6 +8,8 @@
  * cross-ref: spec §5.6 Persistence renderers (registration only)
  */
 
+import type { WorkflowInputValues, WorkflowOutputValues } from "../shared/types.js";
+
 // ---------------------------------------------------------------------------
 // Entry payload shapes (matches pi.appendEntry call signatures from §5.6)
 // ---------------------------------------------------------------------------
@@ -15,7 +17,7 @@
 export interface RunStartPayload {
   runId: string;
   name: string;
-  inputs?: Record<string, unknown>;
+  inputs?: WorkflowInputValues;
   ts?: number;
 }
 
@@ -46,7 +48,7 @@ export interface StageEndPayload {
 export interface RunEndPayload {
   runId: string;
   status: "ok" | "error" | "killed" | string;
-  result?: Record<string, unknown>;
+  result?: WorkflowOutputValues;
   ts?: number;
 }
 
@@ -82,6 +84,6 @@ export function renderStageResult(payload: StageEndPayload): string {
 
 /** Render workflow.run.end entry. */
 export function renderRunSummary(payload: RunEndPayload): string {
-  const icon = payload.status === "ok" ? "✅" : "❌";
+  const icon = payload.status === "ok" ? "✓" : "✗";
   return `${icon} workflow [${payload.runId}] ${payload.status}`;
 }

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

@@ -12,19 +12,21 @@
 
 import { createRegistry } from "../workflows/registry.js";
 import type { WorkflowRegistry } from "../workflows/registry.js";
-import type {
-  WorkflowDefinition,
-  WorkflowPersistencePort,
-  WorkflowMcpPort,
-  WorkflowRuntimeConfig,
-  WorkflowDetails,
-  WorkflowDirectOptions,
-  WorkflowDirectTaskItem,
-  WorkflowChainStep,
-  WorkflowModelCatalogPort,
+import {
+  INTERACTIVE_WORKFLOW_POLICY,
+  type WorkflowDefinition,
+  type WorkflowPersistencePort,
+  type WorkflowMcpPort,
+  type WorkflowRuntimeConfig,
+  type WorkflowDetails,
+  type WorkflowDirectOptions,
+  type WorkflowDirectTaskItem,
+  type WorkflowChainStep,
+  type WorkflowModelCatalogPort,
+  type WorkflowExecutionPolicy,
 } from "../shared/types.js";
 import type { StageAdapters } from "../runs/foreground/stage-runner.js";
-import { resolveInputs, runChain, runParallel, runTask, type RunOpts } from "../runs/foreground/executor.js";
+import { resolveAndValidateInputs, runChain, runParallel, runTask, type RunOpts } from "../runs/foreground/executor.js";
 import type { Store } from "../shared/store.js";
 import type { RunSnapshot } from "../shared/store-types.js";
 import type { CancellationRegistry } from "../runs/background/cancellation-registry.js";
@@ -41,6 +43,7 @@ import {
 } from "../intercom/result-intercom.js";
 import { validateWorkflowModels } from "../runs/shared/model-fallback.js";
 import { runDetached } from "../runs/background/runner.js";
+import type { JobTracker } from "../runs/background/job-tracker.js";
 import { classifyWorkflowFailure } from "../shared/workflow-failures.js";
 
 // ---------------------------------------------------------------------------
@@ -78,6 +81,10 @@ export interface ExtensionRuntimeOpts {
   config?: WorkflowRuntimeConfig;
   /** Optional model catalog forwarded to workflow runs for fallback resolution. */
   models?: WorkflowModelCatalogPort;
+  /** Job tracker forwarded to named detached runs. */
+  jobs?: JobTracker;
+  /** Invocation cwd used for workflow execution. Defaults to process.cwd(). */
+  cwd?: string;
 }
 
 // ---------------------------------------------------------------------------
@@ -99,13 +106,17 @@ export interface ExtensionRuntime {
    * Dispatch a `list`, `inputs`, or `run` action.
    * For `status`, `kill`, and `resume` use the runs/background/status module directly.
    */
-  dispatch(args: WorkflowToolArgs): Promise<WorkflowToolResult>;
+  dispatch(args: WorkflowToolArgs, options?: RuntimeDispatchOptions): Promise<WorkflowToolResult>;
 
   /** Execute direct single/parallel/chain workflow tool modes. */
-  runDirect(args: WorkflowToolArgs): Promise<WorkflowDetails>;
+  runDirect(args: WorkflowToolArgs, options?: RuntimeDispatchOptions): Promise<WorkflowDetails>;
 
   /** Start a linked continuation for a failed resumable named workflow run. */
-  resumeFailedRun(sourceRunId: string, stageId?: string): ResumeFailedRunResult;
+  resumeFailedRun(sourceRunId: string, stageId?: string, options?: RuntimeDispatchOptions): ResumeFailedRunResult;
+}
+
+export interface RuntimeDispatchOptions {
+  readonly policy?: WorkflowExecutionPolicy;
 }
 
 // ---------------------------------------------------------------------------
@@ -135,8 +146,10 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
   const config = opts.config;
   const intercom = opts.intercom;
   const models = opts.models;
+  const jobs = opts.jobs;
+  const runtimeCwd = opts.cwd ?? process.cwd();
 
-  function runOptions(args: WorkflowToolArgs): RunOpts {
+  function runOptions(args: WorkflowToolArgs, policy?: WorkflowExecutionPolicy): RunOpts {
     const argConcurrency =
       typeof args.concurrency === "number" && Number.isFinite(args.concurrency)
         ? Math.max(1, Math.floor(args.concurrency))
@@ -160,6 +173,9 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
       mcp,
       config: effectiveConfig,
       models,
+      ...(policy !== undefined ? { executionMode: policy.mode } : {}),
+      registry,
+      cwd: runtimeCwd,
     };
   }
 
@@ -309,19 +325,25 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
     });
   }
 
-  function runDirectForeground(args: WorkflowToolArgs, runId?: string): Promise<WorkflowDetails> {
-    const baseRunOptions = runOptions(args);
+  function runDirectForeground(
+    args: WorkflowToolArgs,
+    runId?: string,
+    policy?: WorkflowExecutionPolicy,
+  ): Promise<WorkflowDetails> {
+    const directRunOptions = directOptions(args);
+    const baseRunOptions = runOptions(args, policy);
     const effectiveRunOptions = runId === undefined
       ? baseRunOptions
       : { ...baseRunOptions, runId };
+
     if (Array.isArray(args.chain)) {
-      return runChain(args.chain, directOptions(args), effectiveRunOptions);
+      return runChain(args.chain, directRunOptions, effectiveRunOptions);
     }
     if (Array.isArray(args.tasks)) {
-      return runParallel(args.tasks, directOptions(args), effectiveRunOptions);
+      return runParallel(args.tasks, directRunOptions, effectiveRunOptions);
     }
     if (args.task !== undefined && typeof args.task === "object") {
-      return runTask(args.task, directOptions(args), effectiveRunOptions);
+      return runTask(args.task, directRunOptions, effectiveRunOptions);
     }
     throw new Error("WorkflowRuntime.runDirect: no direct execution mode supplied");
   }
@@ -367,7 +389,7 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
     return { ok: true, stageId: failedStageId };
   }
 
-  function resumeFailedRun(sourceRunId: string, stageId?: string): ResumeFailedRunResult {
+  function resumeFailedRun(sourceRunId: string, stageId?: string, options?: RuntimeDispatchOptions): ResumeFailedRunResult {
     const source = activeStore.runs().find((run) => run.id === sourceRunId);
     if (source === undefined) {
       return { ok: false, reason: "run_not_found", message: `run not found: ${sourceRunId}` };
@@ -385,12 +407,12 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
     }
     const sourceInputs = { ...source.inputs };
     try {
-      resolveInputs(def.inputs, sourceInputs);
+      resolveAndValidateInputs(def.inputs, sourceInputs, `workflow "${def.name}"`);
     } catch (err) {
       return { ok: false, reason: "insufficient_state", message: `insufficient_state: ${err instanceof Error ? err.message : String(err)}` };
     }
     const accepted = runDetached(def, sourceInputs, {
-      ...runOptions({ workflow: def.name, inputs: sourceInputs }),
+      ...runOptions({ workflow: def.name, inputs: sourceInputs }, options?.policy),
       continuation: { source, resumeFromStageId: resolvedStage.stageId },
     });
     return {
@@ -402,7 +424,7 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
     };
   }
 
-  async function runDirectAsync(args: WorkflowToolArgs): Promise<WorkflowDetails> {
+  async function runDirectAsync(args: WorkflowToolArgs, policy?: WorkflowExecutionPolicy): Promise<WorkflowDetails> {
     const runId = crypto.randomUUID();
     const mode = directMode(args);
     const delivery = effectiveIntercomDelivery(args, mode);
@@ -411,7 +433,7 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
     try {
       warnings = await validateWorkflowModels({
         requests: directModelRequests(args),
-        catalog: runOptions(args).models,
+        catalog: models,
       });
     } catch (error: unknown) {
       return withIntercomSummary({
@@ -423,10 +445,10 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
         error: classifyWorkflowFailure(error).userMessage,
       }, delivery, parentSession);
     }
-    const background = runDirectForeground(args, runId);
+    const background = runDirectForeground(args, runId, policy);
     void background.then(
       (details) => {
-        emitDirectIntercom(withIntercomSummary(details, delivery, parentSession), delivery, parentSession);
+        emitDirectIntercom(details, delivery, parentSession);
       },
       (error: unknown) => {
         const details: WorkflowDetails = withIntercomSummary({
@@ -455,18 +477,31 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
       return registry;
     },
 
-    dispatch(args: WorkflowToolArgs): Promise<WorkflowToolResult> {
-      return dispatch(args, { registry, adapters, store: activeStore, cancellation, persistence, mcp, config, models });
+    dispatch(args: WorkflowToolArgs, options?: RuntimeDispatchOptions): Promise<WorkflowToolResult> {
+      return dispatch(args, {
+        registry,
+        adapters,
+        store: activeStore,
+        cancellation,
+        jobs,
+        persistence,
+        mcp,
+        config,
+        models,
+        policy: options?.policy,
+        cwd: runtimeCwd,
+      });
     },
 
-    runDirect(args: WorkflowToolArgs): Promise<WorkflowDetails> {
-      if (args.async === true) {
-        return runDirectAsync(args);
+    runDirect(args: WorkflowToolArgs, options?: RuntimeDispatchOptions): Promise<WorkflowDetails> {
+      const policy = options?.policy ?? INTERACTIVE_WORKFLOW_POLICY;
+      if (args.async === true && policy.awaitTerminalRun !== true) {
+        return runDirectAsync(args, policy);
       }
       const mode = directMode(args);
       const delivery = effectiveIntercomDelivery(args, mode);
       const parentSession = intercomParentSession(args);
-      return runDirectForeground(args).then((details) => {
+      return runDirectForeground(args, undefined, policy).then((details) => {
         const summarized = withIntercomSummary(details, delivery, parentSession);
         emitDirectIntercom(summarized, delivery, parentSession);
         return summarized;

package/dist/builtin/workflows/src/extension/status-writer.ts

@@ -129,7 +129,7 @@ export function createStatusWriter(
     store.recordNotice({
       id: `status-writer-error-${Date.now()}`,
       level: "warning",
-      message: `pi-workflows: status file write failed (${filePath}): ${msg}`,
+      message: `atomic-workflows: status file write failed (${filePath}): ${msg}`,
       createdAt: Date.now(),
     });
   }