@agentswf/engine 0.1.0-beta.5 → 0.1.0

package/src/workflow-testing/run-test.ts

@@ -1,14 +1,14 @@
 import { mkdtempSync, rmSync } from "node:fs";
-import { mkdir } from "node:fs/promises";
+import { appendFile, mkdir } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import {
-  MAILBOX_RECORD_VERSION,
-  type MailboxRecord,
+  type EventLine,
+  type RunLine,
+  type RunPanes,
+  readRun,
   type SandboxRecord,
-  STAGE_RECORD_VERSION,
-  type StageNeed,
-  type StageRecord,
+  type StageLine,
 } from "@agentswf/contract/records";
 import {
   AWF_ID_PREFIX,
@@ -20,31 +20,30 @@ import {
   isEventWorkflow,
   type JsonObject,
   type JsonValue,
+  type KeepPane,
   type OutputOf,
-  type ParticipantReply,
   positiveDurationMilliseconds,
   type RuntimeAliases,
   WORKFLOW_KIND,
   type Workflow,
 } from "@agentswf/contract/workflow";
-import { type Harness, sandboxTokens } from "@agentswf/harness";
+import type { Harness } from "@agentswf/harness";
+import { SCRIPTED_HOMES } from "@agentswf/harness/testing";
 import { createFakeSandboxProvider } from "@agentswf/sandbox/testing/fake";
 import { decideEnding, type Finished } from "../attempt-ending";
 import { continueCommand } from "../attempt-view";
-import { type Deprecated, RunDeprecations } from "../deprecations";
 import { checkEvent, eventIdProblem, replyRecord } from "../emit";
 import { messageOf } from "../errors";
-import { appendMailbox, foldMailbox, RunParked, readMailbox } from "../mailbox";
+import { isInside } from "../files";
+import { appendIn, readIn } from "../in-lines";
 import { OPERATOR_ALIASES } from "../operator-aliases";
-import {
-  createRun,
-  idProblem,
-  readEvents,
-  readStageRecords,
-  readTurns,
-  writeStageRecord,
-} from "../runs";
-import { primaryFailure, WorkflowStopped } from "../stopped";
+import { type EarlierOps, listOps } from "../ops";
+import { KEEP_PANES } from "../pane-layout";
+import { claimRunLines, type RunLines, readRunLines, runLinesFile } from "../run-lines";
+import type { TimerState } from "../run-policy/waits";
+import { createRun, idProblem, readEvents, readTurns } from "../runs";
+import { primaryFailure, type WorkflowStopped } from "../stopped";
+import { RunParked, readWaits } from "../waits";
 import { assertJsonValue, type EventWorkflow } from "../workflow-loader";
 import type { RunnableWorkflow } from "../workflow-runner";
 import { runWorkflow, type SettledRun, WorkflowRunError } from "../workflow-runner";
@@ -112,18 +111,27 @@ type EventOptions<Events extends EventSchemas> = [Events] extends [never]
       events?: readonly ScriptedEvent<Events>[];
     };
 
-/** What an earlier attempt left: given, the test's attempt is that run's continue, attempt 2. */
+/**
+ * What an earlier attempt left: given, the test's attempt is that run's continue, the attempt after
+ * the latest its lines name, attempt 2 when they name none later than 1.
+ */
 export type EarlierAttempt = {
   /**
    * The stages it recorded, by name: each value, or `undefined` for a stage that returns nothing,
-   * reused without calling their work, as `awf run --continue` would.
+   * reused without calling their work, as `awf run --continue` would. Written as attempt 1's
+   * `stage` lines.
    */
   stages?: Readonly<Record<string, JsonValue | undefined>>;
   /**
-   * What it left in the run's mailbox, in order: its events, timers, and what its waits and turns
-   * wrote. A starting `event` is appended after them, as the event that woke it.
+   * The events senders gave the run, its `in.jsonl`, in order. A starting `event` is appended
+   * after them, as the event that woke it.
+   */
+  events?: readonly EventLine[];
+  /**
+   * What the run settled, its `run.jsonl` lines, in order, after `stages`: its timers, what its
+   * waits and races took, and the turns it began, as `run.run` gives them.
    */
-  mailbox?: readonly MailboxRecord[];
+  run?: readonly RunLine[];
 };
 
 type CommonTestOptions = {
@@ -161,12 +169,8 @@ type CommonTestOptions = {
   runtimes?: RuntimeAliases;
   /** The run's deadline; none unless given, as `awf run` has none unless `--timeout` gives one. */
   timeout?: Duration;
-  /** @deprecated Give `timeout`, a `Duration` such as `"5m"`. */
-  timeoutMs?: number;
   /** Real time with no turn or decision starting or ending before the test fails; `"2s"`. */
   stall?: Duration;
-  /** @deprecated Give `stall`, a `Duration` such as `"2s"`. */
-  stallMs?: number;
   /**
    * The run's clock is virtual: where a run would park with a timer to come, the clock moves to it
    * and the timer fires, so a two-day reminder takes no time. After this many, the run parks
@@ -190,10 +194,6 @@ type CommonTestOptions = {
   maxTurns?: number;
   /** What an earlier attempt left; given, the test's attempt is its continue. */
   earlier?: EarlierAttempt;
-  /** @deprecated Give `earlier: { stages }`. */
-  recorded?: Readonly<Record<string, JsonValue | undefined>>;
-  /** @deprecated Give `earlier: { mailbox }`. */
-  mailbox?: readonly MailboxRecord[];
   /**
    * The stage the attempt starts at, as `--from-stage`: a continue of `earlier`, or a new run
    * started there. A workflow with events takes it only with `earlier`, as `awf run` takes it only
@@ -205,6 +205,12 @@ type CommonTestOptions = {
    * a workflow with events takes none.
    */
   values?: Readonly<Record<string, JsonValue>>;
+  /**
+   * Where the run's TUI agents' panes go and whether they stay, as `awf run --workspace` and
+   * `--keep-panes` give them: `run.agents` shows what each agent's host was asked. Absent, the
+   * run's workspace, and no pane kept.
+   */
+  panes?: RunPanes;
 };
 
 /** Every option a test may give, whatever its workflow's args and events: what the run reads. */
@@ -234,54 +240,34 @@ const OPTION_KEYS: readonly (keyof AnyTestOptions)[] = [
   "earlier",
   "fromStage",
   "values",
+  "panes",
   "event",
   "events",
 ];
-/** Taken, logged, until story 039's last task removes them; never suggested. */
-const DEPRECATED_KEYS: readonly (keyof AnyTestOptions)[] = [
-  "timeoutMs",
-  "stallMs",
-  "recorded",
-  "mailbox",
-];
-const EARLIER_KEYS: readonly (keyof EarlierAttempt)[] = ["stages", "mailbox"];
+const EARLIER_KEYS: readonly (keyof EarlierAttempt)[] = ["stages", "events", "run"];
 
 /**
- * A test's options as `testWorkflow` was called: `(workflow, options?)`, or the deprecated
- * `(workflow, args, options)`. Three arguments are always the deprecated form. With two, the second
- * is the options when it is an object, and args otherwise (`null`, a string, a number, a boolean or
- * an array), so a workflow's object args are never taken for args there: they are read as options,
- * and refused by their first key.
+ * A test's options as `testWorkflow` was called, `(workflow, options?)`: a workflow's args given
+ * second, or options third, are refused, naming `{ args }`; object args given second are named by
+ * their first key.
  */
-export function testCall(
-  workflow: unknown,
-  given: readonly unknown[],
-): { options: AnyTestOptions; used: Deprecated[] } {
-  const deprecatedForm =
-    given.length >= 2 || (given.length === 1 && given[0] !== undefined && !isObject(given[0]));
-  if (!deprecatedForm) {
-    const options = plainOptions(given[0] ?? {});
-    // Object args given second are named by their key, whatever the workflow is.
-    const problem = optionsProblem(
-      options,
-      isEventWorkflow(workflow),
-      (workflow as { meta?: { name?: string } } | null)?.meta?.name ?? "the workflow",
+export function testCall(workflow: unknown, given: readonly unknown[]): AnyTestOptions {
+  if (given.length > 1)
+    throw new Error(
+      "testWorkflow takes (workflow, options?): give args among the options, testWorkflow(workflow, { args, … })",
     );
-    if (problem) throw new Error(problem);
-    if (!isWorkflow(workflow))
-      throw new Error(
-        "testWorkflow(workflow, options?) tests a workflow defineWorkflow made: define it with defineWorkflow",
-      );
-    return { options, used: [] };
-  }
-  // The args-second form never existed for a workflow with events: refused, not deprecated.
-  if (isEventWorkflow(workflow))
-    throw new Error("a workflow with events is tested as testWorkflow(workflow, { id, event? })");
-  const [args, optionsGiven = {}] = given;
-  const options = plainOptions(optionsGiven);
-  if ("args" in options)
-    throw new Error("args are given once: testWorkflow(workflow, { args, … }) is the one form");
-  return { options: { ...options, args: args as JsonValue }, used: ["test-args"] };
+  const options = plainOptions(given[0] === undefined ? {} : given[0]);
+  const problem = optionsProblem(
+    options,
+    isEventWorkflow(workflow),
+    (workflow as { meta?: { name?: string } } | null)?.meta?.name ?? "the workflow",
+  );
+  if (problem) throw new Error(problem);
+  if (!isWorkflow(workflow))
+    throw new Error(
+      "testWorkflow(workflow, options?) tests a workflow defineWorkflow made: define it with defineWorkflow",
+    );
+  return options;
 }
 
 function isObject(value: unknown): value is AnyTestOptions {
@@ -320,56 +306,58 @@ function optionsProblem(
   name: string,
 ): string | undefined {
   for (const key of Object.keys(options) as (keyof AnyTestOptions)[]) {
-    if (!OPTION_KEYS.includes(key) && !DEPRECATED_KEYS.includes(key))
+    if (!OPTION_KEYS.includes(key))
       return `testWorkflow has no option ${JSON.stringify(key)}: its options are ${OPTION_KEYS.join(", ")}${
         "args" in options ? "" : "; a workflow's args are given as { args }"
       }`;
     if (!withEvents && (key === "event" || key === "events"))
       return `${key} is an option for a workflow with events, and ${name} declares none`;
   }
+  const panes = panesProblem(options.panes);
+  if (panes) return panes;
   const { earlier } = options;
   if (earlier === undefined) return undefined;
-  if (!isObject(earlier)) return "earlier is an object: { stages?, mailbox? }";
+  if (!isObject(earlier)) return "earlier is an object: { stages?, events?, run? }";
   const unknown = Object.keys(earlier).find(
     (key) => !EARLIER_KEYS.includes(key as keyof EarlierAttempt),
   );
   return unknown === undefined
     ? undefined
-    : `earlier has no ${JSON.stringify(unknown)}: it gives ${EARLIER_KEYS.join(" and ")}`;
+    : `earlier has no ${JSON.stringify(unknown)}: it gives ${EARLIER_KEYS.join(", ")}`;
+}
+
+/** Why `panes` isn't what `awf run --workspace` and `--keep-panes` could give; undefined when it is. */
+function panesProblem(panes: unknown): string | undefined {
+  if (panes === undefined) return undefined;
+  if (!isObject(panes)) return "panes is an object: { workspace?, keep? }";
+  const { workspace, keep, ...rest } = panes as Record<string, unknown>;
+  const other = Object.keys(rest)[0];
+  if (other !== undefined) return `panes has no ${JSON.stringify(other)}: it gives workspace, keep`;
+  if (keep !== undefined && !KEEP_PANES.includes(keep as KeepPane))
+    return `panes.keep is ${KEEP_PANES.join(", ")}, not ${JSON.stringify(keep)}`;
+  const named =
+    isObject(workspace) &&
+    Object.keys(workspace).join() === "name" &&
+    typeof (workspace as { name?: unknown }).name === "string" &&
+    (workspace as { name: string }).name.trim() !== "";
+  if (workspace !== undefined && workspace !== "run" && workspace !== "origin" && !named)
+    return `panes.workspace is "run", "origin" or { name }, not ${JSON.stringify(workspace)}`;
+  return undefined;
 }
 
 /** What a test of the engine, not of a workflow, may give `runTest`. */
-export type EngineTestOptions = {
+type EngineTestOptions = {
   /**
    * Where an agent may `--await-reply`: `listed`, where the engine's list allows it for the
    * agent's harness and placement, as a run would; `anywhere`, on any harness, the fake's included.
    */
   awaitReply?: "listed" | "anywhere";
-  /** Deprecated forms the call itself used, logged with the run's own. */
-  used?: readonly Deprecated[];
 };
 
-/**
- * A test's length of time in milliseconds: `field`, a `Duration`, or `old`, its deprecated form in
- * milliseconds, which is reported; both at once are refused.
- */
-function milliseconds(
-  options: AnyTestOptions,
-  field: "timeout" | "stall",
-  old: "timeoutMs" | "stallMs",
-  deprecated: () => void,
-): number | undefined {
+/** A test's length of time in milliseconds, a `Duration` checked; undefined when not given. */
+function milliseconds(options: AnyTestOptions, field: "timeout" | "stall"): number | undefined {
   const given = options[field];
-  const ms = options[old];
-  if (given != null) {
-    if (ms != null) throw new Error(`give ${field} alone: ${old} is its deprecated form`);
-    return positiveDurationMilliseconds(given, `a test's ${field}`);
-  }
-  if (ms == null) return undefined;
-  if (!Number.isSafeInteger(ms) || ms <= 0)
-    throw new Error(`a test's ${old} is a positive whole number of milliseconds: not ${ms}`);
-  deprecated();
-  return ms;
+  return given == null ? undefined : positiveDurationMilliseconds(given, `a test's ${field}`);
 }
 
 /** A file's contents, or a directory of them by name. */
@@ -382,41 +370,24 @@ const WAITED_OUT = "the test ended the attempt: everything left waited on a part
 
 /**
  * An event a test sends while the run goes on, at an agent's `n`th turn, `"{agent}#{n}"`: `during`
- * it, or `after` it has ended, once the run waits live in an agent's `keepAlive` window.
+ * it, or `after` it has ended, once the run waits live in an agent's `keepAlive` window. `n` counts
+ * the agent's turns in the test, a nudge's included, and not its compactions: not the `n` of its
+ * operation's id, `{agent}.{n}`, which counts each operation once and its compactions too.
  */
 export type ScriptedEvent<Events extends EventSchemas> = (
   | { during: string; after?: undefined }
   | { after: string; during?: undefined }
 ) &
   EventIds &
-  (
-    | {
-        [Name in Exclude<keyof Events & string, `${string}:ended`>]: {
-          name: Name;
-          data: OutputOf<Events[Name]>;
-        };
-      }[Exclude<keyof Events & string, `${string}:ended`>]
-    /**
-     * A reply on a participant routed to the code with `to: "code"`; awf fills its author and id
-     * when absent.
-     *
-     * @deprecated Declare `{key}:reply: ParticipantReply` and script `{ name: "{key}:reply", data }`.
-     */
-    | { name: "participant:reply"; from: string; data: ParticipantReply }
-  );
-
-/** An event's id in the run's mailbox, as `awf emit --event-id` gives it. */
-type EventIds = {
-  eventId?: string;
-  /** @deprecated Give it as `eventId`. */
-  id?: string;
-};
+  {
+    [Name in Exclude<keyof Events & string, `${string}:ended`>]: {
+      name: Name;
+      data: OutputOf<Events[Name]>;
+    };
+  }[Exclude<keyof Events & string, `${string}:ended`>];
 
-/** @deprecated Use `TestOptions<Args, Events>`, the one options type. */
-export type EventTestOptions<
-  Events extends EventSchemas,
-  Args extends JsonValue = JsonValue,
-> = TestOptions<Args, Events>;
+/** An event's id in the run's `in.jsonl`, as `awf emit --event-id` gives it. */
+type EventIds = { eventId?: string };
 
 /** An event the run sent, to the run whose ref is `ref`, which a test doesn't start. */
 export type EmittedEvent = { ref: string; name: string; data: JsonValue; eventId?: string };
@@ -450,35 +421,29 @@ export type TestRun<Result> = {
   decisions: DecisionRequest[];
   logs: { message: string; fields?: JsonObject }[];
   /**
-   * Each stage's record in the order entered, as the run wrote it to disk: sessions, times and
-   * reason included, which the run's own summaries leave out.
+   * Each stage the attempt entered, in order, by its line in `run.jsonl`: one it ran or was given
+   * its own, times and reason included, which the run's own summaries leave out; one it reused the
+   * line it reused, an earlier attempt's. A stage the plan stopped as it was entered wrote none, and
+   * is absent.
    */
-  stages: StageRecord[];
+  stages: StageLine[];
   /**
    * How the attempt ended, as the workflow's `present` and `report` are given it: `completed` with
    * its value, `parked` at its last wait, or `stopped`, `failed`, `timed-out` or `cancelled` with
    * the stage it ended in and why.
    */
   ending: Ending<Result>;
-  /**
-   * @deprecated Read `run.ending`, whose kind is `"stopped"`. How the attempt stopped, and the
-   * values it stopped for; absent when it didn't.
-   */
-  readonly stopped?: { reason: string; stage?: string; needs?: readonly StageNeed[] };
   /** Every event the run sent to another workflow, in order. */
   emits: EmittedEvent[];
-  /**
-   * @deprecated Read `run.ending`, whose kind is `"parked"`. A run that parked, and its last wait;
-   * absent when it returned.
-   */
-  readonly parked?: { label?: string; until?: string };
   /** The run's timers in the order set: when each was due, and whether it fired or was cancelled. */
   timers: { name: string; due: string; state: "fired" | "cancelled" | "pending" }[];
+  /** The events senders gave the run, its `in.jsonl` as the run left it, in order. */
+  events: EventLine[];
   /**
-   * Its mailbox as the run left it: its events, timers, and what its waits and turns wrote, in
-   * order; a plain run's holds its timers alone.
+   * What the run settled, its `run.jsonl` as the run left it, in order: each attempt's `claimed`,
+   * and its stages, timers, sessions, what its waits and races took, and the turns it began.
    */
-  mailbox: MailboxRecord[];
+  run: RunLine[];
 };
 
 /**
@@ -495,11 +460,7 @@ export async function runTest<Result extends JsonValue>(
   const problem = optionsProblem(options, withEvents !== undefined, workflow.meta.name);
   if (problem) throw new Error(problem);
   const logs: TestRun<Result>["logs"] = [];
-  // A test's own forms, apart from the run's: said in its logs as the run says a warning.
-  const deprecations = new RunDeprecations((message) => logs.push({ message }));
-  const deprecated = (name: Deprecated) => deprecations.used(name);
-  for (const name of engine.used ?? []) deprecated(name);
-  const earlier = earlierOf(options, deprecated);
+  const earlier = earlierOf(options);
   if (withEvents && options.values !== undefined)
     throw new Error(
       "a run of a workflow with events takes no values: before fromStage, a stage with no record runs",
@@ -508,7 +469,7 @@ export async function runTest<Result extends JsonValue>(
     throw new Error(
       "a run of a workflow with events takes fromStage only with earlier, as awf run takes --from-stage only with --continue",
     );
-  const started = startOf(withEvents, options, deprecated);
+  const started = startOf(withEvents, options);
   const definition = workflow as RunnableWorkflow<JsonValue, Result>;
   const scripts = new Scripts(options.agents);
   const compactionScripts = new Scripts(options.compactions, {
@@ -521,11 +482,8 @@ export async function runTest<Result extends JsonValue>(
   }
   const stopping = new AbortController();
   const problems: string[] = [];
-  const stallMs =
-    milliseconds(options, "stall", "stallMs", () => deprecations.used("stall-ms")) ?? 2_000;
-  const timeoutMs = milliseconds(options, "timeout", "timeoutMs", () =>
-    deprecations.used("timeout-ms", "in testWorkflow's options"),
-  );
+  const stallMs = milliseconds(options, "stall") ?? 2_000;
+  const timeoutMs = milliseconds(options, "timeout");
   let stall: ReturnType<typeof setTimeout> | undefined;
   /** The test ended the attempt: everything left waited on a coordinator's script. */
   let waitedOut = false;
@@ -576,8 +534,7 @@ export async function runTest<Result extends JsonValue>(
     events.onActivity();
     return true;
   };
-  const scripted =
-    withEvents && new ScriptedEvents(withEvents, options, earlier.mailbox ?? [], now, deprecated);
+  const scripted = withEvents && new ScriptedEvents(withEvents, options, earlier.events ?? [], now);
   const maxTurns = options.maxTurns ?? 20;
   if (!Number.isInteger(maxTurns) || maxTurns < 1)
     throw new Error(`maxTurns is a whole number of turns, at least 1, not ${options.maxTurns}`);
@@ -588,7 +545,6 @@ export async function runTest<Result extends JsonValue>(
   const events = {
     onActivity: () => arm(stallMs),
     onScriptError: (message: string) => stopWith(message),
-    onDeprecated: (name: Deprecated, subject?: string) => deprecations.used(name, subject),
     onTurnStarted: async (turn: TestTurn) => {
       turnsStarted += 1;
       if (turnsStarted > maxTurns)
@@ -597,11 +553,13 @@ export async function runTest<Result extends JsonValue>(
         );
       const due = scripted ? scripted.due(turn) : [];
       if (due.length === 0) return;
-      for (const record of due) await appendMailbox(run.dir, record);
+      for (const line of due) await appendIn(run.dir, line);
       nudge?.();
     },
   };
-  const attempt = earlier.continues ? 2 : 1;
+  const attempt = earlier.continues
+    ? Math.max(1, ...(earlier.run ?? []).map((line) => line.attempt)) + 1
+    : 1;
   const coordinators = new ParticipantScripts(options.participants, attempt, events);
   const stopWith = (message: string) => {
     problems.push(message);
@@ -650,8 +608,10 @@ export async function runTest<Result extends JsonValue>(
   };
   let sandboxOf = new Map<string, AgentSandbox>();
   const emits: EmittedEvent[] = [];
-  let mailbox: MailboxRecord[] = [];
-  let stages: StageRecord[] = [];
+  let inLines: EventLine[] = [];
+  let runLines: RunLine[] = [];
+  let timers: TestRun<Result>["timers"] = [];
+  let stages: StageLine[] = [];
   let messages: (MessageRecord & { to: string })[] = [];
   const runRoot = directory();
   const deadline =
@@ -666,15 +626,28 @@ export async function runTest<Result extends JsonValue>(
     for (const path of temporary) rmSync(path, { recursive: true, force: true });
     throw error;
   });
-  if (earlier.stages) await recordEarlierAttempt(run.dir, earlier.stages);
-  for (const record of earlier.mailbox ?? []) await appendMailbox(run.dir, record);
-  if (started.record) await appendMailbox(run.dir, started.record);
+  let lines: RunLines;
+  let ops: EarlierOps;
+  try {
+    if (earlier.stages) await recordEarlierAttempt(run.dir, earlier.stages);
+    if (earlier.run) await writeEarlierLines(run.dir, earlier.run);
+    for (const line of earlier.events ?? []) await appendIn(run.dir, line);
+    if (started.record) await appendIn(run.dir, started.record);
+    ops = await listOps(run.dir);
+    lines = await claimRunLines(run.dir, attempt, new Date(now()).toISOString());
+  } catch (error) {
+    for (const path of temporary) rmSync(path, { recursive: true, force: true });
+    throw error;
+  }
   const recordedStages = async ({ stages: entered = [] }: SettledRun) => {
-    const records = await readStageRecords(run.dir);
-    // A stage the plan stopped has no record of this attempt's: the one there is an earlier one's.
-    return entered.flatMap(({ stage, attempt }) => {
-      const record = records.get(stage);
-      return record?.attempt === attempt ? [record] : [];
+    const { view } = await readRunLines(run.dir);
+    // The run's summaries hold one entry per stage, as it last stood: a stage by content that
+    // failed and ran again in this attempt is one entry, its latest line. So each entry's line is
+    // the latest its attempt wrote: a stage this attempt ran or was given has its own, a reused one
+    // the line it reused. A stage the plan stopped wrote none.
+    return entered.flatMap(({ stage, attempt: wrote }) => {
+      const line = view.stages[stage]?.history.findLast((each) => each.attempt === wrote);
+      return line ? [line] : [];
     });
   };
   events.onActivity();
@@ -694,8 +667,10 @@ export async function runTest<Result extends JsonValue>(
       run: {
         dir: run.dir,
         id: run.record.id,
-        attempt,
+        lines,
+        ops,
         ...(options.fromStage === undefined ? {} : { fromStage: options.fromStage }),
+        ...(options.panes === undefined ? {} : { panes: options.panes }),
         ...(options.values === undefined
           ? {}
           : { values: new Map(Object.entries(options.values)) }),
@@ -707,7 +682,7 @@ export async function runTest<Result extends JsonValue>(
               live: async (until: number) => {
                 liveUntil = until;
                 const due = scripted.ended(host.inFlight());
-                for (const record of due) await appendMailbox(run.dir, record);
+                for (const line of due) await appendIn(run.dir, line);
                 if (due.length > 0) nudge?.();
               },
               listenNudges: (given: () => void) => {
@@ -737,11 +712,8 @@ export async function runTest<Result extends JsonValue>(
         },
         sandboxesDir: directory(),
         machineRoot: directory(),
-        // A sandbox here launches nothing, so no harness's login is needed: a stand-in for each.
-        environment: {
-          ...process.env,
-          ...Object.fromEntries(sandboxTokens().map((name) => [name, "workflow-test"])),
-        },
+        // An agent here launches nothing, so it needs no harness's executable or login.
+        homes: SCRIPTED_HOMES,
       },
       decisions: {
         providers: { scripted: decisions.provider },
@@ -777,7 +749,9 @@ export async function runTest<Result extends JsonValue>(
     }
     host.settle(await readTurns(run.dir));
     messages = await messagesIn(run.dir);
-    mailbox = await readMailbox(run.dir);
+    inLines = await readIn(run.dir);
+    runLines = (await readRunLines(run.dir)).lines;
+    timers = timersOf((await readWaits(run.dir, now())).timers);
     for (const path of temporary) rmSync(path, { recursive: true, force: true });
   }
   if (problems.length === 0 && scripted) problems.push(...scripted.unsent(host.inFlight()));
@@ -827,9 +801,7 @@ export async function runTest<Result extends JsonValue>(
             continue: goOn(undefined, decided.stages),
           }
         : decided;
-  const stopped = stoppedOf(settled);
-  const parked = parkedOf(settled);
-  const result: TestRun<Result> = {
+  return {
     get value() {
       if ("value" in settled) return settled.value;
       if (primaryFailure(settled.error) instanceof RunParked)
@@ -842,7 +814,8 @@ export async function runTest<Result extends JsonValue>(
     },
     turns: host.turns,
     emits,
-    mailbox,
+    events: inLines,
+    run: runLines,
     turnsOf: (agent) => host.turns.filter((turn) => turn.agent === agent),
     compactions: host.compactions,
     compactionsOf: (agent) => host.compactions.filter((compaction) => compaction.agent === agent),
@@ -860,32 +833,17 @@ export async function runTest<Result extends JsonValue>(
     decisions: decisions.asked,
     logs,
     stages,
-    timers: timersOf(mailbox),
+    timers,
     ending,
   };
-  // Not enumerable, so spreading the run reads neither.
-  Object.defineProperties(result, {
-    stopped: {
-      get: () => {
-        deprecated("run-stopped");
-        return stopped;
-      },
-    },
-    parked: {
-      get: () => {
-        deprecated("run-parked");
-        return parked;
-      },
-    },
-  });
-  return result;
 }
 
-function timersOf(records: readonly MailboxRecord[]): TestRun<unknown>["timers"] {
-  return [...foldMailbox(records).timers.values()].map(({ name, due, fired, cancelled }) => ({
+/** Each timer: taken, or due by the run's clock and not cancelled, is `fired`. */
+function timersOf(timers: ReadonlyMap<string, TimerState>): TestRun<unknown>["timers"] {
+  return [...timers.values()].map(({ name, due, taken, fired, cancelled }) => ({
     name,
     due,
-    state: fired ? "fired" : cancelled ? "cancelled" : "pending",
+    state: taken ? "fired" : cancelled ? "cancelled" : fired ? "fired" : "pending",
   }));
 }
 
@@ -940,36 +898,52 @@ async function messagesIn(dir: string): Promise<(MessageRecord & { to: string })
 }
 
 /**
- * Writes `recorded` as attempt 1's succeeded stages into a run's folder, a second apart in the order
- * given: a continue orders what is recorded by when each stage started.
+ * Writes `recorded` as attempt 1's succeeded stage lines into a run's `run.jsonl`, after attempt 1's
+ * claim, a second apart in the order given: a continue orders what is recorded by when each stage
+ * started.
  */
 async function recordEarlierAttempt(
   dir: string,
   recorded: Readonly<Record<string, JsonValue | undefined>>,
 ): Promise<void> {
   let at = Date.now() - Object.keys(recorded).length * 1_000;
-  for (const [stage, value] of Object.entries(recorded)) {
+  const lines = await claimRunLines(dir, 1, new Date(at - 1_000).toISOString());
+  for (const [name, value] of Object.entries(recorded)) {
     const time = new Date(at).toISOString();
     at += 1_000;
-    await writeStageRecord(dir, {
-      version: STAGE_RECORD_VERSION,
-      stage,
+    await lines.append({
+      kind: "stage",
       attempt: 1,
+      at: time,
+      name,
       outcome: "succeeded",
       started: time,
-      ended: time,
-      sessions: [],
       ...(value === undefined ? {} : { value }),
     });
   }
 }
 
+/**
+ * Writes `lines`, what an earlier attempt settled, into the run's `run.jsonl` as given, once
+ * `readRun` takes them: the test's claim comes after them.
+ */
+async function writeEarlierLines(dir: string, lines: readonly RunLine[]): Promise<void> {
+  try {
+    readRun(lines);
+  } catch (error) {
+    throw new Error(`earlier.run: ${messageOf(error)}`);
+  }
+  await appendFile(runLinesFile(dir), lines.map((line) => `${JSON.stringify(line)}\n`).join(""), {
+    mode: 0o600,
+  });
+}
+
 /** An event a test sends while its run goes on, once its turn begins. */
 type PendingEvent = {
   at: string;
   after: boolean;
   name: string;
-  record: MailboxRecord;
+  record: EventLine;
   /** Its turn, once begun: an `after` event waits for it to end. */
   turn?: TestTurn;
 };
@@ -981,11 +955,10 @@ class ScriptedEvents {
   constructor(
     workflow: EventWorkflow,
     options: AnyTestOptions,
-    /** What the earlier attempt left in the mailbox, whose event ids are taken. */
-    earlier: readonly MailboxRecord[],
+    /** The events the earlier attempt left, whose ids are taken. */
+    earlier: readonly EventLine[],
     /** The run's clock, which stamps what is sent. */
     private readonly now: () => number,
-    deprecated: (name: Deprecated) => void,
   ) {
     const ids = new Set<string>();
     const idOf = (given: string | undefined, made: string) => {
@@ -998,8 +971,8 @@ class ScriptedEvents {
       ids.add(id);
       return id;
     };
-    for (const record of earlier) if (record.kind === "event") ids.add(record.id);
-    if (options.event) idOf(eventIdOf(options.event, deprecated), `${AWF_ID_PREFIX}start`);
+    for (const line of earlier) ids.add(line.id);
+    if (options.event) idOf(options.event.eventId, `${AWF_ID_PREFIX}start`);
     this.#pending = (options.events ?? []).map((event, index) => {
       if ((event.during === undefined) === (event.after === undefined))
         throw new Error("a scripted event gives during or after, one of them");
@@ -1009,7 +982,7 @@ class ScriptedEvents {
         throw new Error(
           `a scripted event's ${after ? "after" : "during"} is "{agent}#{n}", an agent's nth turn, not ${at}`,
         );
-      const id = idOf(eventIdOf(event, deprecated), `${AWF_ID_PREFIX}test.${index + 1}`);
+      const id = idOf(event.eventId, `${AWF_ID_PREFIX}test.${index + 1}`);
       // A participant's reply is recorded as `awf emit` records one, whatever name it is sent by.
       const stamped = new Date().toISOString();
       let sent = {
@@ -1020,11 +993,7 @@ class ScriptedEvents {
         at: stamped,
       };
       const reply = awfEventOf(event.name);
-      if (event.name === "participant:reply") {
-        deprecated("test-participant-reply");
-        const old = event as { from: string; data: ParticipantReply };
-        sent = replyRecord(old.from, id, { author: "engineer", ...old.data }, stamped);
-      } else if (reply?.kind === "reply") {
+      if (reply?.kind === "reply") {
         checkEvent(workflow, event, true);
         sent = replyRecord(reply.key, id, event.data, stamped);
       } else checkEvent(workflow, event);
@@ -1032,24 +1001,24 @@ class ScriptedEvents {
         at,
         after,
         name: event.name,
-        record: { version: MAILBOX_RECORD_VERSION, kind: "event", ...sent },
+        record: sent,
       };
     });
   }
 
   /** The events due during `turn`, taken off the list, stamped now; those after it wait for it. */
-  due(turn: TestTurn): MailboxRecord[] {
+  due(turn: TestTurn): EventLine[] {
     const at = `${turn.agent}#${turn.n}`;
     for (const each of this.#pending) if (each.after && each.at === at) each.turn = turn;
     return this.#take((each) => !each.after && each.at === at);
   }
 
   /** The run waits live: the events after a turn that has ended, taken off the list. */
-  ended(inFlight: readonly TestTurn[]): MailboxRecord[] {
+  ended(inFlight: readonly TestTurn[]): EventLine[] {
     return this.#take((each) => each.turn !== undefined && !inFlight.includes(each.turn));
   }
 
-  #take(which: (each: PendingEvent) => boolean): MailboxRecord[] {
+  #take(which: (each: PendingEvent) => boolean): EventLine[] {
     const due = this.#pending.filter(which);
     for (const each of due) this.#pending.splice(this.#pending.indexOf(each), 1);
     return due.map((each) => ({ ...each.record, at: new Date(this.now()).toISOString() }));
@@ -1085,7 +1054,7 @@ async function layOut(
   for (const [path, tree] of Object.entries(files ?? {})) {
     // Under the test's own directory, which it removes: a path outside would be left behind.
     const target = resolve(cwd, path);
-    if (isAbsolute(path) || relative(cwd, target).startsWith(".."))
+    if (isAbsolute(path) || (relative(cwd, target) !== "" && !isInside(cwd, target)))
       throw new Error(`files lays out under the run's directory; ${path} is outside it`);
     await write(target, tree);
   }
@@ -1098,8 +1067,7 @@ async function layOut(
 function startOf(
   workflow: EventWorkflow | undefined,
   options: AnyTestOptions,
-  deprecated: (name: Deprecated) => void,
-): { id: string; record?: MailboxRecord } {
+): { id: string; record?: EventLine } {
   const { event, id = "test" } = options;
   if (typeof id !== "string") throw new Error(`a run's id is a string, not ${JSON.stringify(id)}`);
   const problem = idProblem(id);
@@ -1111,11 +1079,9 @@ function startOf(
     throw new Error(
       `${event.name} doesn't start a run of ${workflow.meta.name}: its starts are ${starts.join(", ")}`,
     );
-  const record = {
-    version: MAILBOX_RECORD_VERSION,
+  const record: EventLine = {
     at: new Date().toISOString(),
-    kind: "event" as const,
-    id: eventIdOf(event, deprecated) ?? `${AWF_ID_PREFIX}start`,
+    id: event.eventId ?? `${AWF_ID_PREFIX}start`,
     name: event.name,
     data: event.data,
     from: "operator",
@@ -1124,32 +1090,9 @@ function startOf(
   return { id, record };
 }
 
-/**
- * What the earlier attempt left, from `earlier` or its deprecated forms, `recorded` and `mailbox`;
- * `continues` when it left anything, so the test's attempt is attempt 2.
- */
-function earlierOf(
-  options: AnyTestOptions,
-  deprecated: (name: Deprecated) => void,
-): EarlierAttempt & { continues: boolean } {
-  const { earlier = {}, recorded, mailbox } = options;
-  if (recorded !== undefined) {
-    if (earlier.stages !== undefined)
-      throw new Error("give earlier.stages alone: recorded is its deprecated form");
-    deprecated("test-recorded");
-  }
-  if (mailbox !== undefined) {
-    if (earlier.mailbox !== undefined)
-      throw new Error("give earlier.mailbox alone: mailbox is its deprecated form");
-    deprecated("test-mailbox");
-  }
-  const stages = earlier.stages ?? recorded;
-  const left = earlier.mailbox ?? mailbox;
-  return {
-    ...(stages === undefined ? {} : { stages }),
-    ...(left === undefined ? {} : { mailbox: left }),
-    continues: options.earlier !== undefined || stages !== undefined || left !== undefined,
-  };
+/** What the earlier attempt left; `continues` when `earlier` is given: the test's is a continue. */
+function earlierOf(options: AnyTestOptions): EarlierAttempt & { continues: boolean } {
+  return { ...options.earlier, continues: options.earlier !== undefined };
 }
 
 /**
@@ -1176,15 +1119,6 @@ function argsOf(
   }
 }
 
-/** An event's id, given as `eventId` or, deprecated, `id`. */
-function eventIdOf(event: EventIds, deprecated: (name: Deprecated) => void): string | undefined {
-  if (event.id === undefined) return event.eventId;
-  deprecated("test-event-id");
-  if (event.eventId !== undefined && event.eventId !== event.id)
-    throw new Error(`an event gives eventId ${event.eventId} and id ${event.id}: give eventId`);
-  return event.id;
-}
-
 function sandboxesOf(sandboxes: readonly SandboxRecord[] | undefined): Map<string, AgentSandbox> {
   return new Map(
     (sandboxes ?? []).flatMap(({ key, provider, spec, domains, agents }) =>
@@ -1192,22 +1126,3 @@ function sandboxesOf(sandboxes: readonly SandboxRecord[] | undefined): Map<strin
     ),
   );
 }
-
-/** A run that parked, and its last wait: what the attempt ended with. */
-function parkedOf(settled: { value: unknown } | { error: unknown }): TestRun<unknown>["parked"] {
-  if (!("error" in settled)) return undefined;
-  const parked = primaryFailure(settled.error);
-  return parked instanceof RunParked ? parked.wait : undefined;
-}
-
-/** Decided as `awf run` decides it: a stop is the run's first failure, whatever failed beside it. */
-function stoppedOf(settled: { value: unknown } | { error: unknown }): TestRun<unknown>["stopped"] {
-  if (!("error" in settled)) return undefined;
-  const stop = primaryFailure(settled.error);
-  if (!(stop instanceof WorkflowStopped)) return undefined;
-  return {
-    reason: stop.reason,
-    ...(stop.stage === undefined ? {} : { stage: stop.stage }),
-    ...(stop.needs === undefined ? {} : { needs: stop.needs }),
-  };
-}