@agentswf/engine 0.1.0-beta.2 → 0.1.0-beta.4

package/src/agent-cli/client.ts

@@ -0,0 +1,115 @@
+import { createConnection, type Socket } from "node:net";
+import {
+  type ControlRequest,
+  decodeResponseFor,
+  type ResponseFor,
+  type ResultSubmitRequest,
+  type ResultSubmitResponse,
+  type WaitingRequest,
+  type WaitingResponse,
+} from "@agentswf/contract/wire";
+
+const MAX_RESPONSE_BYTES = 256 * 1024;
+
+/** The connection never opened: nothing was written, so nothing reached the engine. */
+export class NotSentError extends Error {}
+
+export function submitResult(
+  endpoint: string,
+  request: ResultSubmitRequest,
+  timeoutSeconds = 30,
+  connect: (endpoint: string) => Socket = createConnection,
+): Promise<ResultSubmitResponse> {
+  return submitControl(endpoint, request, timeoutSeconds, connect);
+}
+
+export function submitWaiting(
+  endpoint: string,
+  request: WaitingRequest,
+  timeoutSeconds = 30,
+  connect: (endpoint: string) => Socket = createConnection,
+): Promise<WaitingResponse> {
+  return submitControl(endpoint, request, timeoutSeconds, connect);
+}
+
+/** Sends one request and resolves with a response that answers its command. */
+export function submitControl<R extends ControlRequest>(
+  endpoint: string,
+  request: R,
+  /** Null waits as long as the engine takes, as a tool call does: it answers once the call settles. */
+  timeoutSeconds: number | null = 30,
+  connect: (endpoint: string) => Socket = createConnection,
+): Promise<ResponseFor[R["command"]]> {
+  type Response = ResponseFor[R["command"]];
+  if (timeoutSeconds !== null && (!Number.isFinite(timeoutSeconds) || timeoutSeconds <= 0)) {
+    return Promise.reject(new Error("control-plane timeout must be positive"));
+  }
+  const outgoing = Buffer.from(`${JSON.stringify(request)}\n`);
+
+  return new Promise<Response>((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    let bytes = 0;
+    let settled = false;
+    let connected = false;
+    const socket = connect(endpoint);
+    const lifetime =
+      timeoutSeconds === null
+        ? undefined
+        : setTimeout(
+            () => fail(new Error("control plane response timed out")),
+            timeoutSeconds * 1000,
+          );
+
+    const fail = (error: Error): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(lifetime);
+      socket.destroy();
+      reject(error);
+    };
+
+    socket.once("connect", () => {
+      connected = true;
+      socket.end(outgoing);
+    });
+    socket.on("data", (data) => {
+      if (settled) return;
+      const chunk = typeof data === "string" ? Buffer.from(data) : data;
+      bytes += chunk.byteLength;
+      if (bytes > MAX_RESPONSE_BYTES) {
+        fail(new Error("control-plane response exceeds the size limit"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    socket.once("end", () => {
+      if (settled) return;
+      const frame = Buffer.concat(chunks).toString("utf8");
+      if (!frame.endsWith("\n") || frame.slice(0, -1).includes("\n")) {
+        fail(new Error("control plane returned an invalid response frame"));
+        return;
+      }
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(frame.slice(0, -1));
+      } catch {
+        fail(new Error("control plane returned invalid JSON"));
+        return;
+      }
+      const decoded = decodeResponseFor<R["command"]>(request.command, parsed);
+      if (!decoded.ok) {
+        fail(new Error(decoded.error));
+        return;
+      }
+      settled = true;
+      clearTimeout(lifetime);
+      resolve(decoded.value);
+    });
+    socket.once("error", (error) =>
+      fail(connected ? error : new NotSentError(error.message, { cause: error })),
+    );
+    socket.once("close", () => {
+      if (!settled) fail(new Error("control plane closed without a response"));
+    });
+  });
+}

package/src/agent-launcher.ts

@@ -1,9 +1,11 @@
-import { chmod, mkdir, readFile, realpath, writeFile } from "node:fs/promises";
-import { createRequire } from "node:module";
-import { basename, dirname, join, resolve } from "node:path";
+import { chmod, mkdir, realpath, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { type AgentDoor, shellQuote } from "@agentswf/sandbox";
 
-/** bun loads the `.env` of the directory it starts in: an agent's, which is none of `wf`'s. */
+const AGENT_CLI = fileURLToPath(new URL("./agent-cli/cli.ts", import.meta.url));
+
+/** bun loads the `.env` of the directory it starts in: an agent's, which is none of `wfa`'s. */
 const NO_ENV = "--no-env-file";
 
 /**
@@ -27,19 +29,18 @@ export async function installAgentLauncher(
    */
   sessionEnv?: string,
 ): Promise<string> {
-  const command = await resolveAgentCommand();
-  return writeLauncher(directory, [process.execPath, NO_ENV, command], endpoint, sessionEnv);
+  return writeLauncher(directory, [process.execPath, NO_ENV, AGENT_CLI], endpoint, sessionEnv);
 }
 
 /**
- * A sandboxed agent's door: the same launcher, running the bundled `wf` with the host's bun by
+ * A sandboxed agent's door: the same launcher, running the bundled `wfa` with the host's bun by
  * its real path, since a sandbox reads neither the workspace's sources nor bun's links under `~`.
  * A box copies `boxScript` to the launcher's path, which runs the bundle with the box's own bun.
  */
 export async function installSandboxedDoor(
   directory: string,
   endpoint: string,
-  /** The bundled `wf`'s source, written beside the launcher. */
+  /** The bundled `wfa`'s source, written beside the launcher. */
   source: string,
   sessionEnv?: string,
 ): Promise<AgentDoor> {
@@ -50,7 +51,7 @@ export async function installSandboxedDoor(
   const socket = join(real, basename(endpoint));
   // In the agent's own directory: bun will not load a module from the control plane's, which is
   // not listable so that no agent can find another's socket.
-  const bundle = join(real, "wf.js");
+  const bundle = join(real, "wfa.js");
   await writeFile(bundle, source, { mode: 0o500 });
   const launcher = await writeLauncher(real, [bun, NO_ENV, bundle], socket, sessionEnv);
   return {
@@ -64,12 +65,12 @@ export async function installSandboxedDoor(
 }
 
 /**
- * `wf` as one file's source, which a sandbox can read where it cannot read this workspace. Built by
+ * `wfa` as one file's source, which a sandbox can read where it cannot read this workspace. Built by
  * a `bun build` of its own: in process, the bundler resolved packages against the test runner's
  * state and missed the workspace's links.
  */
 export async function buildAgentBundle(): Promise<string> {
-  const entry = await resolveAgentCommand();
+  const entry = AGENT_CLI;
   const built = Bun.spawn({
     cmd: [process.execPath, "build", entry, "--target=bun"],
     cwd: dirname(entry),
@@ -81,7 +82,7 @@ export async function buildAgentBundle(): Promise<string> {
     new Response(built.stdout).text(),
     new Response(built.stderr).text(),
   ]);
-  if (code !== 0) throw new Error(`could not bundle wf: ${stderr.trim().slice(0, 400)}`);
+  if (code !== 0) throw new Error(`could not bundle wfa: ${stderr.trim().slice(0, 400)}`);
   return bundle;
 }
 
@@ -93,7 +94,7 @@ async function writeLauncher(
 ): Promise<string> {
   await mkdir(directory, { recursive: true });
   await chmod(directory, 0o700);
-  const path = join(directory, "wf");
+  const path = join(directory, "wfa");
   // Not writable, so an agent that redirects into its own launcher fails rather than replacing its
   // only way to answer. A `chmod` still gets past it; a sandbox denies the write outright.
   await writeFile(path, launcherScript(command, endpoint, sessionEnv, path), { mode: 0o500 });
@@ -105,7 +106,7 @@ function launcherScript(
   command: readonly string[],
   endpoint: string,
   sessionEnv: string | undefined,
-  /** Its own path, which `wf` names in what it prints, as an agent must type it. */
+  /** Its own path, which `wfa` names in what it prints, as an agent must type it. */
   path: string,
 ): string {
   if (sessionEnv !== undefined && !/^[A-Za-z_][A-Za-z0-9_]*$/.test(sessionEnv)) {
@@ -114,14 +115,3 @@ function launcherScript(
   const session = sessionEnv ? ` --session "\${${sessionEnv}:-}"` : "";
   return `#!/bin/sh\nexec ${command.map(shellQuote).join(" ")} --at ${shellQuote(endpoint)} --as ${shellQuote(path)}${session} "$@"\n`;
 }
-
-async function resolveAgentCommand(): Promise<string> {
-  const require = createRequire(import.meta.url);
-  const manifestPath = require.resolve("@agentswf/wf/package.json");
-  const manifest = JSON.parse(await readFile(manifestPath, "utf8")) as {
-    bin?: string | Record<string, string>;
-  };
-  const relative = typeof manifest.bin === "string" ? manifest.bin : manifest.bin?.wf;
-  if (!relative) throw new Error("@agentswf/wf does not publish the wf command");
-  return resolve(dirname(manifestPath), relative);
-}

package/src/allowance-command.ts

@@ -1,26 +1,15 @@
-import {
-  ALLOWANCE_VERSION,
-  type AllowanceReport,
-  type AllowanceWindow,
-  type HarnessAllowance,
+import type {
+  AllowanceReport,
+  AllowanceWindow,
+  HarnessAllowance,
 } from "@agentswf/contract/records";
 import { HARNESS_NAMES, type Harness } from "@agentswf/harness";
-import { PLAN_BASIS, planPrice } from "./accounting/plans";
+import { planPrice } from "./accounting/plans";
+import { messageOf } from "./errors";
+import help from "./help/allowance.txt" with { type: "text" };
+import type { Out } from "./run-commands";
 
-export const allowanceUsage = [
-  "usage: awf allowance [harness...] [--json]",
-  "",
-  "What is left of each harness's plan, as the harness itself shows it: claude's /usage, codex's",
-  "/status, and cursor's /usage, read in a Herdr pane. Nothing asks a model. Every harness when",
-  `none is named: ${HARNESS_NAMES.join(", ")}.`,
-  "",
-  "A plan's monthly price is the vendor's list price as of the table's date, not what was",
-  `charged: ${PLAN_BASIS}.`,
-  "",
-  `--json prints an ${ALLOWANCE_VERSION} record, the interface for scripts, with the plan as the`,
-  "harness names it and no price; what it prints otherwise is for reading. A harness that could",
-  "not be read says why. Exits 0 once every harness was asked, 2 on a usage error.",
-].join("\n");
+export const allowanceUsage = help.trimEnd();
 
 export type AllowanceCommand = { harnesses: Harness[]; json: boolean } | "help";
 
@@ -37,6 +26,27 @@ export function parseAllowanceCommand(argv: readonly string[]): AllowanceCommand
   return { harnesses: harnesses.length > 0 ? harnesses : [...HARNESS_NAMES], json };
 }
 
+/** `awf allowance`: what is left of each harness's plan, read with `read`. */
+export async function allowanceCommand(
+  argv: readonly string[],
+  io: Out & { read: (harness: Harness) => Promise<HarnessAllowance>; now: () => number },
+): Promise<number> {
+  let command: AllowanceCommand;
+  try {
+    command = parseAllowanceCommand(argv);
+  } catch (error) {
+    io.stderr(`awf: ${messageOf(error)}\n\n${allowanceUsage}`);
+    return 2;
+  }
+  if (command === "help") {
+    io.stdout(allowanceUsage);
+    return 0;
+  }
+  const report = await readReport(command.harnesses, io.read, io.now());
+  io.stdout(command.json ? JSON.stringify(report, null, 2) : describeReport(report));
+  return 0;
+}
+
 /** Every harness asked at once: cursor's pane takes seconds the others need not wait for. */
 export async function readReport(
   harnesses: readonly Harness[],
@@ -44,7 +54,7 @@ export async function readReport(
   now: number,
 ): Promise<AllowanceReport> {
   return {
-    version: ALLOWANCE_VERSION,
+    v: 1,
     readAt: new Date(now).toISOString(),
     harnesses: await Promise.all(harnesses.map(read)),
   };

package/src/attempt-ending.ts

@@ -12,6 +12,7 @@ import {
 import { PUBLISHED_PRICES } from "./accounting/prices";
 import { summarizeRun } from "./accounting/summary";
 import { messageOf } from "./errors";
+import { RunParked } from "./mailbox";
 import type { Paint } from "./progress-view";
 import { FromStageUnreached, primaryFailure, WorkflowStopped } from "./stopped";
 import {
@@ -53,6 +54,7 @@ export const OUTCOMES: Record<
   { word: string; told: string; mark: (paint: Paint) => string; exitCode?: number }
 > = {
   completed: { word: "completed", told: "completed", mark: (p) => p.ok("✓"), exitCode: 0 },
+  parked: { word: "parked", told: "parked", mark: (p) => p.ok("◇"), exitCode: 0 },
   stopped: { word: "stopped", told: "stopped", mark: (p) => p.busy("■"), exitCode: 3 },
   cancelled: { word: "cancelled", told: "was cancelled", mark: (p) => p.busy("■") },
   "timed-out": { word: "timed out", told: "timed out", mark: (p) => p.bad("✗"), exitCode: 1 },
@@ -63,7 +65,11 @@ export const OUTCOMES: Record<
 export type GoOn = (stop: WorkflowStopped | undefined, entered: readonly StageSummary[]) => string;
 
 /** The ending of a run that returned or threw. */
-export function decideEnding(run: Finished, deadline: AbsoluteDeadline, goOn: GoOn): AttemptEnd {
+export function decideEnding(
+  run: Finished,
+  deadline: AbsoluteDeadline | undefined,
+  goOn: GoOn,
+): AttemptEnd {
   if ("result" in run) {
     const { result } = run;
     return {
@@ -74,6 +80,18 @@ export function decideEnding(run: Finished, deadline: AbsoluteDeadline, goOn: Go
   }
   const { error } = run;
   const settled = error instanceof WorkflowRunError ? error : undefined;
+  const parked = primaryFailure(unwrapped(error));
+  if (parked instanceof RunParked) {
+    return {
+      ending: {
+        kind: "parked",
+        stages: settled?.stages ?? [],
+        ...parked.wait,
+      },
+      ...(settled ? { settled } : {}),
+      exitCode: OUTCOMES.parked.exitCode!,
+    };
+  }
   const { kind, stop, cancellation } = runOutcome(error, deadline);
   const cause = unwrapped(error);
   const beside =
@@ -104,10 +122,10 @@ export function decideEnding(run: Finished, deadline: AbsoluteDeadline, goOn: Go
  */
 export function endedBeforeStart(
   error: unknown,
-  deadline: AbsoluteDeadline,
+  deadline: AbsoluteDeadline | undefined,
   run: { runId: string; startedAt: number; endedAt: number },
   goOn: GoOn,
-): AttemptEnd & { ending: Exclude<Ending<JsonValue>, { kind: "completed" }> } {
+): AttemptEnd & { ending: Exclude<Ending<JsonValue>, { kind: "completed" | "parked" }> } {
   const { kind, cancellation } = runOutcome(error, deadline);
   const times = {
     startedAt: new Date(run.startedAt).toISOString(),
@@ -156,14 +174,14 @@ export function cleanupFailed(end: AttemptEnd, error: unknown, goOn: string): At
  */
 export function runOutcome(
   error: unknown,
-  deadline: AbsoluteDeadline,
+  deadline: AbsoluteDeadline | undefined,
 ): { kind: UnfinishedOutcome; stop?: WorkflowStopped; cancellation?: WorkflowCancelledError } {
   const cancellation = findCancellation(error);
   const failure = primaryFailure(unwrapped(error));
   const stop = failure instanceof WorkflowStopped ? failure : undefined;
   const timedOut =
     failure instanceof DeadlineExceededError &&
-    failure.deadline.unixMilliseconds === deadline.unixMilliseconds;
+    failure.deadline.unixMilliseconds === deadline?.unixMilliseconds;
   const kind = cancellation ? "cancelled" : stop ? "stopped" : timedOut ? "timed-out" : "failed";
   return { kind, ...(stop ? { stop } : {}), ...(cancellation ? { cancellation } : {}) };
 }

package/src/attempt-output.ts

@@ -4,13 +4,15 @@ import {
   type OutputRecord,
   RUN_EVENT_VERSIONS,
 } from "@agentswf/contract/records";
-import type { Ending, ExecutableWorkflow, JsonValue } from "@agentswf/contract/workflow";
+import type { Ending, JsonValue } from "@agentswf/contract/workflow";
 import { attemptAccounting } from "./accounting/summary";
 import type { AttemptEnd } from "./attempt-ending";
 import { messageOf } from "./errors";
 import { writeJson, writeWhole } from "./files";
+import { foldMailbox, readMailbox } from "./mailbox";
 import { type Attempt, appendEvent, endAttempt, outputFile, reportFile } from "./runs";
 import { withoutValue } from "./stage-ledger";
+import type { AnyWorkflow, LoadedWorkflow } from "./workflow-loader";
 
 /** Where an attempt's records went, and its output record as `--json` prints it. */
 export type Kept = {
@@ -30,27 +32,34 @@ export async function keepRecords(
   end: AttemptEnd,
   context: {
     attempt: Attempt;
-    executable: ExecutableWorkflow<JsonValue, JsonValue>;
-    workflow: { name: string; file: string };
+    loaded: LoadedWorkflow;
     stderr: (text: string) => void;
+    /** An event run's: runs `work` holding its run's lock. */
+    locked?: (work: () => Promise<void>) => Promise<void>;
   },
 ): Promise<Kept> {
   const { attempt, stderr } = context;
   const { ending, settled } = end;
   const dir = attempt.run.dir;
-  const report = await writeReport(context.executable, ending, dir, stderr);
+  const report = await writeReport(context.loaded.workflow, ending, dir, stderr);
   const stages = settled?.stages?.map(withoutValue);
-  const at =
-    ending.kind !== "completed" && ending.stage !== undefined ? { stage: ending.stage } : {};
+  const unfinished = ending.kind !== "completed" && ending.kind !== "parked" ? ending : undefined;
+  const at = unfinished?.stage !== undefined ? { stage: unfinished.stage } : {};
   const ended =
     ending.kind === "completed"
       ? { outcome: "completed" as const, value: ending.value }
-      : {
-          outcome: ending.kind,
-          reason: ending.reason,
-          ...at,
-          ...(end.needs ? { needs: [...end.needs] } : {}),
-        };
+      : ending.kind === "parked"
+        ? {
+            outcome: "parked" as const,
+            ...(ending.label === undefined ? {} : { label: ending.label }),
+            ...(ending.until === undefined ? {} : { until: ending.until }),
+          }
+        : {
+            outcome: ending.kind,
+            reason: ending.reason,
+            ...at,
+            ...(end.needs ? { needs: [...end.needs] } : {}),
+          };
   const kept: Kept = report ? { report } : {};
   const output = outputFile(dir);
   if (!settled) {
@@ -63,7 +72,7 @@ export async function keepRecords(
       version: OUTPUT_RECORD_VERSION,
       runId: settled.runId,
       attempt: attempt.record.attempt,
-      workflow: context.workflow,
+      workflow: { name: context.loaded.workflow.meta.name, file: context.loaded.file },
       accounting: settled.accounting,
       usage: settled.usage,
       artifacts: dir,
@@ -91,14 +100,35 @@ export async function keepRecords(
     kind: "attempt-ended",
     outcome: ending.kind,
   }).catch((error) => stderr(`awf: the run's event log was not written: ${messageOf(error)}`));
-  try {
+  // An event run's ending is written holding its run's lock, as parking's is: a sender after it sees
+  // the run returned and is refused, so what no wait took is counted whole. Its last batch was
+  // handled, as the code returned after it.
+  const writeEnding = async () => {
+    const unacknowledged =
+      ending.kind === "completed" && attempt.run.record.events
+        ? await readMailbox(dir).then(
+            // The event that started the run is `wf.started`'s, taken or not.
+            (records) => {
+              const state = foldMailbox(records);
+              return state.unacknowledged.filter((id) => id !== state.started?.id).length;
+            },
+            (error: unknown) => {
+              stderr(`awf: what no wait took was not counted: ${messageOf(error)}`);
+              return undefined;
+            },
+          )
+        : undefined;
     await endAttempt(attempt, {
       outcome: ending.kind,
-      ...(ending.kind === "completed" ? {} : { reason: ending.reason }),
+      ...(unacknowledged === undefined ? {} : { unacknowledged }),
+      ...(unfinished ? { reason: unfinished.reason } : {}),
       ...at,
       ...(stages ? { stages } : {}),
       ...(settled ? { accounting: attemptAccounting(settled.accounting) } : {}),
     });
+  };
+  try {
+    await (context.locked ?? ((work: () => Promise<void>) => work()))(writeEnding);
   } catch (error) {
     stderr(`awf: the attempt's ending was not written to ${attempt.file}: ${messageOf(error)}`);
   }
@@ -106,7 +136,7 @@ export async function keepRecords(
 }
 
 async function writeReport(
-  executable: ExecutableWorkflow<JsonValue, JsonValue>,
+  workflow: AnyWorkflow,
   ending: Ending<JsonValue>,
   dir: string,
   stderr: (text: string) => void,
@@ -114,11 +144,11 @@ async function writeReport(
   const file = reportFile(dir);
   // An earlier attempt's report is gone with it: report.md is the last ended attempt's.
   const none = () => rm(file, { force: true }).then(() => undefined);
-  if (!executable.report) return none();
+  if (!workflow.report) return none();
   // The result is still in output.json; a report that cannot be rendered or saved should not fail
   // the run, nor cost it its record.
   try {
-    const markdown = executable.report(
+    const markdown = workflow.report(
       ending.kind === "completed" ? ending.value : undefined,
       ending,
     );

package/src/attempt-view.ts

@@ -5,12 +5,7 @@ import type {
   StageNeed,
   StageRecord,
 } from "@agentswf/contract/records";
-import type {
-  Ending,
-  ExecutableWorkflow,
-  JsonValue,
-  StageSummary,
-} from "@agentswf/contract/workflow";
+import type { Ending, JsonValue, StageSummary } from "@agentswf/contract/workflow";
 import { ago, describeAccounting, describeAttempts } from "./accounting/format";
 import { sumAttempts } from "./accounting/summary";
 import { type AttemptEnd, OUTCOMES } from "./attempt-ending";
@@ -22,6 +17,7 @@ import type { RunCommand } from "./run-command";
 import type { AttemptRefusal } from "./runs";
 import { schemaLines } from "./stage-schema";
 import { FromStageUnreached, type WorkflowStopped } from "./stopped";
+import type { AnyWorkflow } from "./workflow-loader";
 
 /**
  * Prints how the attempt ended, and returns its exit code. A completed one's result goes to stdout;
@@ -32,7 +28,7 @@ export function printEnding(
   end: AttemptEnd,
   kept: Kept,
   context: {
-    executable: ExecutableWorkflow<JsonValue, JsonValue>;
+    workflow: AnyWorkflow;
     /** The run's id and folder. */
     run: { id: string; dir: string };
     n: number;
@@ -56,7 +52,7 @@ export function printEnding(
   const { ending, settled } = end;
   const presented =
     ending.kind === "completed" && !context.json
-      ? present(context.executable, ending, stderr)
+      ? present(context.workflow, ending, stderr)
       : undefined;
   if (end.alsoFailed) stderr(`awf: also failed: ${end.alsoFailed}`);
   const again =
@@ -67,7 +63,7 @@ export function printEnding(
   if (context.cleanupAlso) stderr(`awf: runtime cleanup also failed: ${context.cleanupAlso}`);
   // Beside the result rather than in it: stdout stays the workflow's report or the JSON.
   const lines = describeEnding(ending, {
-    named: `${context.executable.definition.meta.name} ${context.run.id}`,
+    named: `${context.workflow.meta.name} ${context.run.id}`,
     n: context.n,
     ...(settled ? { accounting: settled.accounting } : {}),
     earlier: context.earlier,
@@ -78,7 +74,7 @@ export function printEnding(
     ...(end.needs ? { needs: end.needs } : {}),
     ...(settled?.panes ? { panes: settled.panes } : {}),
     // As the run's Herdr workspace is labelled.
-    runWorkspace: `awf ${context.executable.definition.meta.name} ${context.run.id} #${context.n}`,
+    runWorkspace: `awf ${context.workflow.meta.name} ${context.run.id} #${context.n}`,
     paint: context.terminal?.color ? ANSI : PLAIN,
   });
   for (const line of ["", ...lines]) stderr(line);
@@ -91,7 +87,9 @@ export function printEnding(
 export function toldOf(end: AttemptEnd, kept: Kept): string {
   const { ending } = end;
   const told = `${OUTCOMES[ending.kind].told}${kept.output ? `; its record is ${kept.output}` : ""}`;
-  return ending.kind === "completed" ? told : `${told}: ${ending.reason}`;
+  if (ending.kind === "completed") return told;
+  if (ending.kind === "parked") return ending.label ? `${told}: ${ending.label}` : told;
+  return `${told}: ${ending.reason}`;
 }
 
 /**
@@ -135,6 +133,17 @@ function describeEnding(
   if (ending.kind === "completed") {
     return [`${mark} ${word} · ${run}`, ...figures, ...rows([], context)];
   }
+  if (ending.kind === "parked") {
+    const waits = [ending.label, ending.until && `until ${ending.until}`]
+      .filter(Boolean)
+      .join(" · ");
+    return [
+      `${mark} ${word}${waits ? `: ${waits}` : ""}`,
+      `  ${run}`,
+      ...figures,
+      ...rows([], context),
+    ];
+  }
   // A reason's later lines, such as a schema's problems, sit under it, apart from the rows.
   const [first, ...more] = ending.reason.split("\n");
   const goOn = context.choose
@@ -233,13 +242,13 @@ function runTotal(n: number, current: RunAccounting, earlier: readonly AttemptRe
 
 /** A completed attempt's value as the workflow presents it; undefined to print the JSON. */
 function present(
-  executable: ExecutableWorkflow<JsonValue, JsonValue>,
+  workflow: AnyWorkflow,
   ending: Extract<Ending<JsonValue>, { kind: "completed" }>,
   stderr: (text: string) => void,
 ): string | undefined {
-  if (!executable.present) return undefined;
+  if (!workflow.present) return undefined;
   try {
-    return executable.present(ending.value, ending)?.trimEnd();
+    return workflow.present(ending.value, ending)?.trimEnd();
   } catch (error) {
     stderr(`awf: present: ${messageOf(error)}; printing the full result instead`);
     return undefined;
@@ -343,8 +352,9 @@ export function continueCommand(
     ...(command.runRootGiven ? ["--run-root", command.runRoot] : []),
     ...(command.cwdGiven ? ["--cwd", command.cwd] : []),
     pathFrom(command.shellCwd, command.workflowFile),
-    "--continue",
+    "--id",
     id,
+    "--continue",
     ...(redo === undefined ? [] : ["--from-stage", redo]),
     ...(values === undefined ? [] : ["--values", values]),
   ]