@bastani/atomic 0.9.9 → 0.9.10

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

@@ -1,23 +1,20 @@
 import {
   interruptAllRuns,
   interruptRun,
-  killAllRuns,
-  killRun,
   pauseAllRuns,
   pauseRun,
   resumeRun,
 } from "../runs/background/status.js";
-import { cancellationRegistry } from "../runs/background/cancellation-registry.js";
+import { quitAllRuns, quitRun } from "../runs/background/quit.js";
 import { store } from "../shared/store.js";
 import { getDurableBackend } from "../durable/factory.js";
-import type { WorkflowExecutionPolicy, WorkflowPersistencePort } from "../shared/types.js";
+import type { WorkflowExecutionPolicy } from "../shared/types.js";
 import type { ExtensionRuntime } from "./runtime.js";
 import type { WorkflowToolResult } from "./render-result.js";
 import type { WorkflowToolArgs } from "./public-types.js";
 import {
   allStageConflictMessage,
   ambiguousRunMessage,
-  formatAlreadyEndedRetainedMessage,
   reloadFailureMessage,
   resolveToolRunTarget,
   resolveToolStageTarget,
@@ -25,45 +22,75 @@ import {
 } from "./workflow-targets.js";
 import { formatWorkflowReloadReport, formatWorkflowResourceLoadWarning } from "./workflow-command-surfaces.js";
 import { normalizeWorkflowReloadReport, type WorkflowReloadReport } from "./workflow-reload-report.js";
+import { classifyDurableResumeShadow } from "./workflow-resume-shadow.js";
+import {
+  workflowHasPausedStages,
+  workflowHasPausedState,
+} from "../runs/background/workflow-lifecycle-aggregate.js";
 
 export interface WorkflowControlActionDeps {
-  getPersistence: () => WorkflowPersistencePort | undefined;
   reloadWorkflowResources: () => Promise<WorkflowReloadReport | void> | void;
   getRuntime: () => ExtensionRuntime;
   policy: WorkflowExecutionPolicy;
   ensureWorkflowResourcesLoaded: () => Promise<void> | void;
 }
 
-export function workflowPauseAction(args: WorkflowToolArgs): WorkflowToolResult {
+function controlFailure(action: "pause" | "interrupt" | "quit" | "resume", runId: string, error: unknown): WorkflowToolResult {
+  return {
+    action,
+    runId,
+    status: "noop",
+    message: `Failed to ${action} run ${runId}: ${error instanceof Error ? error.message : String(error)}`,
+  };
+}
+
+function resumeControlFailure(runId: string, error: unknown): WorkflowToolResult {
+  const run = store.runs().find((candidate) => candidate.id === runId);
+  const visiblyRunning = run?.status === "running" || run?.stages.some(
+    (stage) => stage.status === "running" || stage.status === "pending" || stage.status === "awaiting_input",
+  ) === true;
+  const detail = error instanceof Error ? error.message : String(error);
+  return {
+    action: "resume",
+    runId,
+    status: visiblyRunning ? "partial" : "noop",
+    message: `Failed to resume run ${runId}: ${detail}`,
+  };
+}
+
+export async function workflowPauseAction(args: WorkflowToolArgs): Promise<WorkflowToolResult> {
   const target = resolveToolRunTarget(args, "No in-flight runs to pause.");
   const action = "pause";
   if (target.kind === "all") {
     if (args.stageId !== undefined && args.stageId.length > 0) {
       return { action, runId: "--all", status: "noop", message: allStageConflictMessage("pause") };
     }
-    const results = pauseAllRuns();
-    const paused = results.filter((r) => r.ok).length;
-    return {
-      action,
-      runId: "--all",
-      status: paused > 0 ? "paused" : "noop",
-      message: paused > 0 ? `Paused ${paused} run(s).` : "No in-flight runs to pause.",
-    };
+    try {
+      const results = await pauseAllRuns();
+      const paused = results.filter((result) => result.ok).length;
+      return {
+        action,
+        runId: "--all",
+        status: paused > 0 ? "paused" : "noop",
+        message: paused > 0 ? `Paused ${paused} run(s).` : "No in-flight runs to pause.",
+      };
+    } catch (error) {
+      return controlFailure(action, "--all", error);
+    }
   }
   if (target.kind === "ambiguous") return { action, runId: target.target, status: "noop", message: ambiguousRunMessage(target.target, target.matches) };
   if (target.kind === "not_found") return { action, runId: target.target, status: "noop", message: target.message };
   const stage = resolveToolStageTarget(target.runId, args.stageId);
   if (!stage.ok) return { action, runId: target.runId, status: "noop", message: stage.message };
   const stageRunId = stage.runId ?? target.runId;
-  const result = pauseRun(stageRunId, { stageId: stage.stageId });
-  return result.ok
-    ? { action, runId: result.runId, status: "paused", message: `Paused ${result.paused.length} stage(s) on run ${result.runId.slice(0, 8)}.` }
-    : {
-        action,
-        runId: stageRunId,
-        status: "noop",
-        message: stageFailureMessage(stageRunId, result.reason, "pause"),
-      };
+  try {
+    const result = await pauseRun(stageRunId, { stageId: stage.stageId });
+    return result.ok
+      ? { action, runId: result.runId, status: "paused", message: `Paused ${result.paused.length} stage(s) on run ${result.runId.slice(0, 8)}.` }
+      : { action, runId: stageRunId, status: "noop", message: stageFailureMessage(stageRunId, result.reason, "pause") };
+  } catch (error) {
+    return controlFailure(action, stageRunId, error);
+  }
 }
 
 export async function workflowReloadAction(
@@ -93,83 +120,133 @@ export async function workflowReloadAction(
   }
 }
 
-export function workflowKillAction(
-  args: WorkflowToolArgs,
-  deps: Pick<WorkflowControlActionDeps, "getPersistence">,
-): WorkflowToolResult {
-  const target = resolveToolRunTarget(args, "No in-flight runs to kill.");
-  const action = "kill";
+function bulkQuitFailureMessage(
+  results: Awaited<ReturnType<typeof quitAllRuns>>,
+): string {
+  const successes = results.filter((result) => result.ok).length;
+  const failures = results.length - successes;
+  const outcomes = results.map((result) => result.ok
+    ? `${result.runId}: quit`
+    : `${result.runId}: ${result.reason}${"message" in result ? ` (${result.message})` : ""}`
+  ).join(", ");
+  return `${successes > 0 ? `Quit ${successes} run(s); ` : ""}failed to quit ${failures} run(s); outcomes: ${outcomes}.`;
+}
+
+export async function workflowQuitAction(args: WorkflowToolArgs): Promise<WorkflowToolResult> {
+  const target = resolveToolRunTarget(args, "No in-flight runs to quit.");
+  const action = "quit";
   if (target.kind === "all") {
     if (args.stageId !== undefined && args.stageId.length > 0) {
-      return { action, runId: "--all", status: "noop", message: allStageConflictMessage("kill") };
+      return { action, runId: "--all", status: "noop", message: allStageConflictMessage("quit") };
     }
-    const results = killAllRuns({ cancellation: cancellationRegistry, persistence: deps.getPersistence() });
-    const killed = results.filter((r) => r.ok).length;
+    const results = await quitAllRuns();
+    const successes = results.filter((result) => result.ok);
+    const quitCount = successes.length;
+    const failures = results.filter((result) => !result.ok);
     return {
       action,
       runId: "--all",
-      status: killed > 0 ? "killed" : "noop",
-      message: killed > 0 ? `Killed and retained ${killed} run(s) for inspection.` : "No in-flight runs to kill.",
+      status: failures.length > 0 ? (quitCount > 0 ? "partial" : "noop") : quitCount > 0 ? "paused" : "noop",
+      message: failures.length > 0
+        ? bulkQuitFailureMessage(results)
+        : quitCount > 0
+          ? `Quit ${quitCount} run(s); resume with /workflow resume.`
+          : "No in-flight runs to quit.",
     };
   }
-  if (target.kind === "ambiguous") return { action, runId: target.target, status: "noop", message: ambiguousRunMessage(target.target, target.matches) };
+  if (target.kind === "ambiguous") {
+    return { action, runId: target.target, status: "noop", message: ambiguousRunMessage(target.target, target.matches) };
+  }
   if (target.kind === "not_found") return { action, runId: target.target, status: "noop", message: target.message };
-  const result = killRun(target.runId, { cancellation: cancellationRegistry, persistence: deps.getPersistence() });
-  if (result.ok) {
+  try {
+    const result = await quitRun(target.runId);
+    if (result.ok) {
+      return {
+        action,
+        runId: result.runId,
+        status: "paused",
+        message: `Run ${result.runId} quit and can be resumed with /workflow resume.`,
+      };
+    }
     return {
       action,
-      runId: result.runId,
-      status: "killed",
-      message: `Run ${result.runId} killed and retained for inspection (was ${result.previousStatus}).`,
+      runId: target.runId,
+      status: "noop",
+      message: result.reason === "already_ended"
+        ? `Run ${target.runId.slice(0, 8)} already ended.`
+        : result.reason === "no_active_stages"
+          ? `No controllable stages on run ${target.runId.slice(0, 8)}; the run remains active.`
+          : `Run not found: ${target.runId}`,
     };
+  } catch (error) {
+    return controlFailure(action, target.runId, error);
   }
-  return {
-    action,
-    runId: target.runId,
-    status: "noop",
-    message: result.reason === "already_ended"
-      ? formatAlreadyEndedRetainedMessage(target.runId)
-      : `Run not found: ${target.runId}`,
-  };
 }
 
-export function workflowInterruptAction(args: WorkflowToolArgs): WorkflowToolResult {
+export async function workflowInterruptAction(args: WorkflowToolArgs): Promise<WorkflowToolResult> {
   const target = resolveToolRunTarget(args, "No in-flight runs to interrupt.");
   const action = "interrupt";
   if (target.kind === "all") {
     if (args.stageId !== undefined && args.stageId.length > 0) {
       return { action, runId: "--all", status: "noop", message: allStageConflictMessage("interrupt") };
     }
-    const results = interruptAllRuns();
-    const interrupted = results.filter((r) => r.ok).length;
-    return {
-      action,
-      runId: "--all",
-      status: interrupted > 0 ? "paused" : "noop",
-      message: interrupted > 0 ? `Interrupted ${interrupted} run(s).` : "No in-flight runs to interrupt.",
-    };
+    try {
+      const results = await interruptAllRuns();
+      const interrupted = results.filter((result) => result.ok).length;
+      return {
+        action,
+        runId: "--all",
+        status: interrupted > 0 ? "paused" : "noop",
+        message: interrupted > 0 ? `Interrupted ${interrupted} run(s).` : "No in-flight runs to interrupt.",
+      };
+    } catch (error) {
+      return controlFailure(action, "--all", error);
+    }
   }
   if (target.kind === "ambiguous") return { action, runId: target.target, status: "noop", message: ambiguousRunMessage(target.target, target.matches) };
   if (target.kind === "not_found") return { action, runId: target.target, status: "noop", message: target.message };
   const stage = resolveToolStageTarget(target.runId, args.stageId);
   if (!stage.ok) return { action, runId: target.runId, status: "noop", message: stage.message };
   const stageRunId = stage.runId ?? target.runId;
-  const result = interruptRun(stageRunId, { stageId: stage.stageId });
-  if (result.ok) {
-    return {
-      action,
-      runId: result.runId,
-      status: "paused",
-      message: stage.stageId
-        ? `Stage ${stage.stageId} interrupted on run ${result.runId} and can be resumed.`
-        : `Run ${result.runId} interrupted and can be resumed.`,
-    };
+  try {
+    const result = await interruptRun(stageRunId, { stageId: stage.stageId });
+    if (result.ok) {
+      return {
+        action,
+        runId: result.runId,
+        status: "paused",
+        message: stage.stageId
+          ? `Stage ${stage.stageId} interrupted on run ${result.runId} and can be resumed.`
+          : `Run ${result.runId} interrupted and can be resumed.`,
+      };
+    }
+    return { action, runId: stageRunId, status: "noop", message: stageFailureMessage(stageRunId, result.reason, "interrupt") };
+  } catch (error) {
+    return controlFailure(action, stageRunId, error);
   }
+}
+
+async function resumeDurableShadow(
+  runId: string,
+  deps: Pick<WorkflowControlActionDeps, "getRuntime" | "policy" | "ensureWorkflowResourcesLoaded">,
+): Promise<WorkflowToolResult> {
+  const runtime = deps.getRuntime();
+  let warning: string | undefined;
+  try {
+    await deps.ensureWorkflowResourcesLoaded();
+    // Targeted read: the shadow run id is exact, so avoid a full catalog scan.
+    if (runtime.prepareDurableResumableForIds !== undefined) await runtime.prepareDurableResumableForIds([runId]);
+    else await runtime.prepareDurableResumable(runId);
+  } catch (error) {
+    warning = formatWorkflowResourceLoadWarning(error);
+  }
+  const resumed = await runtime.resumeDurableWorkflow(runId, { policy: deps.policy });
+  const message = warning === undefined ? resumed.message : `${warning}\n\n${resumed.message}`;
   return {
-    action,
-    runId: stageRunId,
-    status: "noop",
-    message: stageFailureMessage(stageRunId, result.reason, "interrupt"),
+    action: "resume",
+    runId: resumed.ok ? resumed.runId : runId,
+    status: resumed.ok ? "running" : "noop",
+    message,
   };
 }
 
@@ -182,13 +259,25 @@ export async function workflowResumeAction(
   if (target.kind === "ambiguous") return { action: "resume", runId: target.target, status: "noop", message: ambiguousRunMessage(target.target, target.matches) };
   if (target.kind === "not_found") return { action: "resume", runId: target.target, status: "noop", message: target.message };
   const backend = getDurableBackend();
+  const exact = store.runs().find((run) => run.id === target.runId);
+  const shadow = exact === undefined ? "not_shadow" : classifyDurableResumeShadow(exact, store, { backend });
+  if (shadow === "eligible") return resumeDurableShadow(target.runId, deps);
+  if (shadow === "ineligible") {
+    return {
+      action: "resume",
+      runId: target.runId,
+      status: "noop",
+      message: "Workflow " + target.runId + " has no durable checkpoint or pending prompt progress and is not resumable.",
+    };
+  }
   if (!backend.isWorkflowLoadable(target.runId)) {
     try {
       await deps.ensureWorkflowResourcesLoaded();
-      await deps.getRuntime().prepareDurableResumable(target.runId);
+      const runtime = deps.getRuntime();
+      if (runtime.prepareDurableResumableForIds !== undefined) await runtime.prepareDurableResumableForIds([target.runId]);
+      else await runtime.prepareDurableResumable(target.runId);
     } catch {
-      // Durable compatibility preparation failures fall through to the
-      // authoritative loadability check below; workflow resume remains best-effort.
+      // Compatibility preparation remains best-effort before the authoritative check.
     }
     if (!backend.isWorkflowLoadable(target.runId)) {
       store.removeRun(target.runId);
@@ -199,10 +288,10 @@ export async function workflowResumeAction(
   const stage = resolveToolStageTarget(target.runId, args.stageId);
   if (!stage.ok) return { action: "resume", runId: target.runId, status: "noop", message: stage.message };
   const stageRunId = stage.runId ?? target.runId;
-  const run = store.runs().find((r) => r.id === stageRunId);
+  const run = store.runs().find((candidate) => candidate.id === stageRunId);
   const hadPausedRunState = run?.status === "paused";
-  const hadPausedStageState = run?.stages.some((s) => s.status === "paused") ?? false;
-  const isPaused = hadPausedRunState || hadPausedStageState;
+  const hadPausedStageState = run !== undefined && workflowHasPausedStages(store, stageRunId);
+  const isPaused = run !== undefined && workflowHasPausedState(store, stageRunId);
   const isResumableContinuation = run !== undefined && !isPaused && (
     (run.status === "failed" && run.endedAt !== undefined && run.resumable !== false) ||
     (run.endedAt === undefined && run.resumable === true && run.failureRecoverability === "recoverable")
@@ -213,7 +302,7 @@ export async function workflowResumeAction(
     } catch (error) {
       warning = formatWorkflowResourceLoadWarning(error);
     }
-    const continuation = deps.getRuntime().resumeFailedRun(stageRunId, stage.stageId, { policy: deps.policy });
+    const continuation = await deps.getRuntime().resumeFailedRun(stageRunId, stage.stageId, { policy: deps.policy });
     const message = warning === undefined ? continuation.message : `${warning}\n\n${continuation.message}`;
     return {
       action: "resume",
@@ -222,15 +311,22 @@ export async function workflowResumeAction(
       message,
     };
   }
-  const result = resumeRun(stageRunId, { stageId: stage.stageId, message: args.message });
-  if (result.ok) {
-    const runLevelResumed = hadPausedRunState && !hadPausedStageState && stage.stageId === undefined && result.snapshot.status === "running";
-    const message = result.message ?? (isPaused
-      ? result.resumed.length === 0
-        ? runLevelResumed ? `Resumed run ${result.runId.slice(0, 8)}.` : `No paused stages on run ${result.runId.slice(0, 8)}.`
-        : `Resumed ${result.resumed.length} stage(s) on run ${result.runId.slice(0, 8)}${args.message ? ` with message: "${args.message}"` : ""}.`
-      : `Snapshot available: run ${result.runId} (${result.snapshot.name}) — status: ${result.snapshot.status}, stages: ${result.snapshot.stages.length}`);
-    return { action: "resume", runId: result.runId, status: "ok", message };
+  try {
+    const result = await resumeRun(stageRunId, { stageId: stage.stageId, message: args.message });
+    if (result.ok) {
+      const runLevelResumed = hadPausedRunState && !hadPausedStageState && stage.stageId === undefined && result.snapshot.status === "running";
+      const noPausedProgress = isPaused && result.resumed.length === 0
+        && result.message === undefined && !runLevelResumed;
+      const message = result.message ?? (isPaused
+        ? result.resumed.length === 0
+          ? runLevelResumed ? `Resumed run ${result.runId.slice(0, 8)}.` : `No paused stages on run ${result.runId.slice(0, 8)}.`
+          : `Resumed ${result.resumed.length} stage(s) on run ${result.runId.slice(0, 8)}${args.message ? ` with message: "${args.message}"` : ""}.`
+        : `Snapshot available: run ${result.runId} (${result.snapshot.name}) — status: ${result.snapshot.status}, stages: ${result.snapshot.stages.length}`);
+      const status = result.mode === "partial" ? "partial" : noPausedProgress ? "noop" : "ok";
+      return { action: "resume", runId: result.runId, status, message };
+    }
+    return { action: "resume", runId: stageRunId, status: "noop", message: `Run not found: ${stageRunId}` };
+  } catch (error) {
+    return resumeControlFailure(stageRunId, error);
   }
-  return { action: "resume", runId: stageRunId, status: "noop", message: `Run not found: ${stageRunId}` };
 }

package/dist/builtin/workflows/src/extension/workflow-tool-send.ts

@@ -1,4 +1,10 @@
 import { stageControlRegistry } from "../runs/foreground/stage-control-registry.js";
+import {
+  ensurePostMortemStageHandle,
+  type PostMortemStageChatDeps,
+} from "../runs/foreground/postmortem-stage-chat.js";
+import type { StageControlHandle } from "../runs/foreground/stage-control-registry.js";
+import type { StageUserMessageDeliveryAction } from "../runs/foreground/stage-runner-types.js";
 import { store } from "../shared/store.js";
 import { stageUiBroker } from "../shared/stage-ui-broker.js";
 import {
@@ -14,6 +20,14 @@ import {
   resolveToolStageTarget,
 } from "./workflow-targets.js";
 
+/**
+ * Optional dependencies enabling `workflow send` to revive an eligible terminal
+ * agent stage as a post-mortem chat when no process-local handle exists.
+ */
+export interface WorkflowSendDeps {
+  readonly resolvePostMortemDeps?: (runId: string) => PostMortemStageChatDeps;
+}
+
 function hasPayloadProperty(args: WorkflowToolArgs): boolean {
   return args.text !== undefined || args.response !== undefined || args.message !== undefined;
 }
@@ -52,7 +66,35 @@ function workflowSendResult(
   return { action: "send", runId, stageId, delivery, status, message };
 }
 
-export async function workflowSendAction(args: WorkflowToolArgs): Promise<WorkflowSendToolResult> {
+async function deliverStageUserMessage(
+  handle: StageControlHandle,
+  text: string,
+  deliverAs?: "steer" | "followUp",
+): Promise<StageUserMessageDeliveryAction> {
+  if (handle.sendUserMessage !== undefined) return handle.sendUserMessage(text, { deliverAs });
+  if (!handle.isStreaming) {
+    await handle.prompt(text);
+    return "prompt";
+  }
+  if (deliverAs === "steer") {
+    await handle.steer(text);
+    return "steer";
+  }
+  await handle.followUp(text);
+  return "followUp";
+}
+
+function deliveryMessage(delivery: StageUserMessageDeliveryAction): string {
+  if (delivery === "prompt") return "Prompt started for stage.";
+  if (delivery === "steer") return "Steered live stage.";
+  if (delivery === "followUp") return "Follow-up queued for stage.";
+  return "Message handled by stage extension.";
+}
+
+export async function workflowSendAction(
+  args: WorkflowToolArgs,
+  deps: WorkflowSendDeps = {},
+): Promise<WorkflowSendToolResult> {
   const target = resolveToolRunTarget(args, "No active run to message.");
   const requestedDelivery = args.delivery ?? "auto";
   if (target.kind === "all") {
@@ -143,22 +185,61 @@ export async function workflowSendAction(args: WorkflowToolArgs): Promise<Workfl
   if (text === undefined) {
     return workflowSendResult(stageRunId, stage.stageId, requestedDelivery, "noop", "Send requires text, response, or message.");
   }
-  const handle = stageControlRegistry.get(stageRunId, stage.stageId);
+  let handle: StageControlHandle | undefined = stageControlRegistry.get(stageRunId, stage.stageId);
+  if (handle === undefined && deps.resolvePostMortemDeps !== undefined && snapshot !== undefined) {
+    const revived = ensurePostMortemStageHandle(stageRunId, snapshot, deps.resolvePostMortemDeps(stageRunId));
+    if (revived.ok) handle = revived.handle;
+  }
   if (handle === undefined) {
     return workflowSendResult(stageRunId, stage.stageId, requestedDelivery, "noop", "No live handle for stage.");
   }
+  // A completed post-mortem handle is not live execution: its handle-level
+  // resume()/pause() reject by contract. Return a structured noop with guidance
+  // instead of letting that rejection cross the tool boundary. Failed handles
+  // remain eligible for their existing recoverable execution-resume semantics.
+  const isTerminalPostMortemStage = handle.status === "completed";
+  if (requestedDelivery === "resume" && handle.status !== "paused" && !isTerminalPostMortemStage) {
+    return workflowSendResult(stageRunId, stage.stageId, "resume", "noop", "Stage is not paused; no resume message was delivered.");
+  }
+  if (handle.status === "paused" && requestedDelivery !== "resume" && requestedDelivery !== "auto") {
+    return workflowSendResult(stageRunId, stage.stageId, requestedDelivery, "noop", "Stage is paused; resume it before sending a new message.");
+  }
   if (requestedDelivery === "resume" || (requestedDelivery === "auto" && handle.status === "paused")) {
-    await handle.resume(text);
-    return workflowSendResult(stageRunId, stage.stageId, "resume", "ok", "Resumed stage with message.");
+    if (isTerminalPostMortemStage) {
+      return workflowSendResult(stageRunId, stage.stageId, "resume", "noop", "Cannot resume a terminal post-mortem stage; use delivery \"followUp\" or \"prompt\" to continue its retained conversation.");
+    }
+    const resumedDelivery = await handle.resume(text);
+    if (resumedDelivery !== undefined && resumedDelivery !== "prompt") {
+      return workflowSendResult(stageRunId, stage.stageId, resumedDelivery, "ok", deliveryMessage(resumedDelivery));
+    }
+    if (resumedDelivery === "prompt") {
+      return workflowSendResult(stageRunId, stage.stageId, "prompt", "ok", "Resumed stage and started prompt.");
+    }
+    const hasResumeMessage = text.trim().length > 0;
+    return workflowSendResult(
+      stageRunId,
+      stage.stageId,
+      "resume",
+      "ok",
+      hasResumeMessage ? "Resumed interrupted stage with message." : "Resumed stage.",
+    );
   }
-  if (requestedDelivery === "steer" || (requestedDelivery === "auto" && handle.isStreaming)) {
-    await handle.steer(text);
-    return workflowSendResult(stageRunId, stage.stageId, "steer", "ok", "Steered live stage.");
+  if (requestedDelivery === "steer") {
+    if (isTerminalPostMortemStage) {
+      return workflowSendResult(stageRunId, stage.stageId, "steer", "noop", "Cannot steer a terminal post-mortem stage; use delivery \"followUp\" or \"prompt\" to continue its retained conversation.");
+    }
+    const delivery = await deliverStageUserMessage(handle, text, "steer");
+    return workflowSendResult(stageRunId, stage.stageId, delivery, "ok", deliveryMessage(delivery));
+  }
+  if (requestedDelivery === "auto" && handle.isStreaming && !isTerminalPostMortemStage) {
+    const delivery = await deliverStageUserMessage(handle, text, "steer");
+    return workflowSendResult(stageRunId, stage.stageId, delivery, "ok", deliveryMessage(delivery));
   }
   if (requestedDelivery === "prompt") {
-    await handle.prompt(text);
-    return workflowSendResult(stageRunId, stage.stageId, "prompt", "ok", "Prompt sent to stage.");
+    const delivery = await deliverStageUserMessage(handle, text);
+    const message = delivery === "prompt" ? "Prompt sent to stage." : deliveryMessage(delivery);
+    return workflowSendResult(stageRunId, stage.stageId, delivery, "ok", message);
   }
-  await handle.followUp(text);
-  return workflowSendResult(stageRunId, stage.stageId, "followUp", "ok", "Follow-up queued for stage.");
+  const delivery = await deliverStageUserMessage(handle, text, "followUp");
+  return workflowSendResult(stageRunId, stage.stageId, delivery, "ok", deliveryMessage(delivery));
 }

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

@@ -1,20 +1,13 @@
 import { inspectRun } from "../runs/background/status.js";
-import type { WorkflowExecutionPolicy, WorkflowPersistencePort } from "../shared/types.js";
+import type { WorkflowExecutionPolicy } from "../shared/types.js";
 import type { ExtensionRuntime } from "./runtime.js";
 import type { WorkflowToolResult } from "./render-result.js";
 import type { PiExecuteContext, WorkflowToolArgs } from "./public-types.js";
 import { workflowPolicyFromContext } from "./workflow-policy.js";
 import { workflowGetResult } from "./workflow-tool-content.js";
-import {
-  directModeCount,
-  hasDirectExecutionMode,
-  hasNamedExecutionMode,
-  withForkParentSession,
-  workflowRunResultFromDetails,
-} from "./workflow-tool-helpers.js";
 import {
   workflowInterruptAction,
-  workflowKillAction,
+  workflowQuitAction,
   workflowPauseAction,
   workflowReloadAction,
   workflowResumeAction,
@@ -24,7 +17,8 @@ import {
   workflowStagesResult,
   workflowTranscriptResult,
 } from "./workflow-tool-inspection.js";
-import { workflowSendAction } from "./workflow-tool-send.js";
+import { workflowSendAction, type WorkflowSendDeps } from "./workflow-tool-send.js";
+import { buildWorkflowStatusListing } from "./workflow-status-summary.js";
 import {
   ambiguousRunMessage,
   isWorkflowStageToolContext,
@@ -36,9 +30,9 @@ import type { WorkflowReloadReport } from "./workflow-reload-report.js";
 
 export function makeExecuteWorkflowTool(
   runtime: ExtensionRuntime | ((ctx: PiExecuteContext) => ExtensionRuntime),
-  getPersistence: () => WorkflowPersistencePort | undefined,
   reloadWorkflowResources: () => Promise<WorkflowReloadReport | void> | void,
   ensureWorkflowResourcesLoaded: () => Promise<void> | void = () => {},
+  sendDeps: WorkflowSendDeps = {},
 ): (args: WorkflowToolArgs, ctx: PiExecuteContext) => Promise<WorkflowToolResult> {
   return async function executeWorkflowTool(
     args: WorkflowToolArgs,
@@ -75,15 +69,6 @@ export function makeExecuteWorkflowTool(
         return getRuntime().dispatch(args, { policy });
       }
       case "run": {
-        if (hasDirectExecutionMode(args)) {
-          const activeRuntime = getRuntime();
-          const normalModeCount = directModeCount(args) + (hasNamedExecutionMode(args) ? 1 : 0);
-          if (normalModeCount !== 1) {
-            throw new Error("Workflow extension: specify exactly one normal execution mode: workflow, task, tasks, or chain");
-          }
-          const details = await activeRuntime.runDirect(withForkParentSession(args, ctx), { policy });
-          return workflowRunResultFromDetails(details);
-        }
         await ensureWorkflowResourcesVisible();
         return getRuntime().dispatch(args, { policy });
       }
@@ -106,7 +91,16 @@ export function makeExecuteWorkflowTool(
             ? { action: "statusDetail", runId: result.runId, detail: result.detail }
             : { action: "statusDetail", runId: target, error: `run not found: ${target}` };
         }
-        return { action: "status", snapshots: topLevelExpandedSnapshots() };
+        const listing = buildWorkflowStatusListing(
+          topLevelExpandedSnapshots(),
+          args.statusFilter ?? "all",
+        );
+        return {
+          action: "status",
+          filter: listing.filter,
+          runs: listing.runs,
+          snapshots: listing.snapshots,
+        };
       }
       case "stages":
         return workflowStagesResult(args);
@@ -115,13 +109,13 @@ export function makeExecuteWorkflowTool(
       case "transcript":
         return workflowTranscriptResult(args);
       case "send":
-        return workflowSendAction(args);
+        return workflowSendAction(args, sendDeps);
       case "pause":
         return workflowPauseAction(args);
       case "reload":
         return workflowReloadAction(args, { reloadWorkflowResources });
-      case "kill":
-        return workflowKillAction(args, { getPersistence });
+      case "quit":
+        return workflowQuitAction(args);
       case "interrupt":
         return workflowInterruptAction(args);
       case "resume":