@agentswf/engine 0.1.0-beta.4 → 0.1.0

package/src/workflow-runner.ts

@@ -10,9 +10,12 @@ import {
   RESERVED_PARTICIPANT_KEYS,
 } from "@agentswf/contract/participant";
 import type {
+  AgentOp,
   AgentPaneRecord,
   AgentSkillsRecord,
   RunAccounting,
+  RunPanes,
+  RunView,
   SandboxRecord,
   SettledDecision,
   SettledOperation,
@@ -31,7 +34,8 @@ import {
 } from "@agentswf/contract/schema";
 import {
   type AbsoluteDeadline,
-  type AgentEndedEvent,
+  type AgentEnded,
+  type AgentEndOf,
   type AgentExecution,
   type AgentForkSpec,
   type AgentKey,
@@ -40,42 +44,49 @@ import {
   type AgentRunStructuredSpec,
   type AgentRunTextSpec,
   type AgentStartSpec,
+  awfEventOf,
   type Branches,
-  type CodeParticipantRef,
+  type CallerForkSpec,
   type CompactionId,
   type CompactSpec,
   DeadlineExceededError,
   type Duration,
+  durationMilliseconds,
   type EmitOutcome,
-  type EventAgentOpenSpec,
-  type EventAgentRef,
+  type EventLike,
+  type ForkRuntime,
   type HarnessAllowance,
+  type HarnessKind,
   isEventWorkflow,
   isJsonValue,
   type JsonObject,
   type JsonValue,
   type KeepPane,
-  type Matched,
   type MessageAccess,
+  type NativeSessionRef,
   type Next,
   nameProblem,
   type OperationRecord,
   type OutputSchema,
   type PaneLayout,
+  type PaneSpec,
+  type ParticipantDirectory,
   type ParticipantRef,
   type ParticipantSpec,
   type PlacementChoice,
   placementOf,
+  positiveDurationMilliseconds,
   type RaceBranches,
-  type ReceiveOptions,
   type RunResult,
   type RuntimeSelection,
-  type SelectOptions,
   type SettingsSpec,
   type SkillSource,
+  type Source,
   type StageOptions,
   type StageSummary,
   type StartedTurn,
+  type Taken,
+  type Timeout,
   type TimeRead,
   type Timer,
   type TurnId,
@@ -83,8 +94,8 @@ import {
   type WaitOptions,
   type When,
   type WorkflowContext,
-  type WorkflowDefinition,
   type WorkflowEvent,
+  type WorkflowMeta,
 } from "@agentswf/contract/workflow";
 import {
   type AgentSkills,
@@ -92,7 +103,8 @@ import {
   findHarness,
   HARNESS_NAMES,
   type Harness,
-  hostHome,
+  type HarnessHomes,
+  OPERATOR_HOMES,
   settingsRefusal,
   skillsLayout,
 } from "@agentswf/harness";
@@ -121,7 +133,7 @@ import {
 import type { CoordinatorPort } from "./coordinator-port";
 import {
   assertDeadline,
-  assertDeadlineValue,
+  boundedDeadline,
   deadlineWithin,
   earlierDeadline,
   harnessDeadline,
@@ -142,15 +154,6 @@ import {
   inTimeoutHandler,
   type KeepAlive,
 } from "./keep-alive";
-import {
-  AT_DUE,
-  type RestoredTurn,
-  RunMailbox,
-  RunParked,
-  recoverTurns,
-  type TurnEnd,
-  unrunUsage,
-} from "./mailbox";
 import { superviseMessageOperation } from "./message-operation";
 import { canAwaitReply } from "./messaging/limits";
 import type { HolderRequest } from "./messaging/messaging";
@@ -165,9 +168,19 @@ import {
   type SupervisedOutcome,
   superviseOperation,
 } from "./operation-liveness";
-import { besideOf, checkPaneOptions, keepsPane, storedLayout } from "./pane-layout";
+import { type EarlierOps, OpIds, writeScreen } from "./ops";
+import {
+  besideOf,
+  checkPaneOptions,
+  keepsPane,
+  type PaneAsked,
+  paneAsked,
+  storedPane,
+} from "./pane-layout";
 import { createResultSlotRegistry, type ResultSlotRegistry } from "./result-slots";
 import { RunEventLog } from "./run-event-log";
+import { type RunLines, readRunLines } from "./run-lines";
+import { branchOf, matches, type RestoredTurn } from "./run-policy/waits";
 import {
   type AgentProgress,
   type GroupProgress,
@@ -181,7 +194,7 @@ import {
   type OperationTags,
   type RunLedger,
 } from "./run-usage";
-import { endTurnsLine, readStageRecords, readTurns } from "./runs";
+import { endLogLine, readAttempts, workDir } from "./runs";
 import { type CredentialLocks, placeCarried, seedHome } from "./sandbox-homes";
 import {
   RUN_SANDBOX_ONLY,
@@ -189,45 +202,62 @@ import {
   type RunSandboxOptions,
   type SeatedAgent,
 } from "./sandboxes";
+import { SessionLines, type SessionPlace } from "./session-lines";
 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 { asSource, branchValue, isSignal, presented, signalOf, source, takeOf } from "./sources";
+import { keepSpend, settleEarlier } from "./spend";
 import { StageLedger, type StageProgress } from "./stage-ledger";
 import { FromStageUnreached } from "./stopped";
 import { inToolHandler, outsideTools, refusedInTool, ToolCalls, toolsLesson } from "./tools";
+import { unrunUsage } from "./turn-ends";
+import { RunParked, RunWaits, type TurnEnd } from "./waits";
 import type { EventWorkflow } from "./workflow-loader";
 
 export { WorkflowCancelledError } from "./deadlines";
 
+/** What the runner needs of a workflow: its meta and its run. */
+export type RunnableWorkflow<Args extends JsonValue, Result extends JsonValue> = {
+  readonly meta: WorkflowMeta;
+  run(context: WorkflowContext, args: Args): Promise<Result>;
+};
+
 export type RunWorkflowOptions = {
   /** Internal timing policy; workflow authors use the operation deadline. */
   livenessPolicy?: LivenessPolicy;
-  /** A `keepAlive` window that gives no `timeoutMs`; absent, an hour. A test's is short. */
+  /** A `keepAlive` that gives no `window`; absent, an hour. A test's is short. */
   defaultWindowMs?: number;
   /** The run's time, which its timers and `wf.now()` read; absent, the clock's. A test's is virtual. */
   now?: () => number;
+  /** Where the control plane's socket directory is made; `/tmp` unless a test watches its own. */
+  socketRoot?: string;
   runRoot: string;
   /** The run this is an attempt of, whose folder the operator claimed under `runRoot`. */
   run: {
     dir: string;
     id: string;
-    attempt: number;
+    /** The attempt's writer on `run.jsonl`, which its claim made; its `attempt` is this attempt. */
+    lines: RunLines;
+    /** What the claim's listing of `ops/` found: each key's last `n`, numbered on from. */
+    ops: EarlierOps;
     /** How the attempt is named to a person: its Herdr workspace's label. */
     label?: string;
     /** `--from-stage`: the stage this attempt starts at, reusing those before it. */
     fromStage?: string;
     /** `--values`: the values of stages before `fromStage` that have no record to reuse. */
     values?: ReadonlyMap<string, JsonValue>;
+    /** `--workspace` and `--keep-panes`, as the run's record keeps them for every attempt. */
+    panes?: RunPanes;
     /** A run of a workflow with `events`. */
     events?: true;
-    /** With `events`: runs `work` holding the run's lock, as every append to the mailbox is made. */
+    /** With `events`: runs `work` holding the run's lock, as every sender appends to `in.jsonl`. */
     locked?<T>(work: () => Promise<T>): Promise<T>;
     /**
      * With `events`: false when the attempt before this one has no ending, its process gone with its
      * agents perhaps still running: its sessions aren't reopened until they are stopped (Q17).
      */
     resumeSessions?: boolean;
-    /** With `events`: calls `nudge` whenever awf tells the run its mailbox has a new event. */
+    /** With `events`: calls `nudge` whenever awf tells the run it has a new event. */
     listenNudges?(nudge: () => void): void;
     /**
      * Writes the attempt's `parked` ending, which the run's wait calls holding the run's lock: an
@@ -244,7 +274,7 @@ export type RunWorkflowOptions = {
   deadline?: AbsoluteDeadline;
   cwd?: string;
   onLog?: (message: string, fields?: JsonObject) => void;
-  /** The operator hands the session back once agents.stop has released it. */
+  /** The operator hands the session back once close() has released it. */
   onCallerStopped?: (reason: string) => Promise<void>;
   signal?: AbortSignal;
   /** The sandbox providers agents may run in; without them, a sandboxed agent is refused. */
@@ -304,7 +334,7 @@ export type SettledRun = {
   sandboxes?: SandboxRecord[];
   /** Each agent's skills; absent when no agent opened. */
   skills?: AgentSkillsRecord[];
-  /** Where each pane agent's pane went; absent when the run placed none. */
+  /** Where each TUI agent's pane went; absent when the run placed none. */
   panes?: AgentPaneRecord[];
   /** Every decision the run asked, in the order asked; absent when it asked none. */
   decisions?: SettledDecision[];
@@ -392,7 +422,7 @@ type AgentEntry = {
    * `undefined` when the channel never opened; the agent state carries the reason.
    */
   channel: Promise<ResultChannel | undefined>;
-  /** Why `agents.stop` ended it; its key is not opened again. */
+  /** Why `close()` ended it; its key is not opened again. */
   stopped?: string;
   stopping?: Promise<boolean>;
   stopComplete?: boolean;
@@ -416,12 +446,12 @@ type AgentIdentity = {
   /** Its skills' sources, checked; absent when it has the operator's. */
   skills?: SkillSource[];
   instructions?: string;
-  labels?: AgentOpenSpec["labels"];
   /** The agent it was forked from, and the spec it was forked with. */
-  forkedFrom?: { parent: AgentKey; spec: AgentForkSpec };
-  /** As written; a reopen compares them so, never where the pane ended up. */
-  layout?: PaneLayout;
-  keepPane?: KeepPane;
+  forkedFrom?: { parent: AgentKey; spec: CallerForkSpec };
+  /** As written; a reopen compares it so, never where the pane ended up. */
+  pane?: PaneSpec;
+  /** What its host is asked for its pane: it, with the operator's flags applied. */
+  asked?: PaneAsked;
 };
 
 const CLEANUP_GRACE_MILLISECONDS = 5_000;
@@ -434,7 +464,7 @@ const FORK_TIMEOUT_MS = 60_000;
 const scopes = new AsyncLocalStorage<ExecutionScope>();
 
 export async function runWorkflow<Args extends JsonValue, Result extends JsonValue>(
-  definition: WorkflowDefinition<Args, Result>,
+  definition: RunnableWorkflow<Args, Result>,
   args: Args,
   options: RunWorkflowOptions,
 ): Promise<WorkflowRunResult<Result>> {
@@ -447,25 +477,50 @@ export async function runWorkflow<Args extends JsonValue, Result extends JsonVal
  * handle's `result`'s.
  */
 export async function startWorkflow<Args extends JsonValue, Result extends JsonValue>(
-  definition: WorkflowDefinition<Args, Result>,
+  definition: RunnableWorkflow<Args, Result>,
   args: Args,
   options: RunWorkflowOptions,
 ): Promise<WorkflowRunHandle<Result>> {
-  assertDeadline(options.deadline);
+  // Cancellation wins when the deadline has passed too, as runUntilStopped has it.
   if (options.signal?.aborted) throw new WorkflowCancelledError(options.signal.reason);
+  assertDeadline(options.deadline);
   // Before anything opens, so a refusal leaves nothing to close.
   const withEvents = isEventWorkflow(definition);
   const locked = options.run.locked ?? (<T>(work: () => Promise<T>) => work());
-  if (withEvents && (options.run.fromStage !== undefined || options.run.values))
-    throw new Error("a run of a workflow with events takes no --from-stage or --values");
-  const { dir: runDir, id: runId, attempt } = options.run;
-  const startedAt = Date.now();
+  if (withEvents && options.run.values)
+    throw new Error(
+      "a run of a workflow with events takes no --values: before --from-stage, a stage with no record runs",
+    );
+  const { dir: runDir, id: runId } = options.run;
+  const { attempt } = options.run.lines;
   const cwd = options.cwd ?? process.cwd();
-  // Before anything opens: a record this awf can't read refuses the attempt, and a crash may have
-  // torn the last line an earlier attempt appended.
-  const recorded = await readStageRecords(runDir);
+  // Before anything opens: a line this awf can't read refuses the attempt.
+  const { lines: written, view: recorded } = await readRunLines(runDir);
+  // The version each earlier attempt ran, which a line it wrote is reused under.
+  const earlier = await readAttempts({ dir: runDir });
+  // While no agent of this attempt can resume a session an earlier one's spend is still in.
+  await settleEarlier(runDir, {
+    attempt,
+    attempts: earlier,
+    lines: written,
+    accounting: options.runtime.host.accounting,
+    now: Date.now(),
+    ...(options.signal ? { signal: options.signal } : {}),
+  }).then(
+    ({ failed }) => {
+      for (const each of failed) options.onLog?.(`awf: spend.json not written for ${each}`);
+    },
+    (error: unknown) =>
+      options.onLog?.(`awf: earlier attempts' spend was not settled: ${messageOf(error)}`),
+  );
+  const startedAt = Date.now();
+  const versions = new Map(
+    earlier.flatMap(({ attempt: n, workflowVersion }) =>
+      workflowVersion === undefined ? [] : [[n, workflowVersion] as const],
+    ),
+  );
   // The log is observation: one that cannot be written says so as it is, and fails nothing.
-  await endTurnsLine(runDir).catch(() => undefined);
+  await endLogLine(runDir).catch(() => undefined);
   const slots = createResultSlotRegistry({
     runDir,
     ...(options.livenessPolicy
@@ -475,7 +530,10 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
         }
       : {}),
   });
-  const control = await startResultControlPlane({ slots });
+  const control = await startResultControlPlane({
+    slots,
+    ...(options.socketRoot ? { socketRoot: options.socketRoot } : {}),
+  });
   let host: AgentRunHost;
   const openingHost = Promise.resolve().then(() =>
     options.runtime.host.openRun({
@@ -512,8 +570,7 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
       });
     };
   const warn = say("warning");
-  // Each turn as it settles, so an attempt that dies keeps the sessions and times of its turns.
-  const turns: TurnRecord[] = [];
+  const sessionLines = new SessionLines({ lines: options.run.lines, failed: (text) => warn(text) });
   const ledger = createRunLedger({ accounting: options.runtime.host.accounting, startedAt });
   const recordTurn: RecordTurn = (outcome, kind) => {
     const turn: TurnRecord = {
@@ -524,18 +581,16 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
       callPath: outcome.usage.callPath,
       ...pick(outcome.usage, TURN_OPERATION_FIELDS),
     };
-    turns.push(turn);
     events.turn(turn);
   };
   const stages = new StageLedger({
-    runDir,
-    attempt,
-    records: recorded,
+    lines: options.run.lines,
+    run: recorded,
+    versions,
     ...(options.run.fromStage === undefined ? {} : { fromStage: options.run.fromStage }),
     ...(options.run.values === undefined ? {} : { values: options.run.values }),
     ...(definition.meta.version === undefined ? {} : { workflowVersion: definition.meta.version }),
     ...(withEvents ? { byContent: true } : {}),
-    turns: () => turns,
     event: (body, at) => events.event(body, at),
   });
   const progress = new RunProgress();
@@ -549,6 +604,7 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
     cwd,
     deadline: options.deadline,
     log: (message) => warn(message),
+    opened: (record) => events.event({ kind: "sandbox-opened", ...record }),
   });
   if (sandboxes.hasRunSandbox) {
     try {
@@ -563,9 +619,11 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
       throw new Error(`the run's sandbox did not open: ${messageOf(error)}`);
     }
   }
+  const ops = new OpIds(runDir, options.run.lines.attempt, options.run.ops);
   const decisions = new RunDecisions({
     ...(options.decisions ? { installation: options.decisions } : {}),
     runDir,
+    ops,
     event: (body) => events.event(body),
   });
   const skills = new RunSkills({
@@ -576,28 +634,33 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
   const fatal = Promise.withResolvers<never>();
   void fatal.promise.catch(() => undefined);
   const now = options.now ?? Date.now;
-  // A turn an earlier attempt started and never ended, its process gone, ends failed before the code
-  // runs again (Q6); the turns whose ends no wait took are their agents' turns again.
-  const restoredTurns = withEvents ? await recoverTurns(runDir, attempt, locked, now) : undefined;
-  // An event run's agents reopen on the sessions its earlier attempts' turns ran on.
+  // An event run's agents reopen on the sessions its earlier attempts recorded.
   const keptSessions =
     withEvents && options.run.resumeSessions !== false
-      ? keptSessionsOf(await readTurns(runDir))
+      ? keptSessionsOf(recorded.sessions)
       : undefined;
-  // Every run's timers live in a mailbox; a run of a workflow with events takes its events there too.
+  // Every run's timers are its own lines; a run of a workflow with events takes its events with them.
   // A plain run without `park` waits for its timers in its process.
-  const waits = new RunMailbox({
+  const { park } = options.run;
+  const waits = new RunWaits({
     runDir,
-    attempt,
+    lines: options.run.lines,
     locked,
     now,
-    ...(options.run.park
+    ...(park
       ? {
           parking: {
-            idle: (stage) => owner.idle(stage),
+            idle: () => owner.idle(),
             timeout: (signal) => owner.timeout(signal),
             liveUntil: () => owner.liveUntil(),
-            park: options.run.park,
+            park: async (wait) => {
+              // No wake carries `--from-stage`: parked short of it, the redo would be lost unsaid.
+              const unreached = stages.fromStageUnreached;
+              if (unreached === undefined) return park(wait);
+              const stop = new FromStageUnreached(unreached, stages.recorded);
+              fatal.reject(stop);
+              throw stop;
+            },
             ...(options.run.live ? { live: options.run.live } : {}),
             ...(options.run.skip ? { skip: options.run.skip } : {}),
           },
@@ -605,22 +668,28 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
       : {}),
   });
   await waits.open();
-  const mailbox = withEvents ? waits : undefined;
-  if (mailbox) options.run.listenNudges?.(() => mailbox.nudge());
-  // The mailbox's parking asks the owner, made after it: by then it is.
+  const eventWaits = withEvents ? waits : undefined;
+  if (eventWaits) options.run.listenNudges?.(() => eventWaits.nudge());
+  // A turn an earlier attempt started whose end no wait took is its agent's turn again (the claim
+  // ended any a crash left running).
+  const restoredTurns = eventWaits?.restored;
+  // The waits' parking asks the owner, made after it: by then it is.
   const owner: WorkflowOwner = new WorkflowOwner({
-    ...(mailbox ? { mailbox } : {}),
+    ...(eventWaits ? { eventWaits } : {}),
     waits,
     ...(keptSessions ? { keptSessions } : {}),
+    sessionLines,
     ...(restoredTurns ? { restoredTurns } : {}),
     failRun: (error) => fatal.reject(error),
     decisions,
+    ops,
     ...(options.allowance ? { allowance: options.allowance } : {}),
     sandboxes,
     skills,
     runDir,
     locks,
     environment,
+    ...(options.sandboxes?.homes ? { homes: options.sandboxes.homes } : {}),
     progress,
     recordTurn,
     stages,
@@ -644,6 +713,8 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
     coordinators: options.coordinators ?? [],
     emit: options.emit ?? machineEmitter,
     workflow: definition.meta.name,
+    declared: new Set(withEvents ? Object.keys(definition.events) : []),
+    ...(options.run.panes ? { panes: options.run.panes } : {}),
   });
   const stopped = new AbortController();
   // Aborted by a stop that comes after the body ended; the one that ended it does not cut short the
@@ -683,7 +754,7 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
       failed = true;
       failure = error;
     }
-    if (mailbox && !mailbox.parked)
+    if (eventWaits && !eventWaits.parked)
       await owner.endStartedTurns(failed ? "the workflow failed" : "the workflow returned");
     // Once `parked` is written, the attempt is parked, whatever the code did after.
     if (waits.parked) {
@@ -731,12 +802,21 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
 
     // Before the wait for session files, which is bookkeeping rather than the run's own time.
     const finishedAt = new Date().toISOString();
+    // A session that moved as its agent closed is recorded before the attempt ends.
+    owner.recordSessions();
+    await sessionLines.flushed();
     await stages
       .close()
-      .catch((error) => warn(`awf: a stage record was not written: ${messageOf(error)}`));
+      .catch((error) => warn(`awf: a stage's line was not written: ${messageOf(error)}`));
     await events.close();
     const usage = await ledger.settle(reading.signal);
     signal.removeEventListener("abort", cutReading);
+    // What a stop or the read's deadline left unread is the next attempt's to read again.
+    const reader = options.runtime.host.accounting;
+    const failedSpend = await keepSpend(runDir, attempt, usage, {
+      reads: (execution) => reader !== undefined && (reader.canRead?.(execution) ?? true),
+    }).catch((error: unknown) => [messageOf(error)]);
+    for (const each of failedSpend) options.onLog?.(`awf: spend.json not written for ${each}`);
     const times = { startedAt: new Date(startedAt).toISOString(), finishedAt };
     const opened = sandboxes.records();
     const given = skills.records();
@@ -878,6 +958,8 @@ class WorkflowOwner {
   readonly #cleanupFailures: Error[] = [];
   readonly context: WorkflowContext;
   readonly #agents = new Map<string, AgentEntry>();
+  /** The skills each agent's harness was given, as placed: what its session lines record. */
+  readonly #givenSkills = new Map<string, AgentSkills>();
   /** Each agent once it has opened, by key: what messaging asks about, and what a ref must be. */
   readonly #logical = new Map<string, LogicalAgent>();
   readonly #messaging: Messaging;
@@ -910,7 +992,9 @@ class WorkflowOwner {
       defaultWindowMs?: number;
       locks: CredentialLocks;
       environment: Readonly<Record<string, string | undefined>>;
+      homes?: HarnessHomes;
       decisions: RunDecisions;
+      ops: OpIds;
       allowance?: (harness: Harness) => Promise<HarnessAllowance>;
       stages: StageLedger;
       runId: string;
@@ -932,19 +1016,25 @@ class WorkflowOwner {
       onCallerStopped?: RunWorkflowOptions["onCallerStopped"];
       awaitReply: NonNullable<RunWorkflowOptions["awaitReply"]>;
       coordinators: readonly CoordinatorPort[];
-      /** A run of a workflow with `events`: its mailbox, which its waits take from. */
-      mailbox?: RunMailbox;
+      /** A run of a workflow with `events`: its waits, which take its events. */
+      eventWaits?: RunWaits;
       /** The run's time. */
       now: () => number;
-      /** Its timers: the mailbox for a run with `events`, one of its own for a plain run. */
-      waits: RunMailbox;
-      /** With `mailbox`: each root agent's last session in earlier attempts, which it reopens on. */
+      /** Its timers and waits, every run's. */
+      waits: RunWaits;
+      /** With `eventWaits`: each agent's latest session in earlier attempts, which it reopens on. */
       keptSessions?: ReadonlyMap<string, NativeFork>;
-      /** With `mailbox`: each agent's turn an earlier attempt started whose end no wait took. */
+      /** Where each session an agent is seen with is recorded, as it is. */
+      sessionLines: SessionLines;
+      /** With `eventWaits`: each agent's turn an earlier attempt started whose end no wait took. */
       restoredTurns?: ReadonlyMap<string, RestoredTurn>;
       emit: Emitter;
       /** The workflow's name, which with the run's id is the ref its events are `from`. */
       workflow: string;
+      /** The names its `events` declares, which `signal` takes. */
+      declared: ReadonlySet<string>;
+      /** The operator's choices for every TUI agent's pane on the host. */
+      panes?: RunPanes;
     },
   ) {
     this.#restored = new Map(options.restoredTurns ?? []);
@@ -964,6 +1054,7 @@ class WorkflowOwner {
       },
       schedule: (at, action) => scheduleAt({ unixMilliseconds: at }, action),
       now: Date.now,
+      question: (n) => `${options.attempt}.${n}`,
       record: async (event) => {
         this.#messagesChanged();
         if (event.kind === "message-sent") {
@@ -1004,7 +1095,10 @@ class WorkflowOwner {
       runId: options.runId,
       attempt: options.attempt,
       cwd: options.cwd,
-      deadline: options.deadline,
+      // A new `Date` each time, so one a workflow changes isn't the run's.
+      get deadline() {
+        return options.deadline && new Date(options.deadline.unixMilliseconds);
+      },
       agents: {
         open: (spec) => {
           try {
@@ -1013,24 +1107,6 @@ class WorkflowOwner {
             return Promise.reject(error);
           }
         },
-        attach: (key, runtime) => {
-          if (this.#caller?.key !== key) return unavailable("agents.attach");
-          const stopped = this.#agents.get(key)?.stopped;
-          if (stopped !== undefined) return Promise.reject(stoppedError(key, stopped));
-          if (runtime !== undefined) {
-            return Promise.reject(
-              new Error(`agent ${key} is the calling session, whose runtime is the operator's`),
-            );
-          }
-          return this.#caller.state;
-        },
-        stop: (key, reason) => {
-          try {
-            return this.stopAgent(key, reason);
-          } catch (error) {
-            return Promise.reject(error);
-          }
-        },
         caller: (spec) => {
           try {
             return this.caller(spec.key);
@@ -1083,17 +1159,10 @@ class WorkflowOwner {
         },
       },
       participants: {
-        connect: async (spec) => this.connectParticipant(spec),
-        get: async (key) =>
-          (this.#messaging.connected().includes(key) ? this.#outsideRefs.get(key) : undefined) ??
-          (this.#logical.get(key) as AgentRef | undefined) ??
-          null,
+        connect: (async (spec: ParticipantSpec) =>
+          this.connectParticipant(spec)) as ParticipantDirectory["connect"],
       },
       messages: { allow: async (access) => this.allowRoute(access) },
-      steps: {
-        run: () => unavailable("steps.run"),
-        sleep: () => unavailable("steps.sleep"),
-      },
       emit: async (target, run, name, data, emitOptions) => {
         if (this.#closed || this.#cleanupFailures.length)
           throw new Error("workflow context is closed");
@@ -1115,9 +1184,12 @@ class WorkflowOwner {
       },
       parallel: (items, operation, parallelOptions) => {
         const inherited = scopes.getStore()?.deadline ?? options.deadline;
-        const deadline = parallelOptions?.deadline
-          ? earlierDeadline(parallelOptions.deadline, inherited)
-          : inherited;
+        let deadline: AbsoluteDeadline | undefined;
+        try {
+          deadline = boundedDeadline(parallelOptions?.timeout, inherited);
+        } catch (error) {
+          return Promise.reject(error);
+        }
         const label = parallelOptions?.label;
         return runParallel(items, operation, deadline, parallelOptions?.concurrency, () =>
           label === undefined ? undefined : options.progress.group(label, items.length),
@@ -1129,7 +1201,6 @@ class WorkflowOwner {
       },
       stage: ((name: string, ...rest: unknown[]) =>
         this.runStage(name, rest)) as WorkflowContext["stage"],
-      call: () => unavailable("call"),
       usage: () => options.ledger.records(),
       allowance: async (harness) => {
         if (this.#closed || this.#cleanupFailures.length)
@@ -1153,33 +1224,29 @@ class WorkflowOwner {
           undefined,
         );
       },
+      // Every run waits on its own lines; one without events never parks, so it waits here.
+      receive: (spec?: WaitOptions) => this.receive(options.waits, spec),
+      race: ((name: string, branches: RaceBranches, raceOptions?: WaitOptions) =>
+        this.race(options.waits, name, branches, raceOptions)) as WorkflowContext["race"],
+      select: ((branches: Branches, selectOptions?: WaitOptions) =>
+        this.select(options.waits, branches, selectOptions)) as WorkflowContext["select"],
+      timer: (name: string, when: When) => this.timer(options.waits, name, when),
+      at: (read: () => Date | null) => timeRead(read),
+      after: (duration: Duration) => {
+        this.#notReading("wf.after()");
+        let milliseconds: number;
+        try {
+          milliseconds = durationMilliseconds(duration);
+        } catch (error) {
+          throw new Error(`wf.after takes a duration: ${messageOf(error)}`);
+        }
+        return new Date(options.now() + milliseconds);
+      },
+      signal: ((name: string) => signalSource(name, options.declared)) as WorkflowContext["signal"],
+      ...(options.eventWaits?.started
+        ? { started: options.eventWaits.started as WorkflowContext["started"] }
+        : {}),
     };
-    const { mailbox } = options;
-    Object.assign(
-      this.context,
-      mailbox
-        ? {
-            receive: (spec?: ReceiveOptions) => this.receive(mailbox, spec),
-            race: (name: string, branches: RaceBranches, raceOptions?: WaitOptions) =>
-              this.race(mailbox, name, branches, raceOptions),
-            select: (branches: Branches, selectOptions?: SelectOptions) =>
-              this.select(mailbox, branches, selectOptions),
-            timer: (name: string, when: When) => this.timer(mailbox, name, when),
-            timers: () => source({}, { name: "timer:due" }),
-            at: (read: () => Date | null) => timeRead(read),
-            after: (duration: Duration) => {
-              this.#notReading("wf.after()");
-              if (typeof duration !== "string" || !/^\d+(?:\.\d+)?[dhm]$/.test(duration))
-                throw new Error(
-                  `wf.after takes days, hours or minutes, "1d", "3h", "1.5h"; not ${String(duration)}`,
-                );
-              return new Date(parseWhen(duration, options.now()).due);
-            },
-            signal: (name: string) => signalSource(name),
-            ...(mailbox.started ? { started: mailbox.started } : {}),
-          }
-        : { receive: () => Promise.reject(new Error("receive needs a workflow with events")) },
-    );
   }
 
   /** Set while a select reads a time from state. */
@@ -1243,7 +1310,8 @@ class WorkflowOwner {
         if (this.#restored.get(event.from)?.turn === turn) this.#restored.delete(event.from);
         this.#logical.get(event.from)?.endTaken(turn);
       }
-      return taken;
+      // `in.jsonl` and the turns' ends keep awf's record names; the code is handed the names it declares.
+      return taken.map((event) => presented(event, this.options.declared));
     } finally {
       removeFromScope?.();
       this.#waiting = false;
@@ -1251,7 +1319,7 @@ class WorkflowOwner {
   }
 
   /** A timer, by name: the recorded one, or set now. A race's own are named `{race}@{branch}`. */
-  private timer(mailbox: RunMailbox, name: string, when: When, own = false): Timer {
+  private timer(waits: RunWaits, name: string, when: When, own = false): Timer {
     if (this.#closed || this.#cleanupFailures.length) throw new Error("workflow context is closed");
     if (typeof name !== "string") throw new Error("a timer's name is a string");
     if (!own) {
@@ -1261,7 +1329,7 @@ class WorkflowOwner {
       if (problem) throw new Error(`timer ${name}: its name is ${problem}`);
     }
     const given = parseWhen(when, this.options.now());
-    const { timer, asked } = mailbox.setTimer(name, given.due, given.when);
+    const { timer, asked } = waits.setTimer(name, given.due, given.when);
     if (timer.cancelled)
       this.options.onLog?.(
         `awf: timer ${name} was cancelled; a name stays cancelled, so it won't fire`,
@@ -1270,12 +1338,12 @@ class WorkflowOwner {
       this.options.onLog?.(
         `awf: timer ${name} is due ${timer.due}, as first set (${timer.when}); ${asked} is ignored`,
       );
-    return timerSource(mailbox, name, timer.due);
+    return timerSource(waits, name, timer.due);
   }
 
   /** Waits for the first of `branches`, recorded under `name`. */
   private async race(
-    mailbox: RunMailbox,
+    waits: RunWaits,
     name: string,
     branches: RaceBranches,
     raceOptions: WaitOptions | undefined,
@@ -1291,8 +1359,7 @@ class WorkflowOwner {
       throw new Error(
         `race ${name} has answered in this attempt; a wait in a loop is named per round, as approval-\${round}`,
       );
-    this.#raced.add(name);
-    const label = checkedLabel(raceOptions?.label);
+    const label = labelOf(raceOptions?.label);
     const given = branchesOf(`race ${name}`, branches, true);
     // A sleep's time may be a Date, its own timer as a duration is.
     const own = (source: unknown) => typeof source === "string" || source instanceof Date;
@@ -1302,36 +1369,43 @@ class WorkflowOwner {
         own(source) ? [] : [[branch, sourceTake(`race ${name}`, branch, source)] as const],
       ),
     );
+    this.#checkSources(`race ${name}`, takes.entries());
+    // Only once its label and branches are checked: a refused race leaves its name to a retry.
+    this.#raced.add(name);
     const owned = new Map<string, string>();
     const pairs: (readonly [string, WaitTake])[] = given.map(([branch, source]) => {
       if (!own(source)) return [branch, takes.get(branch) as WaitTake] as const;
-      const timer = this.timer(mailbox, `${name}@${branch}`, source as When, true);
+      const timer = this.timer(waits, `${name}@${branch}`, source as When, true);
       owned.set(branch, timer.name);
       return [branch, { name: "timer:due", from: timer.name }] as const;
     });
-    let won: { branch: string; event: WorkflowEvent<string, JsonValue> } | undefined;
+    let branch: string | undefined;
+    let event: WorkflowEvent<string, JsonValue>;
     try {
-      await this.#holdingWait(scope, async (signal) => {
-        won = await mailbox.race(name, pairs, owned, label, signal);
+      [event] = (await this.#holdingWait(scope, async (signal) => {
+        const won = await waits.race(name, pairs, owned, label, signal);
+        branch = won.branch;
         return [won.event];
-      });
+      })) as [WorkflowEvent<string, JsonValue>];
     } catch (error) {
-      // Cut short, not parked: its own timers would fire into a later wait. A park's rerun races again.
-      if (!(error instanceof RunParked))
-        await Promise.all([...owned.values()].map((timer) => mailbox.cancelTimer(timer))).catch(
+      // Cut short, not parked: its own timers would fire into a later wait. A park's rerun races
+      // again, and so does a continue's after a park refused short of its --from-stage.
+      if (!(error instanceof RunParked || error instanceof FromStageUnreached))
+        await Promise.all([...owned.values()].map((timer) => waits.cancelTimer(timer))).catch(
           () => undefined,
         );
       throw error;
     }
-    const { branch, event } = won as { branch: string; event: WorkflowEvent<string, JsonValue> };
-    return { key: branch, [branch]: branchValue(event) } as Next<RaceBranches>;
+    const key = branch as string;
+    const whole = isSignal(given.find(([each]) => each === key)?.[1]);
+    return { key, [key]: branchValue(event, whole) } as Next<RaceBranches>;
   }
 
   /** A loop over the events `branches` take, one at a time. */
   private select(
-    mailbox: RunMailbox,
+    waits: RunWaits,
     branches: Branches,
-    selectOptions: SelectOptions | undefined,
+    selectOptions: WaitOptions | undefined,
   ): AsyncIterable<Next<Branches>> {
     const given = branchesOf("select", branches, false);
     const reads = new Map(
@@ -1344,9 +1418,12 @@ class WorkflowOwner {
       ([branch, source]) =>
         [
           branch,
-          reads.has(branch) ? { name: AT_DUE, from: branch } : sourceTake("select", branch, source),
+          reads.has(branch)
+            ? { name: "at:due", from: branch }
+            : sourceTake("select", branch, source),
         ] as const,
     );
+    this.#checkSources("select", pairs);
     // Read at each pass of the wait: a time follows the state as it moves.
     const takes = (): WaitTake[] =>
       pairs.map(([branch, take]) => {
@@ -1354,20 +1431,17 @@ class WorkflowOwner {
         const due = read && this.#readTime(branch, read);
         return due === undefined ? take : { ...take, due };
       });
-    const labelOf = () => {
-      const given = selectOptions?.label;
-      return checkedLabel(typeof given === "function" ? given() : given);
-    };
     const next = async (): Promise<Next<Branches>> => {
       const scope = this.#beginWait("select");
       if (scope?.stage !== undefined)
         throw new Error(`select is in stage ${scope.stage}: a loop's wait is not a stage's`);
       const [event] = await this.#holdingWait(scope, async (signal) => [
-        await mailbox.select(takes, labelOf(), signal),
+        await waits.select(takes, labelOf(selectOptions?.label), signal),
       ]);
       const taken = event as WorkflowEvent<string, JsonValue>;
       const branch = branchOf(pairs, taken) as string;
-      return { key: branch, [branch]: branchValue(taken) } as Next<Branches>;
+      const whole = isSignal(given.find(([each]) => each === branch)?.[1]);
+      return { key: branch, [branch]: branchValue(taken, whole) } as Next<Branches>;
     };
     return {
       [Symbol.asyncIterator]: () => ({
@@ -1377,17 +1451,38 @@ class WorkflowOwner {
     };
   }
 
+  /**
+   * A wait's branches as a run can take them: a run without events, which hears no agent's end or
+   * reply to the code, refuses a branch waiting on one, which would never come.
+   */
+  #checkSources(what: string, takes: Iterable<readonly [string, WaitTake]>): void {
+    const given = [...takes];
+    if (!this.options.eventWaits) {
+      const unheard = given.find(([, take]) => HEARD_WITH_EVENTS.has(take.name));
+      if (unheard)
+        throw new Error(
+          `${what}'s ${unheard[0]} waits on ${unheard[1].name === "agent:ended" ? "an agent's end" : "a participant's reply to the code"}, which a run without events never hears; declare events in the workflow`,
+        );
+    }
+  }
+
   #waiting = false;
   /** The races and sleeps this attempt has run, each by its name once. */
   readonly #raced = new Set<string>();
   /** Each agent's turn an earlier attempt started whose end no wait has taken yet. */
   readonly #restored: Map<string, RestoredTurn>;
 
-  /** How an agent of an event run records its started turns in the mailbox. */
-  #turnsOf(key: string, mailbox: RunMailbox): LogicalAgentTurns {
+  /** How an agent of an event run records its started turns in `run.jsonl`. */
+  #turnsOf(key: string, waits: RunWaits): LogicalAgentTurns {
     return {
-      begin: (turn, meta, execution) => mailbox.beginTurn(key, turn, meta, execution),
-      end: (turn, meta, outcome) => mailbox.endTurn(key, { turn, meta, outcome }),
+      begin: (turn, meta, execution) => waits.beginTurn(key, turn, meta, execution),
+      end: (turn, meta, outcome) => waits.endTurn(key, { turn, meta, outcome }),
+      checkDeclared: () => {
+        if (!this.options.declared.has(`${key}:ended`))
+          throw new Error(
+            `agent ${key}: start()'s end arrives as ${key}:ended, which the workflow declares in events, "${key}:ended": AgentEnded`,
+          );
+      },
       // Read when the agent opens: a wait before then may have taken the end.
       restored: () => this.#restored.get(key),
     };
@@ -1411,10 +1506,9 @@ class WorkflowOwner {
    * Nothing of the run is working but its wait: no agent's turn, message or compaction, and no
    * decision, sandbox or agent opening in flight.
    */
-  idle(waitStage?: string): boolean {
-    const open = this.options.stages.openStage;
+  idle(): boolean {
     return (
-      (open === undefined || open === waitStage) &&
+      this.options.stages.openStage === undefined &&
       this.#inFlight.size === 0 &&
       [...this.#logical.values()].every((agent) => !agent.busy)
     );
@@ -1442,7 +1536,7 @@ class WorkflowOwner {
       if (!onTimeout) continue;
       try {
         await runUntilStopped(
-          async () => asTimeoutHandler(() => onTimeout(agent as unknown as EventAgentRef)),
+          async () => asTimeoutHandler(() => onTimeout(agent)),
           signal,
           undefined,
         );
@@ -1454,34 +1548,17 @@ class WorkflowOwner {
     }
     return false;
   }
-  /** The batch a wait in a stage took, by stage, until the stage ends: what it must return. */
-  readonly #stageBatches = new Map<string, WorkflowEvent<string, JsonValue>[]>();
-  /** Stages around a wait this attempt entered: each is entered once, as a loop over one spins. */
-  readonly #waitedStages = new Set<string>();
-
-  /** A wait: one at a time, and in a stage, the stage's batch. */
+  /** A wait, outside any stage: a wait a rerun gets the same answer from is a `race`. */
   private async receive(
-    mailbox: RunMailbox,
-    spec: ReceiveOptions | undefined,
+    waits: RunWaits,
+    spec: WaitOptions | undefined,
   ): Promise<WorkflowEvent<string, JsonValue>[]> {
     const scope = this.#beginWait("receive()");
-    if (scope?.stage !== undefined && this.#stageBatches.has(scope.stage))
-      throw new Error(`stage ${scope.stage} has waited once; a stage holds one wait`);
-    try {
-      const taken = await this.#holdingWait(scope, (signal) =>
-        mailbox.receive(spec, scope?.stage, signal),
+    if (scope?.stage !== undefined)
+      throw new Error(
+        `receive() is refused in stage ${scope.stage}: wait outside it with wf.race(name, …), which is recorded under its name`,
       );
-      if (scope?.stage !== undefined) {
-        this.#stageBatches.set(scope.stage, taken);
-        this.#waitedStages.add(scope.stage);
-      }
-      return taken;
-    } catch (error) {
-      // Parked in a stage: left unended now, before anything closes it, for the next attempt.
-      if (error instanceof RunParked && scope?.stage !== undefined)
-        this.options.stages.abandon(scope.stage);
-      throw error;
-    }
+    return this.#holdingWait(scope, (signal) => waits.receive(receiveLabel(spec), signal));
   }
 
   /** An agent as messaging sees it, from its entry and its operations. */
@@ -1512,47 +1589,38 @@ class WorkflowOwner {
         !isJsonValue(labels))
     )
       throw new Error("a participant's labels are a JSON object");
-    const to = (spec as { to?: unknown }).to;
-    if (to !== undefined && to !== "code")
-      throw new Error(`a participant's messages go to agents, or to: "code"; not ${String(to)}`);
-    if (to === "code" && !this.options.mailbox)
+    if ((spec as { to?: unknown }).to !== undefined)
       throw new Error(
-        "a participant routed to the code needs a workflow with events, whose waits take its replies",
+        `participant ${key} is connected without to: its messages reach the code when the workflow declares "${key}:reply": ParticipantReply in events`,
       );
     this.#messaging.connect(
       key,
       labels === undefined ? undefined : structuredClone(labels),
-      to === "code" ? "code" : undefined,
+      this.options.declared.has(`${key}:reply`) ? "code" : undefined,
     );
     const ref: ParticipantRef = {
       ...participantRef(key),
+      post: async (text: string) => {
+        if (typeof text !== "string" || text.trim() === "")
+          throw new Error("post takes the text to write");
+        await this.#messaging.post(key, text);
+      },
       release: async (reason) => {
         if (reason !== undefined && typeof reason !== "string")
           throw new Error("a release's reason is a string");
         return this.#messaging.release(key, reason);
       },
     };
-    if (to === "code") {
-      const routed = source(
-        {
-          ...ref,
-          post: async (text: string) => {
-            if (typeof text !== "string" || text.trim() === "")
-              throw new Error("post takes the text to write");
-            await this.#messaging.post(key, text);
-          },
-        },
-        { name: "participant:reply", from: key },
-      ) as unknown as CodeParticipantRef;
-      this.#outsideRefs.set(key, routed);
-      return routed;
-    }
     this.#outsideRefs.set(key, ref);
     return ref;
   }
 
   /** A key an agent may not take: a reserved one, or an outside participant's. */
   #assertFreeKey(key: string, who: string): void {
+    if (typeof key === "string" && key.includes(":"))
+      throw new Error(
+        `${key} has a colon, kept for awf's own event names, {key}:ended and {key}:reply; ${who} takes another key, such as ${key.replaceAll(":", "-")}`,
+      );
     if ((RESERVED_PARTICIPANT_KEYS as readonly string[]).includes(key.toLowerCase()))
       throw new Error(
         `${key} is reserved: an agent could read a message from it as authority; ${who} takes another key`,
@@ -1600,10 +1668,14 @@ class WorkflowOwner {
         throw new Error("a route between agents names two of them");
       ends = { between: [end(shape.between[0]), end(shape.between[1])] };
     } else ends = { from: end(shape.from), to: end(shape.to) };
+    const timeoutMs =
+      access.timeout == null
+        ? undefined
+        : positiveDurationMilliseconds(access.timeout, "a route's timeout");
     this.#messaging.grant(ends, {
       purpose: access.purpose,
       maxMessages: access.maxMessages,
-      timeoutMs: access.timeoutMs,
+      timeoutMs,
       scope: scope?.messages ?? this.#messaging.attempt,
     });
   }
@@ -1694,7 +1766,7 @@ class WorkflowOwner {
                     : "cancelled",
                 reason: "workflow closing",
               })
-              .then(() => state.close("workflow complete")),
+              .then(() => state.terminate("workflow complete")),
           () => undefined,
         ),
       );
@@ -1777,19 +1849,7 @@ class WorkflowOwner {
     });
     if (entered.kind === "reuse") {
       entered.release();
-      // A stage around a wait returns the batch it took, which its record doesn't hold.
-      const batch =
-        entered.value === undefined && !options
-          ? await this.options.mailbox?.batchOf(name)
-          : undefined;
-      if (batch) {
-        if (this.#waitedStages.has(name))
-          throw new Error(
-            `stage ${name} around a wait was entered again in this attempt, and would return the same batch forever; name it by what it waits for`,
-          );
-        this.#waitedStages.add(name);
-      }
-      return (batch as JsonValue | undefined) ?? entered.value;
+      return entered.value;
     }
     const open = entered.stage;
     const messages = this.#messaging.scope(name);
@@ -1807,22 +1867,9 @@ class WorkflowOwner {
       this.#messaging.finishing(messages);
       scope.seal();
       await this.drainMessages(messages, () => scope.settleOwned());
-      // A timer it set is written before its record, which a rerun reuses without its work.
+      // A timer it set is written before its line, which a rerun reuses without its work.
       await this.options.waits.flush();
       if (this.options.stages.stopped?.stage === name) throw this.options.stages.caught();
-      const batch = this.#stageBatches.get(name);
-      if (batch && !options) {
-        const same =
-          Array.isArray(returned) &&
-          returned.length === batch.length &&
-          returned.every((event, i) => (event as { id?: unknown })?.id === batch[i]?.id);
-        if (!same)
-          throw new Error(
-            `stage ${name} returned other events than its wait took; its work is the wait alone`,
-          );
-        await open.succeed(undefined);
-        return batch as JsonValue;
-      }
       const value = stageValue(name, options, returned);
       await open.succeed(value, summaryOf(name, options, value, this.options.onLog));
       return value;
@@ -1842,7 +1889,6 @@ class WorkflowOwner {
       }
       throw error;
     } finally {
-      this.#stageBatches.delete(name);
       this.#messaging.closeScope(messages);
       this.#stageScopes.delete(messages);
       removeFromParent?.();
@@ -1856,13 +1902,14 @@ class WorkflowOwner {
     if (this.#caller?.key === spec.key) {
       throw new Error(`agent ${spec.key} is the calling session; it is not opened`);
     }
+    this.options.ops.claim(spec.key, "agent");
     const inRunSandbox = this.options.sandboxes.hasRunSandbox;
     if (inRunSandbox && spec.sandbox !== undefined)
       throw new Error(`agent ${spec.key}: ${RUN_SANDBOX_ONLY}`);
     const existing = this.#agents.get(spec.key);
     if (existing?.stopped !== undefined) throw stoppedError(spec.key, existing.stopped);
-    const given = (spec as EventAgentOpenSpec).keepAlive;
-    if (given !== undefined && !this.options.mailbox)
+    const given = spec.keepAlive;
+    if (given !== undefined && !this.options.eventWaits)
       throw new Error(
         `agent ${spec.key}: keepAlive is for a workflow with events, whose runs park; this one's never do`,
       );
@@ -1870,26 +1917,25 @@ class WorkflowOwner {
     const execution = existing
       ? constrainExistingExecution(spec.runtime, existing.identity.execution)
       : withKnownEffort(resolveExecution(spec.runtime, this.options.runtime));
-    checkPaneOptions(spec.key, spec, {
+    const paneless = {
       headless: placementOf(execution) === "headless",
       sandboxed:
         spec.sandbox !== undefined || existing?.identity.sandbox !== undefined || inRunSandbox,
-    });
+    };
+    checkPaneOptions(spec.key, spec, paneless);
+    const pane = spec.pane === undefined ? undefined : storedPane(spec.pane);
     const identity: AgentIdentity = {
       execution,
       cwd: spec.cwd ?? this.options.cwd,
       ...(spec.instructions === undefined ? {} : { instructions: spec.instructions }),
-      ...(spec.labels === undefined ? {} : { labels: structuredClone(spec.labels) }),
       ...(spec.sandbox === undefined ? {} : { sandbox: spec.sandbox }),
       ...(spec.skills === undefined ? {} : { skills: readSkillSources(spec.skills) }),
-      ...(spec.layout === undefined ? {} : { layout: storedLayout(spec.layout) }),
-      ...(spec.keepPane === undefined ? {} : { keepPane: spec.keepPane }),
+      ...(pane === undefined ? {} : { pane }),
+      asked: paneAsked(pane, this.options.panes, !paneless.headless && !paneless.sandboxed),
     };
     const scope = scopes.getStore();
     const inheritedDeadline = scope?.deadline ?? this.options.deadline;
-    const effectiveDeadline = spec.deadline
-      ? earlierDeadline(spec.deadline, inheritedDeadline)
-      : inheritedDeadline;
+    const effectiveDeadline = boundedDeadline(spec.timeout, inheritedDeadline);
     assertDeadline(effectiveDeadline);
     if (existing) {
       assertCompatibleAgent(spec.key, existing.identity, identity, spec);
@@ -1944,15 +1990,14 @@ class WorkflowOwner {
         // A kept session already holds the instructions; they are not sent again.
         ...(kept ? { continues: kept } : {}),
         ...(spec.instructions === undefined || kept ? {} : { instructions: spec.instructions }),
-        ...(this.options.mailbox ? { paneAtFirstTurn: true as const } : {}),
-        ...(spec.labels === undefined ? {} : { labels: spec.labels }),
+        ...(this.options.eventWaits ? { paneAtFirstTurn: true as const } : {}),
         ...(seated ? { occupant: seated.occupant } : {}),
         ...(seated?.webSearch ? { webSearch: true } : {}),
         ...(skills ? { skills } : {}),
         ...(home ? { home } : {}),
-        ...paneOptions(identity),
+        ...identity.asked,
       }),
-      layoutFallback: this.besideFallback(identity.layout, effectiveDeadline)(),
+      layoutFallback: this.besideFallback(identity.asked?.layout, effectiveDeadline)(),
     };
     let skills: Promise<PlacedSkills | undefined> = Promise.resolve(undefined);
     let opened: { state: Promise<LogicalAgent>; channel: Promise<ResultChannel> };
@@ -1985,11 +2030,11 @@ class WorkflowOwner {
 
   /**
    * Ends an agent the workflow has no more use for, as an operation that fails ends it: what it
-   * is running is cancelled, and its pane closed or, where `keepPane` says, kept and released.
+   * is running is cancelled, and its pane closed or, where `--keep-panes` says, kept and released.
    */
-  private stopAgent(key: string, reason?: string): Promise<boolean> {
+  private stopAgent(key: string, reason: string | undefined, what: string): Promise<boolean> {
     if (this.#closed || this.#cleanupFailures.length) throw new Error("workflow context is closed");
-    const inTool = refusedInTool(key, "agents.stop");
+    const inTool = refusedInTool(key, what);
     if (inTool) throw inTool;
     const scope = scopes.getStore();
     scope?.assertAccepting();
@@ -2014,7 +2059,7 @@ class WorkflowOwner {
         }
         this.options.progress.agentStopped(key, entry.stopped!);
         try {
-          await state.close(entry.stopped);
+          await state.terminate(entry.stopped);
         } finally {
           await entry.channel.then((channel) => channel?.close());
         }
@@ -2044,13 +2089,14 @@ class WorkflowOwner {
   /**
    * The session the run was started from, under the key the workflow names: `null` when there is
    * none. It is found, not opened: its harness, directory and skills are the operator's, and it
-   * answers through a launcher by path as any pane agent does (ADR 0010).
+   * answers through a launcher by path as any TUI agent does (ADR 0010).
    */
   private caller(key: string): Promise<AgentRef | null> {
     if (this.#closed || this.#cleanupFailures.length) throw new Error("workflow context is closed");
     const scope = scopes.getStore();
     scope?.assertAccepting();
     this.#assertFreeKey(key, "an agent");
+    this.options.ops.claim(key, "agent");
     const found = this.options.runtime.host.caller;
     if (!found) return Promise.resolve(null);
     if (this.#caller) {
@@ -2078,7 +2124,9 @@ class WorkflowOwner {
     };
     const ledger = this.options.ledger.agent(accounted);
     this.options.skills.record(key, "operator");
-    const opened = this.options.control.openChannel(key, (id) => sessions.launcher.add(id));
+    const opened = this.options.control.openChannel(key, (id) =>
+      this.launcherReported(key, execution.harness, sessions, id),
+    );
     const state = opened.then(async (channel) => {
       try {
         const launcher = await installAgentLauncher(
@@ -2121,7 +2169,7 @@ class WorkflowOwner {
    * it is that agent's own fork, taken in its queue; otherwise it is taken now, from a parent the
    * run never opened. `null`, and the reason logged, where there is none to fork.
    */
-  private forkCaller(spec: AgentForkSpec): Promise<AgentRef | null> {
+  private forkCaller(spec: CallerForkSpec): Promise<AgentRef | null> {
     if (this.#closed || this.#cleanupFailures.length) throw new Error("workflow context is closed");
     const scope = scopes.getStore();
     scope?.assertAccepting();
@@ -2150,11 +2198,10 @@ class WorkflowOwner {
       channel: Promise.resolve(undefined),
     };
     parent.state.catch(() => undefined);
-    const deadline = scope?.deadline ?? this.options.deadline;
     return this.forkAgent(
       CALLING,
       spec,
-      (into) =>
+      (deadline, into) =>
         calling
           .fork(deadlineWithin(FORK_TIMEOUT_MS, deadline), into, this.#closingRun.signal)
           .then((native) => ({ native, after: null })),
@@ -2175,7 +2222,10 @@ class WorkflowOwner {
   ): { state: Promise<LogicalAgent>; channel: Promise<ResultChannel> } {
     const opened = placed.then((skills) => {
       if (skills?.given.ownHome) accounted.home = skills.given.ownHome;
-      return this.options.control.openChannel(spec.key, (id) => sessions.launcher.add(id));
+      if (skills) this.#givenSkills.set(spec.key, skills.given);
+      return this.options.control.openChannel(spec.key, (id) =>
+        this.launcherReported(spec.key, execution.harness, sessions, id),
+      );
     });
     const reachable = opened.then(async (channel) => ({
       channel,
@@ -2253,7 +2303,7 @@ class WorkflowOwner {
     const given = skillsLayout(
       execution.harness,
       resolved.map((skill) => skill.name),
-      { bundle: join(runDir, "agents", id), cwd: realCwd },
+      { bundle: join(workDir(runDir), "agents", id), cwd: realCwd },
     );
     this.options.skills.record(key, resolved, given.ownHome);
     const { ownHome } = given;
@@ -2264,8 +2314,12 @@ class WorkflowOwner {
     await mkdir(dirname(ownHome), { recursive: true });
     const seeded = await seedHome(
       ownHome,
-      join(runDir, "staging", id),
-      hostHome(execution.harness, ownHome, this.options.environment),
+      join(workDir(runDir), "staging", id),
+      (this.options.homes ?? OPERATOR_HOMES).host(
+        execution.harness,
+        ownHome,
+        this.options.environment,
+      ),
       realCwd,
       this.options.locks,
       async (staged) => {
@@ -2314,10 +2368,11 @@ class WorkflowOwner {
       // What the agent really ran in, which is where accounting finds its sessions.
       accounted.cwd = seat.cwd;
       accounted.home = seat.home;
+      if (seat.skills) this.#givenSkills.set(spec.key, seat.skills);
       let channel: ResultChannel | undefined;
       try {
         channel = await this.options.control.openChannel(spec.key, (id) =>
-          sessions.launcher.add(id),
+          this.launcherReported(spec.key, execution.harness, sessions, id),
         );
         const door = await installSandboxedDoor(
           dirname(channel.endpoint),
@@ -2381,6 +2436,7 @@ class WorkflowOwner {
       execution,
       session,
       slots: this.options.slots,
+      ops: this.options.ops,
       endpoint,
       launcher,
       deadline: this.options.deadline,
@@ -2388,6 +2444,11 @@ class WorkflowOwner {
       progress: this.options.progress,
       recordTurn: this.options.recordTurn,
       events: this.options.events,
+      sessionsKnown: (sessions, operation) =>
+        this.options.sessionLines.known(key, sessions, {
+          ...(operation === undefined ? {} : { operation }),
+          ...this.placeOf(key),
+        }),
       track: (promise) => this.track(promise),
       isRunClosing: () => this.#closed || this.#cleanupFailures.length > 0,
       checkOperation: () => this.options.stages.checkOperation(),
@@ -2397,9 +2458,16 @@ class WorkflowOwner {
         this.options.failRun(error);
       },
       livenessPolicy: this.options.livenessPolicy,
-      ...(this.options.mailbox ? { turns: this.#turnsOf(key, this.options.mailbox) } : {}),
+      ...(this.options.eventWaits ? { turns: this.#turnsOf(key, this.options.eventWaits) } : {}),
       fork: (spec, take, settings) => this.forkAgent(key, spec, take, settings),
-      keepPane: () => this.#agents.get(key)?.identity.keepPane,
+      close: (reason) => {
+        try {
+          return this.stopAgent(key, reason, "close()");
+        } catch (error) {
+          return Promise.reject(error);
+        }
+      },
+      keepPane: () => this.#agents.get(key)?.identity.asked?.keepPane,
       keepAlive: () => this.#agents.get(key)?.keepAlive,
       defaultWindowMs: this.options.defaultWindowMs ?? DEFAULT_WINDOW_MS,
       now: this.options.now,
@@ -2431,8 +2499,11 @@ class WorkflowOwner {
   private forkAgent(
     parentKey: string,
     spec: AgentForkSpec,
-    /** Queues the native fork, or its copy `into` another home; or why its host cannot fork. */
-    take: ((into?: SessionCopy) => Promise<TakenFork>) | string,
+    /**
+     * Queues the native fork, or its copy `into` another home, within the fork's `deadline`; or why
+     * its host cannot fork.
+     */
+    take: TakeFork | string,
     /** The parent's settings once every `set` queued before the fork has run. */
     parentSettings: AgentExecution,
     /** A parent the run never opened: the session it was started from. */
@@ -2446,11 +2517,13 @@ class WorkflowOwner {
       throw new Error(`agent ${spec.key} is the calling session; it is not opened`);
     }
     this.#assertFreeKey(spec.key, "an agent");
+    this.options.ops.claim(spec.key, "agent");
     // Out before the clone, which throws on a handler, and out of the spec a repeat is compared by.
-    const { tools, ...cloned } = spec;
-    const forkSpec = structuredClone(cloned);
-    if (forkSpec.layout !== undefined) forkSpec.layout = storedLayout(forkSpec.layout);
-    const deadline = scope?.deadline ?? this.options.deadline;
+    // A bound is the call's, not the fork's: a repeat with another is the same fork.
+    const { tools, timeout, ...given } = spec;
+    const forkSpec = structuredClone(forkSpecOf(given));
+    if (forkSpec.pane !== undefined) forkSpec.pane = storedPane(forkSpec.pane);
+    const deadline = boundedDeadline(timeout, scope?.deadline ?? this.options.deadline);
     assertDeadline(deadline);
     // A fork of the calling session is one whichever way it was asked for.
     const from = unopened || this.#caller?.key === parentKey ? CALLING : parentKey;
@@ -2478,27 +2551,24 @@ class WorkflowOwner {
     // child's home: anything added to the parent's would be read as the parent's.
     const copy =
       sandboxed || opening.accounted.home !== undefined
-        ? join(this.options.runDir, "forks", randomUUID())
+        ? join(workDir(this.options.runDir), "forks", randomUUID())
         : undefined;
-    const execution = withKnownEffort(forkExecution(parentSettings, forkSpec));
+    const execution = withKnownEffort(forkExecution(parentSettings, forkSpec.runtime));
     // A fork of the calling session is an agent the run opened, on the model the session's files
     // show, which the fork reads: `""` until then (ADR 0010).
     const ofCaller = execution.caller === true;
     delete execution.caller;
-    checkPaneOptions(spec.key, forkSpec, {
-      headless: placementOf(execution) === "headless",
-      sandboxed,
-    });
+    const headless = placementOf(execution) === "headless";
+    checkPaneOptions(spec.key, forkSpec, { headless, sandboxed });
     const identity: AgentIdentity = {
       execution,
       cwd: parent.identity.cwd,
       ...(forkSpec.instructions === undefined ? {} : { instructions: forkSpec.instructions }),
-      ...(forkSpec.labels === undefined ? {} : { labels: forkSpec.labels }),
       ...(parent.identity.skills ? { skills: parent.identity.skills } : {}),
       ...(parent.identity.sandbox === undefined ? {} : { sandbox: parent.identity.sandbox }),
       forkedFrom: { parent: from, spec: forkSpec },
-      ...(forkSpec.layout === undefined ? {} : { layout: forkSpec.layout }),
-      ...(forkSpec.keepPane === undefined ? {} : { keepPane: forkSpec.keepPane }),
+      ...(forkSpec.pane === undefined ? {} : { pane: forkSpec.pane }),
+      asked: paneAsked(forkSpec.pane, this.options.panes, !headless && !sandboxed),
     };
 
     this.options.progress.agentOpened(spec.key, scope?.group);
@@ -2512,11 +2582,11 @@ class WorkflowOwner {
       sessions: () => reportedSessions(sessions),
       forkedAt: () => forkedAt,
     };
-    const besideAtFork = this.besideFallback(identity.layout, deadline);
+    const besideAtFork = this.besideFallback(identity.asked?.layout, deadline);
     let continues: NativeFork | undefined;
     // The fork is asked for now, in the parent's queue; the child opens once it is made. One that
     // was not made leaves nothing behind: its key may be forked again, after the parent's turn.
-    const forked = take(copy === undefined ? undefined : { directory: copy })
+    const forked = take(deadline, copy === undefined ? undefined : { directory: copy })
       .then(({ native: fork, after }) => {
         if (ofCaller) {
           if (!fork.model) throw new Error(`agent ${parentKey}'s fork named no model to run on`);
@@ -2563,13 +2633,12 @@ class WorkflowOwner {
         cwd,
         execution,
         ...(forkSpec.instructions === undefined ? {} : { instructions: forkSpec.instructions }),
-        ...(forkSpec.labels === undefined ? {} : { labels: forkSpec.labels }),
         ...(seated ? { occupant: seated.occupant } : {}),
         ...(seated?.webSearch ? { webSearch: true } : {}),
         ...(given ? { skills: given } : {}),
         ...(home ? { home } : {}),
         ...(continues ? { continues } : {}),
-        ...paneOptions(identity),
+        ...identity.asked,
       }),
       // The target as it stands when `fork` is called, waited for once the fork is made.
       layoutFallback: forked.then(besideAtFork, () => undefined),
@@ -2627,6 +2696,10 @@ class WorkflowOwner {
   ): void {
     state.then(
       () => {
+        const entry = this.#agents.get(accounted.key);
+        const skills = this.options.skills.of(accounted.key);
+        const pane = entry && paneOf(entry);
+        const seat = this.options.sandboxes.admitted(accounted.key);
         this.options.events.event({
           kind: "agent-opened",
           agent: accounted.key,
@@ -2634,17 +2707,26 @@ class WorkflowOwner {
           harness: accounted.execution.harness,
           cwd: accounted.cwd,
           ...(accounted.home === undefined ? {} : { home: accounted.home }),
+          ...(seat ? { sandbox: seat.sandbox, domains: seat.domains } : {}),
           ...(as && "caller" in as ? { caller: true } : {}),
+          ...(skills
+            ? {
+                skills: {
+                  skills: skills.skills,
+                  ...(skills.home === undefined ? {} : { home: skills.home }),
+                },
+              }
+            : {}),
+          ...(pane ? { pane } : {}),
         });
         // A fork's session is made before its first operation names it.
         if (!as || !("fork" in as)) return;
-        for (const id of accounted.sessions()) {
-          this.options.events.event({
-            kind: "session-known",
-            session: { harness: accounted.execution.harness, id },
-            agent: accounted.key,
-          });
-        }
+        const { harness } = accounted.execution;
+        this.options.sessionLines.known(
+          accounted.key,
+          accounted.sessions().map((id) => ({ harness, id })),
+          this.placeOf(accounted.key),
+        );
       },
       () => undefined,
     );
@@ -2690,24 +2772,60 @@ class WorkflowOwner {
       );
   }
 
-  /** Where each pane agent's pane went, as its host reported it, in the order opened. */
+  /** Where each TUI agent's pane went, as its host reported it, in the order opened. */
   panes(): AgentPaneRecord[] {
     return [...this.#agents].flatMap(([agent, entry]) => {
-      const placed = entry.opening?.sessions.harness?.pane?.();
-      if (!placed) return [];
-      const { layout, keepPane } = entry.identity;
-      return [
-        {
-          callPath: [],
-          agent,
-          ...(layout === undefined ? {} : { layout }),
-          ...(keepPane === undefined ? {} : { keepPane }),
-          placed,
-        },
-      ];
+      const pane = paneOf(entry);
+      return pane ? [{ callPath: [], agent, ...pane }] : [];
     });
   }
 
+  /**
+   * Where an agent's sessions live, once it is known: its own harness home, the sandbox that home is
+   * in, and the skills its harness was given, which `awf open` reopens (story 042).
+   */
+  private placeOf(key: string): SessionPlace {
+    const home = this.#agents.get(key)?.opening?.accounted.home;
+    const sandbox = this.options.sandboxes.sessionSandbox(key);
+    const skills = this.#givenSkills.get(key);
+    return {
+      ...(home === undefined ? {} : { home }),
+      ...(sandbox ? { sandbox } : {}),
+      ...(skills ? { skills: { names: [...skills.names], directory: skills.directory } } : {}),
+    };
+  }
+
+  /** A session an agent's `wfa` named: recorded at once, less one a fork or parent holds. */
+  private launcherReported(
+    key: string,
+    harness: HarnessKind,
+    sessions: AgentSessions,
+    id: string,
+  ): void {
+    sessions.launcher.add(id);
+    this.options.sessionLines.known(
+      key,
+      reportedSessions(sessions).map((session) => ({ harness, id: session })),
+      this.placeOf(key),
+    );
+  }
+
+  /**
+   * Every agent's sessions as its close left them: one that moved in a compaction or fork at close,
+   * or that its harness saw after its last operation, is what the next continue resumes.
+   */
+  recordSessions(): void {
+    for (const [key, entry] of this.#agents) {
+      if (!entry.opening) continue;
+      const { harness } = entry.opening.accounted.execution;
+      this.options.sessionLines.known(
+        key,
+        reportedSessions(entry.opening.sessions).map((id) => ({ harness, id })),
+        this.placeOf(key),
+      );
+    }
+  }
+
   /** A reopened agent names the sandbox it runs in, or none: a different one is a conflict. */
   private async assertSameSandbox(
     key: string,
@@ -2726,21 +2844,22 @@ class WorkflowOwner {
   }
 }
 
+/** An agent's pane as its workflow wrote it and as its host placed it; undefined for no pane. */
+function paneOf(entry: AgentEntry): Omit<AgentPaneRecord, "callPath" | "agent"> | undefined {
+  const placed = entry.opening?.sessions.harness?.pane?.();
+  if (!placed) return undefined;
+  const { pane } = entry.identity;
+  return { ...(pane === undefined ? {} : { pane }), placed };
+}
+
+// What a wait takes of it is type-only, and `asSource` marks it at run time.
+// biome-ignore lint/correctness/noUnusedVariables: merged into the class below.
+interface LogicalAgent extends Source<Taken<AgentEnded>> {}
+
+// biome-ignore lint/suspicious/noUnsafeDeclarationMerging: the interface adds a type-only member.
 class LogicalAgent implements AgentRef {
   readonly [PARTICIPANT] = true as const;
   readonly #operationStops = new Set<(stop: OperationStop) => Promise<void>>();
-  readonly #operations = new Map<
-    string,
-    {
-      spec: AgentRunTextSpec | AgentRunStructuredSpec<JsonValue>;
-      result: Promise<RunResult<JsonValue>>;
-    }
-  >();
-  readonly #compactions = new Map<
-    string,
-    { spec: CompactSpec; result: Promise<TurnOutcome<string>> }
-  >();
-  readonly #sets = new Map<string, { spec: SettingsSpec; result: Promise<TurnOutcome<null>> }>();
   /** Its settings now; see `AgentRef.execution`. */
   #execution: AgentExecution;
   /** What each `set` queued and not yet settled changes, in queue order. */
@@ -2781,6 +2900,8 @@ class LogicalAgent implements AgentRef {
       execution: AgentExecution;
       session: HarnessSession;
       slots: ResultSlotRegistry;
+      /** Numbers its operations, `{key}.{n}`. */
+      ops: OpIds;
       endpoint: string;
       /** The path this agent is told to run; see `installAgentLauncher`. */
       launcher: string;
@@ -2789,6 +2910,8 @@ class LogicalAgent implements AgentRef {
       progress: RunProgress;
       recordTurn: RecordTurn;
       events: RunEventLog;
+      /** Records the sessions it is seen with, in `operation` when one is named. */
+      sessionsKnown(sessions: readonly NativeSessionRef[], operation?: string): void;
       track<T>(promise: Promise<T>): Promise<T>;
       isRunClosing(): boolean;
       /** Throws when no turn may start: the attempt is looking on for values it needs. */
@@ -2804,14 +2927,16 @@ class LogicalAgent implements AgentRef {
        */
       fork(
         spec: AgentForkSpec,
-        take: ((into?: SessionCopy) => Promise<TakenFork>) | string,
+        take: TakeFork | string,
         settings: AgentExecution,
       ): Promise<AgentRef>;
-      /** As the workflow wrote it; decides, at close, whether its pane stays. */
+      /** The workflow ends it: the run tears it down and its key is not opened again. */
+      close(reason: string | undefined): Promise<boolean>;
+      /** As the operator gave it; decides, at close, whether its pane stays. */
       keepPane(): KeepPane | undefined;
       /** As the workflow's last open of it gave it. */
       keepAlive(): KeepAlive | undefined;
-      /** Its window when `keepAlive` gives no `timeoutMs`. */
+      /** Its window when `keepAlive` gives no `window`. */
       defaultWindowMs: number;
       /** The run's time, which its window is measured on. */
       now: () => number;
@@ -2825,7 +2950,7 @@ class LogicalAgent implements AgentRef {
     const restored = options.turns?.restored();
     if (restored)
       this.#started = {
-        ref: turnRef(options.key, restored.turn, async () => false),
+        ref: turnRef(restored.turn, async () => false),
         meta: restored.meta,
         ended: true,
         done: Promise.resolve(),
@@ -2865,7 +2990,7 @@ class LogicalAgent implements AgentRef {
   liveUntil(now = this.options.now()): number | undefined {
     const keepAlive = this.options.keepAlive();
     if (this.#closed || !keepAlive || this.#lastEnd === undefined) return undefined;
-    const until = this.#lastEnd + (keepAlive.timeoutMs ?? this.options.defaultWindowMs);
+    const until = this.#lastEnd + (keepAlive.windowMs ?? this.options.defaultWindowMs);
     return until > now ? until : undefined;
   }
 
@@ -2928,8 +3053,12 @@ class LogicalAgent implements AgentRef {
 
   async start(spec: AgentStartSpec): Promise<StartedTurn> {
     const { turns } = this.options;
-    if (!turns) return unavailable("AgentRef.start");
+    if (!turns)
+      throw new Error(
+        `agent ${this.key}: start() is for a workflow with events, at whose waits its end arrives; run() waits for the end here`,
+      );
     if (this.#closed) throw new Error("logical agent is closed");
+    turns.checkDeclared();
     const inTool = refusedInTool(this.key, "start()");
     if (inTool) throw inTool;
     const scope = scopes.getStore();
@@ -2940,12 +3069,12 @@ class LogicalAgent implements AgentRef {
     const refused = this.#refusedWhileStarted("start");
     if (refused) throw refused;
     const { meta = null, ...run } = spec;
-    const id = run.id ?? randomUUID();
+    const id = randomUUID();
     if (!isJsonValue(meta)) throw new Error("a turn's meta is a JSON value");
     const ended = Promise.withResolvers<void>();
     let written: TurnOutcome<JsonValue>["kind"] | undefined;
     const started = {
-      ref: turnRef(this.key, id, async (reason?: string) => {
+      ref: turnRef(id, async (reason?: string) => {
         if (started.ended) return false;
         // Its turn waits for the handler, which would wait for the turn's end.
         const inTool = refusedInTool(this.key, "cancel()");
@@ -2976,13 +3105,13 @@ class LogicalAgent implements AgentRef {
     this.#launching = true;
     let launched: Promise<RunResult<JsonValue>>;
     try {
-      launched = outsideTools(() => this.run({ ...run, id } as AgentRunStructuredSpec<JsonValue>));
+      launched = outsideTools(() => this.#runTurn(run, id));
     } catch (error) {
       launched = Promise.reject(error);
     } finally {
       this.#launching = false;
     }
-    // Tracked until the end is in the mailbox, so the run doesn't park with a turn's end on its way.
+    // Tracked until the end is written, so the run doesn't park with a turn's end on its way.
     this.options.track(
       launched
         .then(
@@ -3023,11 +3152,12 @@ class LogicalAgent implements AgentRef {
       );
   }
 
-  is<Meta extends JsonValue = JsonValue, T extends JsonValue = JsonValue>(event: {
-    readonly name: string;
-    readonly from: string;
-  }): event is AgentEndedEvent<Meta, T> & Matched {
-    return event.name === "agent:ended" && event.from === this.key;
+  is<
+    Meta extends JsonValue = JsonValue,
+    T extends JsonValue = JsonValue,
+    E extends EventLike = EventLike,
+  >(event: E): event is E & AgentEndOf<Meta, T> {
+    return matches(event, { name: "agent:ended", from: this.key });
   }
 
   run(spec: AgentRunTextSpec): Promise<RunResult<string>>;
@@ -3035,51 +3165,24 @@ class LogicalAgent implements AgentRef {
   run<T extends JsonValue>(
     spec: AgentRunTextSpec | AgentRunStructuredSpec<T>,
   ): Promise<RunResult<string | T>> {
-    if (this.#closed) return Promise.reject(new Error("logical agent is closed"));
-    const refused = this.#refusedWhileStarted("run");
-    if (refused) return Promise.reject(refused);
-    const scope = scopes.getStore();
-    try {
-      scope?.assertAccepting();
-      this.options.checkOperation();
-    } catch (error) {
-      return Promise.reject(error);
-    }
+    return this.#runTurn(spec, randomUUID()) as Promise<RunResult<string | T>>;
+  }
+
+  /** A turn under `id`: `start()`'s, which its end is recorded by, or a new one. */
+  #runTurn(
+    spec: AgentRunTextSpec | AgentRunStructuredSpec<JsonValue>,
+    id: TurnId,
+  ): Promise<RunResult<JsonValue>> {
+    const admitted = this.#admit<RunResult<JsonValue>, AbsoluteDeadline | undefined>(
+      "run",
+      { checkOperation: true },
+      (scope) => this.operationDeadline(spec, scope),
+    );
+    if ("rejected" in admitted) return admitted.rejected;
+    const { scope, prepared: deadline } = admitted;
     const opensWindow = !inTimeoutHandler();
-    const id = spec.id ?? randomUUID();
-    const completeSpec = structuredClone({ ...spec, id }) as
-      | AgentRunTextSpec
-      | AgentRunStructuredSpec<JsonValue>;
-    const existing = this.#operations.get(id);
-    if (existing) {
-      if (!isDeepStrictEqual(existing.spec, completeSpec)) {
-        const rejected = Promise.reject<RunResult<string | T>>(
-          new Error(`turn id ${id} was reused with a different specification`),
-        );
-        scope?.track(rejected);
-        return rejected;
-      }
-      scope?.track(existing.result);
-      return existing.result as Promise<RunResult<string | T>>;
-    }
-    let deadline: AbsoluteDeadline | undefined;
-    try {
-      deadline = this.operationDeadline(spec, scope);
-      const recoveryDeadline = spec.nudge ? spec.nudge.deadline : undefined;
-      if (recoveryDeadline) {
-        assertDeadlineValue(recoveryDeadline);
-        deadline = earlierDeadline(deadline, recoveryDeadline);
-      }
-    } catch (error) {
-      const rejected = Promise.reject<RunResult<string | T>>(error);
-      scope?.track(rejected);
-      return rejected;
-    }
-    const result = this.queue(async () => {
-      if (this.#closed || this.options.isRunClosing()) {
-        throw new Error("logical agent is closed");
-      }
-      scope?.assertActive();
+    const completeSpec: TurnSpec = structuredClone({ ...spec, id });
+    const result = this.#queueActive(scope, async () => {
       const cancelled = this.#cancelledTurns.get(id);
       if (cancelled !== undefined) {
         this.#cancelledTurns.delete(id);
@@ -3093,7 +3196,19 @@ class LogicalAgent implements AgentRef {
       }
       const tags = tagsOf(scope, completeSpec.label);
       // Drawn here, so a turn that throws before it is delivered is still written as failed.
-      const operation = this.operationLog(randomUUID(), "turn", tags);
+      let schema: JsonSchema | undefined;
+      try {
+        schema = resultSchema(completeSpec.schema);
+      } catch {
+        // Thrown again as the turn runs, under its id, so it is written as failed.
+      }
+      const { id: drawn, lost } = this.options.ops.draw(this.key, {
+        kind: "turn",
+        ...this.opWhere(tags),
+        question: completeSpec.prompt,
+        ...(schema === undefined ? {} : { schema }),
+      });
+      const operation = this.operationLog(drawn, "turn", tags, lost);
       this.options.progress.turnStarted(this.key, tags);
       try {
         const settled = await this.executeOperation(completeSpec, scope, deadline, operation);
@@ -3107,54 +3222,25 @@ class LogicalAgent implements AgentRef {
         await this.options.afterOperation?.();
       }
     });
-    const tracked = this.options.track(result);
-    scope?.track(tracked);
-    this.#operations.set(id, { spec: completeSpec, result: tracked });
-    return tracked as Promise<RunResult<string | T>>;
+    return this.#tracked(scope, result);
   }
 
   compact(spec: CompactSpec): Promise<TurnOutcome<string>> {
-    if (this.#closed) return Promise.reject(new Error("logical agent is closed"));
-    const refused = this.#refusedWhileStarted("compact");
-    if (refused) return Promise.reject(refused);
-    const scope = scopes.getStore();
-    try {
-      scope?.assertAccepting();
-      this.options.checkOperation();
-    } catch (error) {
-      return Promise.reject(error);
-    }
-    const id = spec.id ?? randomUUID();
-    const completeSpec = structuredClone({ ...spec, id });
-    const existing = this.#compactions.get(id);
-    if (existing) {
-      if (!isDeepStrictEqual(existing.spec, completeSpec)) {
-        const rejected = Promise.reject<TurnOutcome<string>>(
-          new Error(`compaction id ${id} was reused with a different specification`),
-        );
-        scope?.track(rejected);
-        return rejected;
-      }
-      scope?.track(existing.result);
-      return existing.result;
-    }
-    let deadline: AbsoluteDeadline;
-    try {
-      deadline = harnessDeadline(this.operationDeadline(spec, scope));
-    } catch (error) {
-      const rejected = Promise.reject<TurnOutcome<string>>(error);
-      scope?.track(rejected);
-      return rejected;
-    }
-    const result = this.queue(async () => {
-      if (this.#closed || this.options.isRunClosing()) {
-        throw new Error("logical agent is closed");
-      }
-      scope?.assertActive();
+    const admitted = this.#admit<TurnOutcome<string>, AbsoluteDeadline>(
+      "compact",
+      { checkOperation: true },
+      (scope) => harnessDeadline(this.operationDeadline(spec, scope)),
+    );
+    if ("rejected" in admitted) return admitted.rejected;
+    const { scope, prepared: deadline } = admitted;
+    const id = randomUUID();
+    const result = this.#queueActive(scope, async () => {
       const tags = tagsOf(scope);
-      const operation = this.operationLog(randomUUID(), "compact", tags);
+      const drawn = this.options.ops.draw(this.key, { kind: "compact", ...this.opWhere(tags) });
+      const operation = this.operationLog(drawn.id, "compact", tags);
       this.options.progress.turnStarted(this.key, tags, "compact");
       try {
+        if (drawn.lost !== undefined) throw new Error(drawn.lost);
         const outcome = await this.executeCompaction(id, spec.prompt, deadline, scope, operation);
         this.turnEnded(outcome, "compact");
         return outcome;
@@ -3166,47 +3252,23 @@ class LogicalAgent implements AgentRef {
         await this.options.afterOperation?.();
       }
     });
-    const tracked = this.options.track(result);
-    scope?.track(tracked);
-    this.#compactions.set(id, { spec: completeSpec, result: tracked });
-    return tracked;
+    return this.#tracked(scope, result);
   }
 
   /** Not a turn: progress counts none for it, and it asks the model nothing. */
   set(spec: SettingsSpec): Promise<TurnOutcome<null>> {
-    if (this.#closed) return Promise.reject(new Error("logical agent is closed"));
-    const refused = this.#refusedWhileStarted("set");
-    if (refused) return Promise.reject(refused);
-    const scope = scopes.getStore();
-    try {
-      scope?.assertAccepting();
-    } catch (error) {
-      return Promise.reject(error);
-    }
-    const id = spec.id ?? randomUUID();
-    const completeSpec = structuredClone({ ...spec, id });
-    const existing = this.#sets.get(id);
-    if (existing) {
-      if (!isDeepStrictEqual(existing.spec, completeSpec)) {
-        const rejected = Promise.reject<TurnOutcome<null>>(
-          new Error(`settings id ${id} was reused with a different specification`),
-        );
-        scope?.track(rejected);
-        return rejected;
-      }
-      scope?.track(existing.result);
-      return existing.result;
-    }
-    let change: SettingsChange;
-    let deadline: AbsoluteDeadline;
-    try {
-      change = this.settingsChange(spec);
-      deadline = harnessDeadline(this.operationDeadline(spec, scope));
-    } catch (error) {
-      const rejected = Promise.reject<TurnOutcome<null>>(error);
-      scope?.track(rejected);
-      return rejected;
-    }
+    const admitted = this.#admit<
+      TurnOutcome<null>,
+      { change: SettingsChange; deadline: AbsoluteDeadline }
+    >("set", { checkOperation: false }, (scope) => ({
+      change: this.settingsChange(spec),
+      deadline: harnessDeadline(this.operationDeadline(spec, scope)),
+    }));
+    if ("rejected" in admitted) return admitted.rejected;
+    const {
+      scope,
+      prepared: { change, deadline },
+    } = admitted;
     this.#pendingSets.push(change);
     const result = this.queue(async () => {
       try {
@@ -3221,12 +3283,68 @@ class LogicalAgent implements AgentRef {
         this.#pendingSets.splice(this.#pendingSets.indexOf(change), 1);
       }
     });
+    return this.#tracked(scope, result);
+  }
+
+  /**
+   * The checks before an operation is queued, in order: the agent open, no started turn in its
+   * way, the scope accepting and, with `checkOperation`, the stage; then `prepare`, whose refusal
+   * the scope tracks. A refusal is a rejection, never a throw.
+   */
+  #admit<T, P>(
+    what: string,
+    options: { checkOperation: boolean },
+    prepare: (scope: ExecutionScope | undefined) => P,
+  ): { scope: ExecutionScope | undefined; prepared: P } | { rejected: Promise<T> } {
+    if (this.#closed) return { rejected: Promise.reject(new Error("logical agent is closed")) };
+    const refused = this.#refusedWhileStarted(what);
+    if (refused) return { rejected: Promise.reject(refused) };
+    const scope = scopes.getStore();
+    try {
+      scope?.assertAccepting();
+      if (options.checkOperation) this.options.checkOperation();
+    } catch (error) {
+      return { rejected: Promise.reject(error) };
+    }
+    try {
+      return { scope, prepared: prepare(scope) };
+    } catch (error) {
+      const rejected = Promise.reject<T>(error);
+      scope?.track(rejected);
+      return { rejected };
+    }
+  }
+
+  /** `work` once the queue reaches it, the agent and run still open and `scope` still active. */
+  #queueActive<T>(scope: ExecutionScope | undefined, work: () => Promise<T>): Promise<T> {
+    return this.queue(async () => {
+      if (this.#closed || this.options.isRunClosing()) {
+        throw new Error("logical agent is closed");
+      }
+      scope?.assertActive();
+      return work();
+    });
+  }
+
+  #tracked<T>(scope: ExecutionScope | undefined, result: Promise<T>): Promise<T> {
     const tracked = this.options.track(result);
     scope?.track(tracked);
-    this.#sets.set(id, { spec: completeSpec, result: tracked });
     return tracked;
   }
 
+  /**
+   * Whose an operation is, the settings it runs at and where, as its `op.json` says: what its spend
+   * is read with, by the next attempt when this one never settles it.
+   */
+  private opWhere(tags: { stage?: string }): AgentOp & { stage?: string } {
+    return {
+      agent: this.key,
+      execution: this.#execution,
+      cwd: this.options.ledger.cwd(),
+      ...(tags.stage === undefined ? {} : { stage: tags.stage }),
+    };
+  }
+
   /**
    * An operation's start and failure in the run's event log, under the id its record keeps. Its
    * settling is the turn line `recordTurn` writes.
@@ -3235,10 +3353,12 @@ class LogicalAgent implements AgentRef {
     operationId: string,
     of: TurnRecord["kind"],
     tags: OperationTags,
+    unrecorded?: string,
   ): OperationLog {
     let deliveredAt: number | undefined;
     /** Named by its host before delivery, for its start to carry. */
     const named: string[] = [];
+    // Its sessions as of now, recorded before the line that names it, as a turn's are.
     const fields = () => {
       const { callPath, sessions, ...record } = this.options.ledger.unsettled(
         operationId,
@@ -3248,16 +3368,16 @@ class LogicalAgent implements AgentRef {
       );
       const harness = this.#execution.harness;
       const fresh = named.filter((id) => !sessions.some((known) => known.id === id));
-      return {
-        of,
-        callPath,
-        ...record,
-        sessions: [...sessions, ...fresh.map((id) => ({ harness, id }))],
-      };
+      this.options.sessionsKnown(
+        [...sessions, ...fresh.map((id) => ({ harness, id }))],
+        operationId,
+      );
+      return { of, callPath, ...record };
     };
     return {
       operationId,
       tags,
+      ...(unrecorded === undefined ? {} : { unrecorded }),
       delivered: (at: number) => {
         deliveredAt = at;
         this.#hasRun = true;
@@ -3269,11 +3389,7 @@ class LogicalAgent implements AgentRef {
           named.push(id);
           return;
         }
-        this.options.events.event({
-          kind: "session-known",
-          session: { harness: this.#execution.harness, id },
-          operationId,
-        });
+        this.options.sessionsKnown([{ harness: this.#execution.harness, id }], operationId);
       },
       failed: (error: unknown) =>
         this.options.events.event({
@@ -3284,7 +3400,7 @@ class LogicalAgent implements AgentRef {
     };
   }
 
-  /** A turn or compaction that settled, as the view shows it and `turns.jsonl` keeps it. */
+  /** A turn or compaction that settled, as the view shows it and `log.jsonl` keeps it. */
   private turnEnded(
     outcome: TurnOutcome<JsonValue>,
     kind: TurnRecord["kind"],
@@ -3298,6 +3414,7 @@ class LogicalAgent implements AgentRef {
     this.#last = outcome.kind;
     const reason = "reason" in outcome ? outcome.reason : undefined;
     this.options.progress.turnSettled(this.key, outcome.kind, reason);
+    this.options.sessionsKnown(outcome.usage.sessions, outcome.usage.operationId);
     this.options.recordTurn(outcome, kind);
   }
 
@@ -3306,7 +3423,6 @@ class LogicalAgent implements AgentRef {
     const refused = this.#refusedWhileStarted("fork");
     if (refused) return Promise.reject(refused);
     const scope = scopes.getStore();
-    const deadline = this.deadlineCeiling(scope);
     const { session, execution } = this.options;
     const settings = this.queuedExecution();
     const fork = session.fork?.bind(session);
@@ -3325,12 +3441,8 @@ class LogicalAgent implements AgentRef {
     }
     // The harness bounds its fork by this deadline and stops it there, so the session is idle again
     // when the fork rejects.
-    const take = (into?: SessionCopy) =>
-      this.queue(async () => {
-        if (this.#closed || this.options.isRunClosing()) {
-          throw new Error("logical agent is closed");
-        }
-        scope?.assertActive();
+    const take: TakeFork = (deadline, into) =>
+      this.#queueActive(scope, async () => {
         // The fork was opened at the settings it would copy; a `set` before it that did not take
         // would leave it recording settings it never ran at.
         if (!isDeepStrictEqual(sessionSettings(this.#execution), sessionSettings(settings))) {
@@ -3348,19 +3460,12 @@ class LogicalAgent implements AgentRef {
     }
   }
 
-  /** `deadline` or `timeoutMs`, never later than the scope's or the run's; else the earlier of those. */
+  /** Its `timeout`, never later than the scope's or the run's; else the earlier of those. */
   private operationDeadline(
-    spec: { deadline?: AbsoluteDeadline; timeoutMs?: number },
+    spec: { timeout?: Timeout },
     scope: ExecutionScope | undefined,
   ): AbsoluteDeadline | undefined {
-    if (spec.deadline && spec.timeoutMs !== undefined) {
-      throw new Error("an operation cannot specify both deadline and timeoutMs");
-    }
-    const ceiling = this.deadlineCeiling(scope);
-    if (spec.timeoutMs !== undefined) return deadlineWithin(spec.timeoutMs, ceiling);
-    if (!spec.deadline) return ceiling;
-    assertDeadlineValue(spec.deadline);
-    return earlierDeadline(spec.deadline, ceiling);
+    return boundedDeadline(spec.timeout, this.deadlineCeiling(scope));
   }
 
   /** The deadlines around an operation: its scope's and the run's, if either has one. */
@@ -3381,9 +3486,19 @@ class LogicalAgent implements AgentRef {
         `agent ${this.key} is the calling session, whose model and effort are the operator's`,
       );
     }
+    const removed = Object.keys(spec).filter(
+      (field) =>
+        REMOVED_SETTINGS_FIELDS.has(field) && (spec as Record<string, unknown>)[field] != null,
+    );
+    if (removed.length > 0) {
+      const bound = removed.some((field) => field !== "id") ? ": bound it with timeout" : "";
+      throw new Error(`set takes no ${removed.join(", ")}${bound}`);
+    }
     // A workflow is untyped JavaScript at run time: a harness or placement asked for must not be
     // dropped in silence.
-    const others = Object.keys(spec).filter((field) => !SETTINGS_FIELDS.has(field));
+    const others = Object.keys(spec).filter(
+      (field) => !SETTINGS_FIELDS.has(field) && !REMOVED_SETTINGS_FIELDS.has(field),
+    );
     if (others.length > 0) {
       throw new Error(
         `set changes an agent's model and effort, not its ${others.join(", ")}: another harness or placement is another agent`,
@@ -3432,7 +3547,7 @@ class LogicalAgent implements AgentRef {
       };
     }
     const next: AgentExecution = { ...this.#execution, ...change };
-    const pane = placementOf(next) === "pane";
+    const pane = placementOf(next) === "tui";
     let cancelled: string | undefined;
     // A pane's switch waits on its screen; a scope cancelled meanwhile closes the agent, as a
     // half-made switch leaves it at settings nobody knows. A headless one takes no time.
@@ -3440,7 +3555,7 @@ class LogicalAgent implements AgentRef {
       ? scope?.add(async (stop) => {
           cancelled = stop.reason;
           this.#last = "cancelled";
-          await this.close(stop.reason);
+          await this.terminate(stop.reason);
         })
       : undefined;
     try {
@@ -3477,10 +3592,15 @@ class LogicalAgent implements AgentRef {
     if (this.options.execution.caller) return;
     // Before its outcome is recorded: whether its pane stays turns on how this one ended.
     this.#last = ended;
-    void this.close(reason).catch(() => undefined);
+    void this.terminate(reason).catch(() => undefined);
   }
 
-  close(reason?: string): Promise<void> {
+  close(reason?: string): Promise<boolean> {
+    return this.options.close(reason);
+  }
+
+  /** What `close()`, a failed operation and the run's end each come to. */
+  terminate(reason?: string): Promise<void> {
     const first = !this.#closed;
     this.#closed = true;
     if (first) {
@@ -3513,13 +3633,17 @@ class LogicalAgent implements AgentRef {
     // Once what it was running has ended, so its last operation's line comes first.
     if (first) {
       const { key, execution } = this.options;
-      const stoppedLine = () =>
+      const stoppedLine = () => {
+        const placed = this.options.session.pane?.();
         this.options.events.event({
           kind: "agent-stopped",
           agent: key,
           callPath: [],
           harness: execution.harness,
+          ...(placed?.kept ? { kept: true } : {}),
+          ...(placed?.notKept === undefined ? {} : { notKept: placed.notKept }),
         });
+      };
       closed.then(stoppedLine, stoppedLine);
     }
     return closed;
@@ -3557,22 +3681,21 @@ class LogicalAgent implements AgentRef {
   }
 
   private async executeOperation(
-    spec: AgentRunTextSpec | AgentRunStructuredSpec<JsonValue>,
+    spec: TurnSpec,
     scope: ExecutionScope | undefined,
     operationDeadline: AbsoluteDeadline | undefined,
     operation: OperationLog,
   ): Promise<RunResult<JsonValue>> {
     const nudge = spec.nudge === false ? undefined : (spec.nudge ?? this.defaultNudge());
     scope?.assertActive();
-    if (nudge?.deadline) assertDeadlineValue(nudge.deadline);
     return this.executeWaitingOperation(spec, scope, operationDeadline, operation, nudge);
   }
 
   private async executeWaitingOperation(
-    spec: AgentRunTextSpec | AgentRunStructuredSpec<JsonValue>,
+    spec: TurnSpec,
     scope: ExecutionScope | undefined,
     initial: AbsoluteDeadline | undefined,
-    { operationId, tags, delivered, session }: OperationLog,
+    { operationId, tags, delivered, session, unrecorded }: OperationLog,
     nudge: Exclude<AgentRunTextSpec["nudge"], false>,
   ): Promise<RunResult<JsonValue>> {
     const schema = resultSchema(spec.schema);
@@ -3634,7 +3757,7 @@ class LogicalAgent implements AgentRef {
           ].join("\n")
         : "");
     const events = createOperationEvents(this.options.runDir, operationId);
-    const messages = this.operationMessages(operationId, `${spec.id!}:message`, {
+    const messages = this.operationMessages(operationId, `${spec.id}:message`, {
       deadline: () => harnessDeadline(deadline),
       authored,
       session,
@@ -3645,6 +3768,7 @@ class LogicalAgent implements AgentRef {
       event: events.record,
       operationId,
       agentId: this.key,
+      ...(unrecorded === undefined ? {} : { unrecorded }),
       question: spec.prompt,
       schema,
       ...(deadline ? { deadline } : {}),
@@ -3666,7 +3790,7 @@ class LogicalAgent implements AgentRef {
         this.options.session
           .start(
             {
-              id: spec.id!,
+              id: spec.id,
               prompt: [
                 operationPrompt(prompt, schema, this.options.launcher, operationId),
                 toolsLesson(
@@ -3686,7 +3810,7 @@ class LogicalAgent implements AgentRef {
           .then((turn) => this.confirmed(operationId, joined?.numbers ?? [], turn)),
       successor: (turn, sequence, deliverySignal) =>
         turn.nudge({
-          id: `${spec.id!}:check-in:${sequence}`,
+          id: `${spec.id}:check-in:${sequence}`,
           deadline: harnessDeadline(deadline),
           deliverySignal,
           prompt: checkInPrompt(recoveryPrompt),
@@ -3700,24 +3824,25 @@ class LogicalAgent implements AgentRef {
           return settle(request);
         };
         this.#operationStops.add(stop);
-        this.#stopsByTurn.set(spec.id!, stop);
+        this.#stopsByTurn.set(spec.id, stop);
         const remove = scope?.add(stop);
         return () => {
           this.#operationStops.delete(stop);
-          if (this.#stopsByTurn.get(spec.id!) === stop) this.#stopsByTurn.delete(spec.id!);
+          if (this.#stopsByTurn.get(spec.id) === stop) this.#stopsByTurn.delete(spec.id);
           remove?.();
         };
       },
       phase: (phase, reason, until) =>
         this.options.progress.turnPhase(this.key, phase, reason, until),
       delivered,
+      keepScreen: (turn) => keepScreen(this.options.runDir, operationId, turn),
     })
       .catch(
         (error: unknown): SupervisedOutcome => ({
           kind: "failed",
           reason: messageOf(error),
           cleanupUnresolved: true,
-          charges: [],
+          reportedCosts: [],
           settledAt: Date.now(),
         }),
       )
@@ -3737,7 +3862,7 @@ class LogicalAgent implements AgentRef {
         ...(outcome.deliveredAt === undefined ? {} : { deliveredAt: outcome.deliveredAt }),
         settledAt: outcome.settledAt,
       },
-      outcome.charges,
+      outcome.reportedCosts,
     );
     if (outcome.kind === "answered")
       return {
@@ -3883,7 +4008,10 @@ class LogicalAgent implements AgentRef {
     stage: ExecutionScope | undefined,
   ): Promise<void> {
     const { messaging } = this.options;
-    const operationId = randomUUID();
+    const { id: operationId, lost } = this.options.ops.draw(this.key, {
+      kind: "message",
+      ...this.opWhere(stage?.stage === undefined ? {} : { stage: stage.stage }),
+    });
     const ceiling = this.deadlineCeiling(stage)?.unixMilliseconds;
     let deadline = Math.min(Date.now() + messaging.limits.operationMs, ceiling ?? Infinity);
     messaging.opened({
@@ -3906,7 +4034,7 @@ class LogicalAgent implements AgentRef {
     let end: SupervisedOutcome["kind"] | undefined;
     try {
       const opening = messaging.take(operationId, "opens");
-      // Withdrawn before it could be shown: nothing to wake it for.
+      // Withdrawn before it could be shown: nothing to wake it for. Its folder stays, its number used.
       if (!opening) return;
       if (opening.deadline !== undefined) deadline = opening.deadline;
       const cause = { message: { from } };
@@ -3917,6 +4045,7 @@ class LogicalAgent implements AgentRef {
       const operation = this.operationLog(operationId, "turn", tags);
       this.options.progress.turnStarted(this.key, tags);
       try {
+        if (lost !== undefined) throw new Error(lost);
         const outcome = await this.superviseMessage(operationId, deadline, opening, {
           cause,
           tags,
@@ -4031,6 +4160,7 @@ class LogicalAgent implements AgentRef {
         phase: (phase, reason, until) =>
           this.options.progress.turnPhase(this.key, phase, reason, until),
         delivered: operation.delivered,
+        keepScreen: (turn) => keepScreen(this.options.runDir, operationId, turn),
         ...(this.options.livenessPolicy ? { policy: this.options.livenessPolicy } : {}),
       });
     } finally {
@@ -4047,7 +4177,7 @@ class LogicalAgent implements AgentRef {
         ...(outcome.deliveredAt === undefined ? {} : { deliveredAt: outcome.deliveredAt }),
         settledAt: outcome.settledAt,
       },
-      outcome.charges,
+      outcome.reportedCosts,
     );
     // Recorded `answered` with no value: it did what it was woken for, and takes no result.
     this.turnEnded(
@@ -4078,7 +4208,7 @@ class LogicalAgent implements AgentRef {
     const times: { deliveredAt?: number } = {};
     const settle = (
       native: HarnessTurnOutcome | "expired",
-      /** A compaction left to end on its own, whose charges come when it does. */
+      /** A compaction left to end on its own, whose reported costs come when it does. */
       later?: Promise<HarnessTurnOutcome>,
     ): TurnOutcome<string> => {
       const usage = entry.settle(
@@ -4086,7 +4216,7 @@ class LogicalAgent implements AgentRef {
           ...times,
           settledAt: Math.min(Date.now(), deadline.unixMilliseconds),
         },
-        native === "expired" ? [] : native.chargesUsd,
+        native === "expired" ? [] : native.reportedCostsUsd,
         later,
       );
       if (native === "expired") {
@@ -4134,7 +4264,7 @@ class LogicalAgent implements AgentRef {
         state: "failed",
         detail: messageOf(error),
         resultEvidence: { kind: "unavailable" },
-        chargesUsd: [],
+        reportedCostsUsd: [],
       });
     }
     times.deliveredAt = Date.now();
@@ -4148,8 +4278,14 @@ class LogicalAgent implements AgentRef {
           cancelTimer = scheduleAt(deadline, () => resolve("expired"));
         }),
       ]).finally(() => cancelTimer?.());
-      if (native === "expired") return settle(native, (await this.leaveFinishing(turn)).later);
-      return settle(native);
+      if (native === "expired") {
+        await keepScreen(this.options.runDir, operationId, turn);
+        return settle(native, (await this.leaveFinishing(turn)).later);
+      }
+      const outcome = settle(native);
+      if (!outcome.answered && outcome.kind !== "cancelled")
+        await keepScreen(this.options.runDir, operationId, turn);
+      return outcome;
     } finally {
       removeCanceller?.();
     }
@@ -4183,10 +4319,27 @@ function checkedWhen(when: unknown): string | Date {
   throw new Error('sleep is for a duration, "2h", or until a Date');
 }
 
-function checkedLabel(label: unknown): string | undefined {
-  if (label !== undefined && typeof label !== "string")
-    throw new Error("a wait's label is a string");
-  return label;
+/** Receive's options as given, checked: what a typed caller can't get wrong, a plain one can. */
+function receiveLabel(options: unknown): string | undefined {
+  if (options === undefined) return undefined;
+  if (typeof options !== "object" || options === null) throw new Error("receive takes { label? }");
+  // `take: "all"` was the default, so only "oldest" asked for what receive no longer does.
+  const { take } = options as { take?: unknown };
+  if (take !== undefined && take !== "all")
+    throw new Error(
+      "receive takes every event not yet acknowledged; wf.select takes one at a time",
+    );
+  if ("until" in options)
+    throw new Error("receive has no until: a timer, wf.timer(name, when), wakes it");
+  return labelOf((options as WaitOptions).label);
+}
+
+/** A wait's label, a function's asked now. */
+function labelOf(label: unknown): string | undefined {
+  const given = typeof label === "function" ? label() : label;
+  if (given !== undefined && typeof given !== "string")
+    throw new Error("a wait's label is a string, or a function that returns one");
+  return given;
 }
 
 /** A wait's branches, by name, checked: a race may give a duration where a select may not. */
@@ -4229,36 +4382,54 @@ function sourceTake(what: string, branch: string, source: unknown): WaitTake {
     throw new Error(
       `${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`,
-  );
+  if (typeof source === "object" && source !== null && startedTurns.has(source))
+    throw new Error(
+      `${what}'s ${branch} is a started turn: name its agent, { ${branch}: agent }, which has at most one`,
+    );
+  throw new Error(`${what}'s ${branch} is not a source: a timer, a signal, or an agent`);
 }
 
+/** The sources only a run of a workflow with events hears. */
+const HEARD_WITH_EVENTS: ReadonlySet<string> = new Set(["agent:ended", "participant:reply"]);
+
 /** One of the workflow's own events, by name, as a source. */
-function signalSource(name: string): unknown {
-  if (typeof name !== "string" || name.includes(":"))
-    throw new Error(`a signal is one of the workflow's own events, by name; not ${String(name)}`);
-  return source({ name }, { name });
+function signalSource(name: string, declared: ReadonlySet<string>): unknown {
+  if (typeof name !== "string")
+    throw new Error(
+      `a signal is one of the workflow's declared events, by name; not ${String(name)}`,
+    );
+  if (!declared.has(name))
+    throw new Error(
+      declared.size === 0
+        ? `signal ${name}: the workflow declares no events`
+        : `signal ${name}: the workflow declares no such event; its events are ${[...declared].join(", ")}`,
+    );
+  const awf = awfEventOf(name);
+  if (awf?.kind === "ended")
+    throw new Error(
+      `signal ${name}: an agent's end is waited on by naming the agent, { done: ${awf.key} }, not a signal`,
+    );
+  // `in.jsonl` keeps a reply under its record name, from the participant's key.
+  const take = awf ? { name: "participant:reply", from: awf.key } : { name };
+  return signalOf({ name }, take);
 }
 
 /** Timer `name`'s source. */
-function timerSource(mailbox: RunMailbox, name: string, due: string): Timer {
+function timerSource(waits: RunWaits, name: string, due: string): Timer {
   return source(
-    { name, due, cancel: () => mailbox.cancelTimer(name) },
+    { name, due, cancel: () => waits.cancelTimer(name) },
     { name: "timer:due", from: name },
   ) as unknown as Timer;
 }
 
-/** A started turn, as the code holds it: its id, its cancel, and a source of its end. */
-function turnRef(
-  agent: string,
-  id: string,
-  cancel: (reason?: string) => Promise<boolean>,
-): StartedTurn {
-  return source(
-    { id, cancel },
-    { name: "agent:ended", from: agent, turn: id },
-  ) as unknown as StartedTurn;
+/** The turns `start()` handed out, which a wait refuses by name. */
+const startedTurns = new WeakSet<object>();
+
+/** A started turn, as the code holds it: its id and its cancel. A wait names its agent. */
+function turnRef(id: string, cancel: (reason?: string) => Promise<boolean>): StartedTurn {
+  const turn = Object.freeze({ id, cancel });
+  startedTurns.add(turn);
+  return turn;
 }
 
 class ExecutionScope {
@@ -4435,6 +4606,17 @@ async function executeParallel<Item, Result>(
   }
 }
 
+/** How long reading a pane for an operation's evidence may hold up its release. */
+const SCREEN_READ_MS = 5_000;
+
+/** Keeps what `turn`'s pane shows, the evidence of an operation that ended without an answer. */
+async function keepScreen(runDir: string, operationId: string, turn: HarnessTurn): Promise<void> {
+  if (!turn.screen) return;
+  const deadline = { unixMilliseconds: Date.now() + SCREEN_READ_MS };
+  const screen = await waitForDeadline(turn.screen(), deadline).catch(() => undefined);
+  if (screen?.trim()) await writeScreen(runDir, operationId, screen).catch(() => undefined);
+}
+
 /**
  * Compaction keeps its existing bounded release behavior. Structured operations use the
  * supervisor, which requires confirmed native completion before returning an answer.
@@ -4521,16 +4703,21 @@ type Warn = (message: string, fields?: JsonObject, stage?: string) => void;
 type OperationLog = {
   operationId: string;
   tags: OperationTags;
+  /** Why its `op.json` wasn't written as it was drawn: a turn fails as its result slot would. */
+  unrecorded?: string;
   delivered(at: number): void;
   /** A session its host named while it ran: on its start if that is still to come. */
   session(id: string): void;
   failed(error: unknown): void;
 };
 
+/** A turn as the agent runs it: its spec, under the id it is recorded by. */
+type TurnSpec = (AgentRunTextSpec | AgentRunStructuredSpec<JsonValue>) & { id: TurnId };
 /** A native fork, and the parent's operation it was copied after: null when it ran none. */
 type TakenFork = { native: NativeFork; after: string | null };
+type TakeFork = (deadline: AbsoluteDeadline | undefined, into?: SessionCopy) => Promise<TakenFork>;
 
-/** A settled turn or compaction, kept in the run's `turns.jsonl`. */
+/** A settled turn or compaction, kept in the run's `log.jsonl`. */
 type RecordTurn = (outcome: TurnOutcome<JsonValue>, kind: TurnRecord["kind"]) => void;
 
 function pick<T extends object, K extends keyof T>(value: T, keys: readonly K[]): Pick<T, K> {
@@ -4693,46 +4880,99 @@ function withKnownEffort(execution: AgentExecution): AgentExecution {
 /** What `set` changes. */
 type SettingsChange = Partial<Pick<AgentExecution, "model" | "effort">>;
 
-const SETTINGS_FIELDS = new Set(["id", "model", "effort", "deadline", "timeoutMs"]);
+const SETTINGS_FIELDS = new Set(["model", "effort", "timeout"]);
+
+/** Removed in 0.1.0-beta.6; refused, as the switch would run otherwise than written. */
+const REMOVED_SETTINGS_FIELDS = new Set(["id", "deadline", "timeoutMs"]);
 
 function sessionSettings({ model, effort }: AgentExecution): SessionSettings {
   return { model, ...(effort === undefined ? {} : { effort }) };
 }
 
 /**
- * A pane is the default and is left unsaid, and `metered` is kept only where it means something,
+ * A TUI is the default and is left unsaid, and `metered` is kept only where it means something,
  * so the same agent always has one identity.
  */
 function storedPlacement(choice: PlacementChoice): PlacementChoice {
-  // A workflow is untyped JavaScript at run time; a misspelt placement must not become a pane.
+  knownPlacement(choice);
+  return placementOf(choice) === "headless"
+    ? { placement: "headless", ...(choice.metered === true ? { metered: true as const } : {}) }
+    : {};
+}
+
+/** A workflow is untyped JavaScript at run time; a misspelt placement must not become a TUI. */
+function knownPlacement(choice: PlacementChoice): void {
   if (
     choice.placement !== undefined &&
-    choice.placement !== "pane" &&
+    choice.placement !== "tui" &&
     choice.placement !== "headless"
   ) {
+    const renamed = (choice.placement as string) === "pane" ? ` ("pane" is now "tui")` : "";
     throw new Error(
-      `unknown placement ${JSON.stringify(choice.placement)}; expected pane or headless`,
+      `unknown placement ${JSON.stringify(choice.placement)}; expected tui or headless${renamed}`,
     );
   }
-  return placementOf(choice) === "headless"
-    ? { placement: "headless", ...(choice.metered === true ? { metered: true as const } : {}) }
-    : {};
 }
 
 /**
  * The parent's harness, model and effort, in the placement and at the effort the fork names, else
  * its parent's.
  */
-function forkExecution(parent: AgentExecution, spec: AgentForkSpec): AgentExecution {
+function forkExecution(parent: AgentExecution, runtime: ForkRuntime = {}): AgentExecution {
   const { placement: _placement, metered: _metered, ...target } = parent;
-  const choice = spec.placement === undefined && spec.metered === undefined ? parent : spec;
+  const choice =
+    runtime.placement === undefined && runtime.metered === undefined ? parent : runtime;
   return {
     ...target,
-    ...(spec.effort === undefined ? {} : { effort: spec.effort }),
+    ...(runtime.effort === undefined ? {} : { effort: runtime.effort }),
     ...storedPlacement(choice),
   };
 }
 
+const FORK_RUNTIME_FIELDS = ["placement", "metered", "effort"] as const;
+
+/** A fork's spec, its `runtime` checked: what a typed caller can't get wrong, a plain one can. */
+function forkSpecOf(spec: CallerForkSpec): CallerForkSpec {
+  const { runtime, ...rest } = spec;
+  // Removed in 0.1.0-beta.6; refused, as the fork would run otherwise than written.
+  const flat = FORK_RUNTIME_FIELDS.filter(
+    (field) => (rest as Record<string, unknown>)[field] !== undefined,
+  );
+  if (flat.length > 0)
+    throw new Error(
+      `agent ${spec.key}: a fork's ${flat.join(", ")} go in its runtime: fork({ key, runtime: { ${flat.join(", ")} } })`,
+    );
+  if (runtime === undefined) return rest;
+  if (typeof runtime !== "object" || runtime === null || Array.isArray(runtime)) {
+    throw new Error(
+      `agent ${spec.key}: a fork's runtime is { placement?, metered?, effort? }, not ${JSON.stringify(runtime)}`,
+    );
+  }
+  // A workflow is untyped JavaScript at run time; a harness or model asked for must not be dropped.
+  const others = Object.keys(runtime).filter(
+    (field) =>
+      !(FORK_RUNTIME_FIELDS as readonly string[]).includes(field) &&
+      (runtime as Record<string, unknown>)[field] !== undefined,
+  );
+  if (others.length > 0) {
+    throw new Error(
+      `agent ${spec.key}: a fork continues its parent's session on its harness and model; its runtime takes placement, metered and effort, not ${others.join(", ")}`,
+    );
+  }
+  const given = definedFields({
+    placement: runtime.placement,
+    metered: runtime.metered,
+    effort: runtime.effort,
+  });
+  return Object.keys(given).length === 0 ? rest : { ...rest, runtime: given };
+}
+
+function definedFields<T extends object>(fields: T): Partial<T> {
+  return Object.fromEntries(
+    Object.entries(fields).filter(([, value]) => value !== undefined),
+  ) as Partial<T>;
+}
+
 function constrainExistingExecution(
   selection: RuntimeSelection,
   existing: AgentExecution,
@@ -4757,6 +4997,7 @@ function constrainExistingExecution(
   if (selection.effort !== undefined && selection.effort !== existing.effort) {
     throw new Error("existing agent was opened at a different effort");
   }
+  knownPlacement(selection);
   const placed = placementOf(existing);
   if (
     (selection.placement !== undefined && placementOf(selection) !== placed) ||
@@ -4792,23 +5033,13 @@ function assertCompatibleAgent(
   if (spec.skills !== undefined && !isDeepStrictEqual(existing.skills, requested.skills)) {
     conflict(key, "skills");
   }
-  for (const field of ["instructions", "labels", "layout", "keepPane"] as const) {
+  for (const field of ["instructions", "pane"] as const) {
     if (spec[field] !== undefined && !isDeepStrictEqual(existing[field], requested[field])) {
       conflict(key, field);
     }
   }
 }
 
-function paneOptions({
-  layout,
-  keepPane,
-}: AgentIdentity): Pick<HarnessActivation, "layout" | "keepPane"> {
-  return {
-    ...(layout === undefined ? {} : { layout }),
-    ...(keepPane === undefined ? {} : { keepPane }),
-  };
-}
-
 function conflict(key: string, field: string): never {
   throw new Error(`agent ${key} is already open with different ${field}`);
 }
@@ -4817,22 +5048,14 @@ function stoppedError(key: string, reason: string): Error {
   return new Error(`agent ${key} was stopped (${reason}); its key is not opened again`);
 }
 
-function unavailable(name: string): Promise<never> {
-  return Promise.reject(new Error(`${name} is not implemented by the minimum workflow runner`));
-}
-
-/**
- * Each root agent's last native session in a run's turns, where its harness can resume it: what a
- * event run's continue reopens it on.
- */
-export function keptSessionsOf(turns: readonly TurnRecord[]): Map<string, NativeFork> {
-  const kept = new Map<string, NativeFork>();
-  for (const turn of turns) {
-    if ((turn.callPath?.length ?? 0) > 0) continue;
-    const session = turn.sessions.at(-1);
-    if (session) kept.set(turn.agent, { harness: session.harness, sessionRef: session.id });
-  }
-  return kept;
+/** Each agent's latest `session` line: what an event run's continue reopens it on. */
+export function keptSessionsOf(sessions: RunView["sessions"]): Map<string, NativeFork> {
+  return new Map(
+    Object.values(sessions.latest).map((line) => [
+      line.agent,
+      { harness: line.harness, sessionRef: line.session },
+    ]),
+  );
 }
 
 /**
@@ -4843,4 +5066,6 @@ type LogicalAgentTurns = {
   begin(turn: TurnId, meta: JsonValue, execution: AgentExecution): Promise<void>;
   end(turn: TurnId, meta: JsonValue, outcome: TurnOutcome<JsonValue>): Promise<void>;
   restored(): RestoredTurn | undefined;
+  /** Throws unless the workflow declares this agent's `{key}:ended`. */
+  checkDeclared(): void;
 };