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

package/src/testing.ts

@@ -104,7 +104,7 @@ export function future(milliseconds = 60_000): { unixMilliseconds: number } {
   return { unixMilliseconds: Date.now() + milliseconds };
 }
 
-/** Answers a call the way an agent's `wf` does: one framed request over its own socket. */
+/** Answers a call the way an agent's `wfa` does: one framed request over its own socket. */
 export async function submit(
   binding: { endpoint: string; operationId: string },
   value: unknown,

package/src/tick-command.ts

@@ -1,6 +1,7 @@
 import type { TickResultJson } from "@agentswf/contract/records";
 import { messageOf } from "./errors";
 import { exists } from "./files";
+import help from "./help/tick.txt" with { type: "text" };
 import { listProjects, projectRunRoot } from "./projects";
 import type { Out } from "./run-commands";
 import { parsePlace } from "./run-commands";
@@ -8,19 +9,7 @@ import { runLockFile, withRunLock } from "./run-lock";
 import { listRuns } from "./run-state";
 import { type Launch, wake } from "./wake";
 
-export const tickUsage = [
-  "usage: awf tick [--cwd <directory>] [--run-root <directory>] [--json]",
-  "       awf tick --all [--json]",
-  "",
-  "Wakes every run of a workflow with events under --cwd's .awf/runs, or --run-root, the runs awf",
-  "runs lists there, as an event would: continues a parked run whose wait's timer is due, and a",
-  "crashed or failed one until it has failed three times in a row. Runs of other workflows are left",
-  "as they are. --all wakes them in every project awf has started one in, as ~/.awf/projects lists",
-  "them. Run it on any schedule; a run is continued once however many wakers come at once.",
-  "",
-  "Prints a line for each run it woke, and nothing when it woke none. --json prints one document.",
-  "Exits 0, or 1 when a project is gone or a run could not be woken; the others are still woken.",
-].join("\n");
+export const tickUsage = help.trimEnd();
 
 export async function tickCommand(
   argv: readonly string[],

package/src/tools.ts

@@ -14,7 +14,14 @@ import { canonical } from "./canonical-json";
 import { scheduleAt } from "./deadlines";
 import { messageOf } from "./errors";
 import type { RunEventBody } from "./run-event-log";
-import { checkGiven, QUOTING_RULE, readGiven, simpleInput, usageLine } from "./simple-input";
+import {
+  checkGiven,
+  QUOTING_RULE,
+  readGiven,
+  simpleInput,
+  takesText,
+  usageLine,
+} from "./simple-input";
 
 /** How long a handler that ignores its aborted signal is waited for before its call is settled. */
 export const TOOL_SETTLE_MS = 5_000;
@@ -195,7 +202,7 @@ export class ToolCalls<Scope> {
     if (operation) operation.deadline = () => deadline;
   }
 
-  /** The call this agent has running, which holds back its `wf result` and `wf waiting`. */
+  /** The call this agent has running, which holds back its `wfa result` and `wfa waiting`. */
   running(agent: AgentKey): { tool: string; settledBy?: number } | undefined {
     const running = this.#current.get(agent)?.running;
     return running && { tool: running.tool, ...optional("settledBy", running.settledBy) };
@@ -204,7 +211,7 @@ export class ToolCalls<Scope> {
   // Calls
 
   /**
-   * `wf tool`'s request from `agent`'s socket. `lifetime` sets how long its connection may stay
+   * `wfa tool`'s request from `agent`'s socket. `lifetime` sets how long its connection may stay
    * open, from now: undefined for as long as the call takes.
    */
   async call(
@@ -519,8 +526,8 @@ function readInput(
 
 /**
  * The tools block of an operation's prompt: how to call one, then each tool's name and description
- * and its usage line, or the schema for an input that isn't simple. The quoting rule comes with it
- * unless the result block above already said it; none for an agent without tools.
+ * and its usage line, or the schema for an input that isn't simple. The quoting rule comes with a
+ * free-text flag unless the result block above already said it; none for an agent without tools.
  */
 export function toolsLesson(
   tools: readonly { name: string; description: string; input?: JsonSchema }[],
@@ -533,9 +540,11 @@ export function toolsLesson(
     return { ...each, simple };
   });
   const flags = taught.some((each) => each.simple && each.simple.length > 0);
+  const text = taught.some((each) => each.simple && takesText(each.simple));
   const json = taught.some((each) => !each.simple);
+  const value = text ? "'<value>'" : "<value>";
   const forms = [
-    flags ? `${launcher} tool <name> --<option> '<value>' ...` : `${launcher} tool <name>`,
+    flags ? `${launcher} tool <name> --<option> ${value} ...` : `${launcher} tool <name>`,
     ...(json ? [`${launcher} tool <name> <<'WF_JSON'`, "<json>", "WF_JSON"] : []),
   ];
   const entries = taught.map(({ name, description, input, simple }) => {
@@ -549,7 +558,7 @@ export function toolsLesson(
     "You have tools the workflow runs for you. Call one with:",
     "",
     ...forms,
-    ...(flags && !quotingSaid ? ["", QUOTING_RULE] : []),
+    ...(text && !quotingSaid ? ["", QUOTING_RULE] : []),
     "",
     ...entries,
   ].join("\n");

package/src/workflow-runner.ts

@@ -189,7 +189,7 @@ import {
   type RunSandboxOptions,
   type SeatedAgent,
 } from "./sandboxes";
-import { QUOTING_RULE, simpleInput, usageLine } from "./simple-input";
+import { QUOTING_RULE, simpleInput, takesText, usageLine } from "./simple-input";
 import { placeSkills, RunSkills, readSkillSources } from "./skills/run-skills";
 import { asSource, branchOf, branchValue, source, takeOf } from "./sources";
 import { StageLedger, type StageProgress } from "./stage-ledger";
@@ -204,7 +204,7 @@ export type RunWorkflowOptions = {
   livenessPolicy?: LivenessPolicy;
   /** A `keepAlive` window that gives no `timeoutMs`; absent, an hour. A test's is short. */
   defaultWindowMs?: number;
-  /** The run's time, which its timers and `workflow.now()` read; absent, the clock's. A test's is virtual. */
+  /** The run's time, which its timers and `wf.now()` read; absent, the clock's. A test's is virtual. */
   now?: () => number;
   runRoot: string;
   /** The run this is an attempt of, whose folder the operator claimed under `runRoot`. */
@@ -253,7 +253,7 @@ export type RunWorkflowOptions = {
   skillCache?: string;
   /** The decision models workflows may ask; without them, `decisions.decide` is refused. */
   decisions?: DecisionInstallation;
-  /** How `workflow.allowance` reads a harness's plan; without it, every harness reads `none`. */
+  /** How `wf.allowance` reads a harness's plan; without it, every harness reads `none`. */
   allowance?: (harness: Harness) => Promise<HarnessAllowance>;
   /**
    * Where an agent may `--await-reply`: the engine's list by harness and placement unless given. A
@@ -267,7 +267,7 @@ export type RunWorkflowOptions = {
    */
   coordinators?: readonly CoordinatorPort[];
   /**
-   * Sends `workflow.emit`'s event through the one way in; absent, `emitEvent` on this machine. A
+   * Sends `wf.emit`'s event through the one way in; absent, `emitEvent` on this machine. A
    * test records them instead.
    */
   emit?: Emitter;
@@ -891,7 +891,7 @@ class WorkflowOwner {
   readonly #inFlight = new Set<Promise<unknown>>();
   #closed = false;
   #closing: Promise<unknown[]> | undefined;
-  /** The bundled `wf`'s source, built once, at the first sandboxed agent. */
+  /** The bundled `wfa`'s source, built once, at the first sandboxed agent. */
   #bundle: Promise<string> | undefined;
   /** The calling session, once the workflow has asked for it (ADR 0010). */
   #caller: { key: string; state: Promise<LogicalAgent> } | undefined;
@@ -957,7 +957,7 @@ class WorkflowOwner {
         if (!agent || agent.hasStartedTurn) return false;
         return options.awaitReply(agent.execution, agent.confirmsDelivery);
       },
-      launcher: (key) => this.#logical.get(key)?.launcher ?? "wf",
+      launcher: (key) => this.#logical.get(key)?.launcher ?? "wfa",
       changed: (key) => {
         this.#messagesChanged();
         this.#logical.get(key)?.messagesChanged();
@@ -1142,7 +1142,7 @@ class WorkflowOwner {
       },
       log: (message, fields) => options.log(message, fields),
       now: () => {
-        this.#notReading("workflow.now()");
+        this.#notReading("wf.now()");
         return new Date(options.now());
       },
       sleep: async (name, when) => {
@@ -1168,10 +1168,10 @@ class WorkflowOwner {
             timers: () => source({}, { name: "timer:due" }),
             at: (read: () => Date | null) => timeRead(read),
             after: (duration: Duration) => {
-              this.#notReading("workflow.after()");
+              this.#notReading("wf.after()");
               if (typeof duration !== "string" || !/^\d+(?:\.\d+)?[dhm]$/.test(duration))
                 throw new Error(
-                  `workflow.after takes days, hours or minutes, "1d", "3h", "1.5h"; not ${String(duration)}`,
+                  `wf.after takes days, hours or minutes, "1d", "3h", "1.5h"; not ${String(duration)}`,
                 );
               return new Date(parseWhen(duration, options.now()).due);
             },
@@ -1189,7 +1189,7 @@ class WorkflowOwner {
   #notReading(what: string): void {
     if (this.#reading)
       throw new Error(
-        `${what} in workflow.at's read: a time made at the read moves with every wait and never comes due; keep the time in the run's state where it is set`,
+        `${what} in wf.at's read: a time made at the read moves with every wait and never comes due; keep the time in the run's state where it is set`,
       );
   }
 
@@ -1205,7 +1205,7 @@ class WorkflowOwner {
     if (value === null) return undefined;
     if (!(value instanceof Date) || !Number.isFinite(value.getTime()))
       throw new Error(
-        `select's ${branch}: workflow.at reads a valid Date or null from the run's state, not ${
+        `select's ${branch}: wf.at reads a valid Date or null from the run's state, not ${
           value instanceof Date ? "an invalid Date" : (JSON.stringify(value) ?? String(value))
         }`,
       );
@@ -2988,6 +2988,7 @@ class LogicalAgent implements AgentRef {
         .then(
           ({ outcome }) => outcome,
           (error: unknown): TurnOutcome<JsonValue> => ({
+            answered: false,
             kind: "failed",
             reason: messageOf(error),
             retryable: false,
@@ -3423,7 +3424,12 @@ class LogicalAgent implements AgentRef {
     const usage = () =>
       entry.settle({ settledAt: Math.min(Date.now(), deadline.unixMilliseconds) }, []);
     if (Date.now() >= deadline.unixMilliseconds) {
-      return { kind: "timed-out", reason: "settings deadline exceeded", usage: usage() };
+      return {
+        answered: false,
+        kind: "timed-out",
+        reason: "settings deadline exceeded",
+        usage: usage(),
+      };
     }
     const next: AgentExecution = { ...this.#execution, ...change };
     const pane = placementOf(next) === "pane";
@@ -3451,15 +3457,16 @@ class LogicalAgent implements AgentRef {
           cancelled !== undefined ? "cancelled" : expired ? "timed-out" : "failed",
         );
       }
-      if (cancelled !== undefined) return { kind: "cancelled", reason, usage: usage() };
+      if (cancelled !== undefined)
+        return { answered: false, kind: "cancelled", reason, usage: usage() };
       return expired
-        ? { kind: "timed-out", reason, usage: usage() }
-        : { kind: "failed", reason, retryable: false, usage: usage() };
+        ? { answered: false, kind: "timed-out", reason, usage: usage() }
+        : { answered: false, kind: "failed", reason, retryable: false, usage: usage() };
     } finally {
       removeCanceller?.();
     }
     this.#execution = next;
-    return { kind: "answered", value: null, usage: usage() };
+    return { answered: true, kind: "answered", value: null, usage: usage() };
   }
 
   /**
@@ -3607,7 +3614,7 @@ class LogicalAgent implements AgentRef {
     const recoveryPrompt =
       nudge?.prompt ??
       (waitingSupported
-        ? "Report the result now, or use wf waiting with a reason if you still need time."
+        ? "Report the result now, or use wfa waiting with a reason if you still need time."
         : "You finished without reporting the requested result. Report it now.");
     // The first prompt carries only the result command; waiting is rare, so it is offered only
     // once a check-in finds the agent idle without an answer.
@@ -3665,7 +3672,7 @@ class LogicalAgent implements AgentRef {
                 toolsLesson(
                   this.options.tools.taught(this.key),
                   this.options.launcher,
-                  simpleInput(schema) !== undefined,
+                  resultSaysQuoting(schema),
                 ),
               ]
                 .filter(Boolean)
@@ -3733,14 +3740,23 @@ class LogicalAgent implements AgentRef {
       outcome.charges,
     );
     if (outcome.kind === "answered")
-      return { outcome: { kind: "answered", value: outcome.value as JsonValue, usage } };
+      return {
+        outcome: { answered: true, kind: "answered", value: outcome.value as JsonValue, usage },
+      };
     if (outcome.kind === "failed") {
       const login = outcome.login ? { login: outcome.login } : {};
       return {
-        outcome: { kind: "failed", reason: outcome.reason, retryable: false, ...login, usage },
+        outcome: {
+          answered: false,
+          kind: "failed",
+          reason: outcome.reason,
+          retryable: false,
+          ...login,
+          usage,
+        },
       };
     }
-    return { outcome: { kind: outcome.kind, reason: outcome.reason, usage } };
+    return { outcome: { answered: false, kind: outcome.kind, reason: outcome.reason, usage } };
   }
 
   /**
@@ -4036,10 +4052,10 @@ class LogicalAgent implements AgentRef {
     // Recorded `answered` with no value: it did what it was woken for, and takes no result.
     this.turnEnded(
       outcome.kind === "answered"
-        ? { kind: "answered", value: null, usage }
+        ? { answered: true, kind: "answered", value: null, usage }
         : outcome.kind === "failed"
-          ? { kind: "failed", reason: outcome.reason, retryable: false, usage }
-          : { kind: outcome.kind, reason: outcome.reason, usage },
+          ? { answered: false, kind: "failed", reason: outcome.reason, retryable: false, usage }
+          : { answered: false, kind: outcome.kind, reason: outcome.reason, usage },
       "turn",
       true,
     );
@@ -4074,17 +4090,23 @@ class LogicalAgent implements AgentRef {
         later,
       );
       if (native === "expired") {
-        return { kind: "timed-out", reason: "compaction deadline exceeded", usage };
+        return {
+          answered: false,
+          kind: "timed-out",
+          reason: "compaction deadline exceeded",
+          usage,
+        };
       }
       if (native.state === "completed") {
         return native.summary === undefined
           ? {
+              answered: false,
               kind: "failed",
               reason: native.detail ?? "the harness did not confirm a compaction",
               retryable: false,
               usage,
             }
-          : { kind: "answered", value: native.summary, usage };
+          : { answered: true, kind: "answered", value: native.summary, usage };
       }
       return reconcile<string>(native, usage);
     };
@@ -4156,7 +4178,7 @@ function checkedWhen(when: unknown): string | Date {
   if (when instanceof Date || typeof when === "string") return when;
   if (readOf(when))
     throw new Error(
-      "sleep is for a duration or a Date; workflow.at() is a select's branch, read at each of its waits",
+      "sleep is for a duration or a Date; wf.at() is a select's branch, read at each of its waits",
     );
   throw new Error('sleep is for a duration, "2h", or until a Date');
 }
@@ -4176,18 +4198,18 @@ function branchesOf(what: string, branches: unknown, durations: boolean): [strin
   if ("key" in branches) throw new Error(`${what}: no branch is named key, which the answer uses`);
   for (const [branch, source] of entries)
     if (typeof source === "string" && !durations)
-      throw new Error(`${what}'s ${branch} is a duration: a timer in a loop is workflow.timer()'s`);
+      throw new Error(`${what}'s ${branch} is a duration: a timer in a loop is wf.timer()'s`);
   return entries;
 }
 
 /** What a time read from state reads, by its source. */
 const timeReads = new WeakMap<object, () => Date | null>();
 
-/** `workflow.at(read)`: a select's branch, due at the time `read` returns. */
+/** `wf.at(read)`: a select's branch, due at the time `read` returns. */
 function timeRead(read: () => Date | null): TimeRead {
   if (typeof read !== "function")
     throw new Error(
-      "workflow.at takes a function that reads a Date or null from the run's state, as () => ledger.nextNudge()",
+      "wf.at takes a function that reads a Date or null from the run's state, as () => ledger.nextNudge()",
     );
   const value = Object.freeze({});
   timeReads.set(value, read);
@@ -4205,7 +4227,7 @@ function sourceTake(what: string, branch: string, source: unknown): WaitTake {
   if (take) return take;
   if (readOf(source))
     throw new Error(
-      `${what}'s ${branch} is workflow.at(), a select's: a race answers once, so it takes a timer, workflow.timer(name, date)`,
+      `${what}'s ${branch} is wf.at(), a select's: a race answers once, so it takes a timer, wf.timer(name, date)`,
     );
   throw new Error(
     `${what}'s ${branch} is not a source: a timer, a signal, a participant routed to the code, an agent, or a started turn`,
@@ -4439,20 +4461,41 @@ function reconcile<T extends JsonValue>(
 ): TurnOutcome<T> {
   switch (native.state) {
     case "completed":
-      return { kind: "unanswered", reason: "agent settled without an accepted result", usage };
+      return {
+        answered: false,
+        kind: "unanswered",
+        reason: "agent settled without an accepted result",
+        usage,
+      };
     case "blocked":
-      return { kind: "blocked", reason: native.detail ?? "agent is blocked", usage };
+      return {
+        answered: false,
+        kind: "blocked",
+        reason: native.detail ?? "agent is blocked",
+        usage,
+      };
     case "timed-out":
-      return { kind: "timed-out", reason: native.detail ?? "operation timed out", usage };
+      return {
+        answered: false,
+        kind: "timed-out",
+        reason: native.detail ?? "operation timed out",
+        usage,
+      };
     case "failed":
       return {
+        answered: false,
         kind: "failed",
         reason: native.detail ?? "harness operation failed",
         retryable: false,
         usage,
       };
     case "cancelled":
-      return { kind: "cancelled", reason: native.detail ?? "operation cancelled", usage };
+      return {
+        answered: false,
+        kind: "cancelled",
+        reason: native.detail ?? "operation cancelled",
+        usage,
+      };
   }
 }
 
@@ -4566,6 +4609,11 @@ function resultSchema<T extends JsonValue>(schema: OutputSchema<T> | undefined):
   return schema ? parseJsonSchema(schema) : { type: "string" };
 }
 
+function resultSaysQuoting(schema: JsonSchema): boolean {
+  const simple = simpleInput(schema);
+  return simple !== undefined && takesText(simple);
+}
+
 function operationPrompt(
   prompt: string,
   schema: JsonSchema,
@@ -4576,7 +4624,7 @@ function operationPrompt(
   // A quoted heredoc passes the JSON through untouched: a quoted argument broke on shell quoting
   // (story 002). Not indented: a copied terminator with leading spaces never closes the heredoc.
   // The schema itself, not a rendering of it: without its bounds, first answers were 0/160 valid
-  // (E5). `wf` says what to do about a rejection, so the prompt does not. A simple schema is taught
+  // (E5). `wfa` says what to do about a rejection, so the prompt does not. A simple schema is taught
   // as flags instead, its usage line carrying every bound, which held them as well (story 035, M1).
   const simple = simpleInput(schema);
   if (simple) {
@@ -4586,8 +4634,7 @@ function operationPrompt(
       "When the answer is ready, return it by running:",
       "",
       `${launcher} result ${callId} ${usageLine(simple)}`,
-      "",
-      QUOTING_RULE,
+      ...(takesText(simple) ? ["", QUOTING_RULE] : []),
     ].join("\n");
   }
   return [

package/src/workflow-testing/coordinator.typecheck.ts

@@ -1,9 +1,8 @@
 // Checked by `tsc --noEmit`, never run: story 032's workflow and its test, as an author writes them.
-import {
-  isAnswered,
-  type ParticipantRef,
-  type WorkflowContext,
-  type WorkflowDefinition,
+import type {
+  ParticipantRef,
+  WorkflowContext,
+  WorkflowDefinition,
 } from "@agentswf/contract/workflow";
 import { answer, type ParticipantScript, testWorkflow } from ".";
 
@@ -11,13 +10,13 @@ declare const runtime: string;
 
 const investigate: WorkflowDefinition<null, string> = {
   meta: { name: "investigate", description: "watches checkout-api" },
-  async run(workflow: WorkflowContext) {
-    const investigator = await workflow.agents.open({ key: "investigator", runtime });
-    const coordinator: ParticipantRef = await workflow.participants.connect({
+  async run(wf: WorkflowContext) {
+    const investigator = await wf.agents.open({ key: "investigator", runtime });
+    const coordinator: ParticipantRef = await wf.participants.connect({
       key: "coordinator",
       labels: { audience: "operator" },
     });
-    await workflow.messages.allow({
+    await wf.messages.allow({
       between: [investigator, coordinator],
       purpose: "report findings that hold up; ask when the logs can't settle it",
       timeoutMs: 2 * 60 * 60_000,
@@ -25,8 +24,8 @@ const investigate: WorkflowDefinition<null, string> = {
     const { outcome } = await investigator.run({ prompt: "Check the checkout-api logs." });
     await coordinator.release("investigation done");
     // A run has no deadline unless `awf run --timeout` gives it one.
-    const left = workflow.deadline ? workflow.deadline.unixMilliseconds - Date.now() : undefined;
-    return isAnswered(outcome) ? `${outcome.value} (${left ?? "no"} ms left)` : outcome.kind;
+    const left = wf.deadline ? wf.deadline.unixMilliseconds - Date.now() : undefined;
+    return outcome.answered ? `${outcome.value} (${left ?? "no"} ms left)` : outcome.kind;
   },
 };
 
@@ -49,7 +48,7 @@ export const sendsFirst: ParticipantScript = async (event) => {
   if (sent.code !== "delivered") throw new Error(sent.code);
 };
 
-export async function refused(workflow: WorkflowContext): Promise<void> {
+export async function refused(wf: WorkflowContext): Promise<void> {
   // @ts-expect-error bindingPath is gone: the socket's place is fixed.
-  await workflow.participants.connect({ key: "coordinator", bindingPath: "/tmp/x" });
+  await wf.participants.connect({ key: "coordinator", bindingPath: "/tmp/x" });
 }

package/src/workflow-testing/host.ts

@@ -37,7 +37,7 @@ import {
   type FakeFork,
   type FakeSet,
 } from "@agentswf/harness/testing";
-import { submitControl, submitResult, submitWaiting } from "@agentswf/wf/client";
+import { submitControl, submitResult, submitWaiting } from "../agent-cli/client";
 import {
   type Message,
   type MessageOutcome,
@@ -192,7 +192,7 @@ export function createScriptedHost(
     return n;
   };
 
-  /** `wf send` or `wf reply` from a running script; with `awaitReply`, resolves with the reply. */
+  /** `wfa send` or `wfa reply` from a running script; with `awaitReply`, resolves with the reply. */
   const message = async (
     invocation: Invocation,
     command: "send" | "reply",
@@ -226,7 +226,7 @@ export function createScriptedHost(
         suspendIfAwaiting(invocation);
         return { kind: "refused", code: response.code as SendCode | ReplyCode };
       }
-      throw new Error(`wf ${command} was refused (${response.code}): ${response.error}`);
+      throw new Error(`wfa ${command} was refused (${response.code}): ${response.error}`);
     }
     if (!options.awaitReply) {
       suspendIfAwaiting(invocation);
@@ -238,7 +238,7 @@ export function createScriptedHost(
     });
   };
 
-  /** `wf tool` from a running script, as JSON or no input; waits as long as the engine takes. */
+  /** `wfa tool` from a running script, as JSON or no input; waits as long as the engine takes. */
   const callTool = async (
     invocation: Invocation,
     name: string,
@@ -278,14 +278,14 @@ export function createScriptedHost(
         return { kind: "failed", outcome: response.outcome, error: response.error };
       default:
         if (response.code === "internal-error" || !TOOL_REFUSALS.has(response.code))
-          throw new Error(`wf tool was refused (${response.code}): ${response.error}`);
+          throw new Error(`wfa tool was refused (${response.code}): ${response.error}`);
         return { kind: "refused", code: response.code as ToolCode, error: response.error };
     }
   };
 
   /**
    * Ends the native turn when its script has gone still awaiting a reply, as an agent ends its turn
-   * after `wf send --await-reply`: nothing of the host's in flight, and no step taken since.
+   * after `wfa send --await-reply`: nothing of the host's in flight, and no step taken since.
    */
   const suspendIfAwaiting = (invocation: Invocation) => {
     setTimeout(() => {
@@ -413,7 +413,7 @@ export function createScriptedHost(
           // Submitted is answered, even though the engine then releases the turn.
           let outcome: TurnOutcome = "cancelled";
           try {
-            // As an agent's `wf send` returns before it can run `wf result`.
+            // As an agent's `wfa send` returns before it can run `wfa result`.
             if (invocation) await Promise.allSettled([...invocation.calls]);
             const { endpoint, operationId } = context.binding!;
             const response = await submitResult(endpoint, {
@@ -782,7 +782,7 @@ type Awaiting = { peer: string; by: Invocation; resolve(outcome: MessageOutcome)
 type Invocation = {
   operation: Operation;
   turn: Turn;
-  /** Its `wf` calls in flight. */
+  /** Its `wfa` calls in flight. */
   calls: Set<Promise<unknown>>;
   state: "running" | "suspended" | "settled" | "cancelled";
   /** Where it stopped in its current native turn. */

package/src/workflow-testing/index.ts

@@ -102,7 +102,7 @@ export type TestOptions = {
   awaitReply?: "listed" | "anywhere";
   /** Each decision's answers, by its key or a pattern. */
   decisions?: Readonly<Record<string, DecisionScript>>;
-  /** What `workflow.allowance` reads, one per harness; a harness with none here reads `none`. */
+  /** What `wf.allowance` reads, one per harness; a harness with none here reads `none`. */
   allowance?: readonly HarnessAllowance[];
   /** Runtime aliases beside the ones `awf run` installs, `claude` and `codex`; the same name replaces one. */
   runtimes?: RuntimeAliases;
@@ -488,7 +488,6 @@ export async function testWorkflow<Args extends JsonValue, Result extends JsonVa
       sandboxes: {
         providers: {
           installed: { srt: sandboxes.provider, docker: sandboxes.provider },
-          default: "srt",
         },
         sandboxesDir: directory(),
         machineRoot: directory(),

package/src/workflow-testing/script.ts

@@ -42,16 +42,16 @@ export type Turn = {
    */
   readonly messages: readonly Message[];
   /**
-   * `wf send`: resolves once admitted, `sent`; or, with `awaitReply`, with the reply, which arrives
+   * `wfa send`: resolves once admitted, `sent`; or, with `awaitReply`, with the reply, which arrives
    * in a later turn of the same call. Returning a result without awaiting it drops the wait, and it
    * resolves `failed` with reason `dropped`. While a reply is awaited the script awaits only the
    * host's calls: once it is still, its turn ends.
    */
   send(peer: string, text: string, options?: SendOptions): Promise<MessageOutcome>;
-  /** `wf reply`: answers the question `peer` asked. A result is refused while one is owed. */
+  /** `wfa reply`: answers the question `peer` asked. A result is refused while one is owed. */
   reply(peer: string, text: string, options?: SendOptions): Promise<MessageOutcome>;
   /**
-   * `wf tool`: calls the agent's tool `name` with `input` as its JSON, or none, through the run's
+   * `wfa tool`: calls the agent's tool `name` with `input` as its JSON, or none, through the run's
    * real checks and handler; resolves with what the agent would read.
    */
   tool(name: string, input?: JsonObject): Promise<ToolOutcome>;
@@ -60,7 +60,7 @@ export type Turn = {
 };
 
 /**
- * How a tool call ended, as `wf tool` reports it; a failure or a refusal is a value to test. A
+ * How a tool call ended, as `wfa tool` reports it; a failure or a refusal is a value to test. A
  * refusal carries what the agent is told, which for `invalid-input` is what it corrects from.
  */
 export type ToolOutcome =

package/src/workflow-testing/workflow-testing.typecheck.ts

@@ -50,7 +50,7 @@ const withEvents = defineWorkflow({
   meta: { name: "w", description: "w" },
   file: import.meta.path,
   events: { ping: { type: "object" } as OutputSchema<{ n: number }> },
-  run: async (workflow) => (await workflow.receive()).length,
+  run: async (wf) => (await wf.receive()).length,
 });
 export const tested = () => testWorkflow(withEvents, { id: "k" });
 // @ts-expect-error a workflow with events is tested from { id, event? }, never its args
@@ -58,7 +58,7 @@ export const byArgs = () => testWorkflow(withEvents, null);
 const plain = defineWorkflow({
   meta: { name: "p", description: "p" },
   prepare: ({ argv }) => ({ n: argv.length }),
-  run: async (_workflow, args) => args.n,
+  run: async (_wf, args) => args.n,
 });
 // @ts-expect-error a workflow without events is tested from its args, not { id }
 export const byOptions = () => testWorkflow(plain, { id: "k" });