@agentswf/engine 0.1.0-beta.5 → 0.1.0

package/src/workflow-runner.ts

@@ -10,10 +10,12 @@ import {
   RESERVED_PARTICIPANT_KEYS,
 } from "@agentswf/contract/participant";
 import type {
+  AgentOp,
   AgentPaneRecord,
   AgentSkillsRecord,
   RunAccounting,
   RunPanes,
+  RunView,
   SandboxRecord,
   SettledDecision,
   SettledOperation,
@@ -45,10 +47,8 @@ import {
   awfEventOf,
   type Branches,
   type CallerForkSpec,
-  type CodeParticipantRef,
   type CompactionId,
   type CompactSpec,
-  DEPRECATED_DEFINITION,
   DeadlineExceededError,
   type Duration,
   durationMilliseconds,
@@ -56,12 +56,14 @@ import {
   type EventLike,
   type ForkRuntime,
   type HarnessAllowance,
+  type HarnessKind,
   isEventWorkflow,
   isJsonValue,
   type JsonObject,
   type JsonValue,
   type KeepPane,
   type MessageAccess,
+  type NativeSessionRef,
   type Next,
   nameProblem,
   type OperationRecord,
@@ -75,7 +77,6 @@ import {
   placementOf,
   positiveDurationMilliseconds,
   type RaceBranches,
-  REPORT_DEPRECATED,
   type RunResult,
   type RuntimeSelection,
   type SettingsSpec,
@@ -85,6 +86,7 @@ import {
   type StageSummary,
   type StartedTurn,
   type Taken,
+  type Timeout,
   type TimeRead,
   type Timer,
   type TurnId,
@@ -101,7 +103,8 @@ import {
   findHarness,
   HARNESS_NAMES,
   type Harness,
-  hostHome,
+  type HarnessHomes,
+  OPERATOR_HOMES,
   settingsRefusal,
   skillsLayout,
 } from "@agentswf/harness";
@@ -130,11 +133,9 @@ import {
 import type { CoordinatorPort } from "./coordinator-port";
 import {
   assertDeadline,
-  assertDeadlineValue,
   boundedDeadline,
   deadlineWithin,
   earlierDeadline,
-  type GivenBound,
   harnessDeadline,
   runUntilStopped,
   scheduleAt,
@@ -143,7 +144,6 @@ import {
 } from "./deadlines";
 import { RunDecisions } from "./decisions/directory";
 import type { DecisionInstallation } from "./decisions/seam";
-import { type Deprecated, RunDeprecations } from "./deprecations";
 import { parseWhen } from "./duration";
 import { emitEvent } from "./emit";
 import { messageOf } from "./errors";
@@ -154,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";
@@ -177,16 +168,19 @@ import {
   type SupervisedOutcome,
   superviseOperation,
 } from "./operation-liveness";
+import { type EarlierOps, OpIds, writeScreen } from "./ops";
 import {
   besideOf,
   checkPaneOptions,
   keepsPane,
   type PaneAsked,
   paneAsked,
-  storedLayout,
+  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,
@@ -200,7 +194,7 @@ import {
   type OperationTags,
   type RunLedger,
 } from "./run-usage";
-import { endTurnsLine, readAttempts, readStageRecords, readTurns } from "./runs";
+import { endLogLine, readAttempts, workDir } from "./runs";
 import { type CredentialLocks, placeCarried, seedHome } from "./sandbox-homes";
 import {
   RUN_SANDBOX_ONLY,
@@ -208,23 +202,16 @@ 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,
-  isSignal,
-  matches,
-  presented,
-  signalOf,
-  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 { lastRedo } from "./stage-plan";
 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";
@@ -242,12 +229,17 @@ export type RunWorkflowOptions = {
   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. */
@@ -258,14 +250,14 @@ export type RunWorkflowOptions = {
     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
@@ -454,14 +446,11 @@ 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: CallerForkSpec };
-  /** As written; a reopen compares them so, never where the pane ended up. */
+  /** As written; a reopen compares it so, never where the pane ended up. */
   pane?: PaneSpec;
-  layout?: PaneLayout;
-  keepPane?: KeepPane;
-  /** What its host is asked for its pane: these, with the operator's flags applied. */
+  /** What its host is asked for its pane: it, with the operator's flags applied. */
   asked?: PaneAsked;
 };
 
@@ -492,8 +481,9 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
   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());
@@ -501,18 +491,36 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
     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, attempt } = options.run;
-  const startedAt = Date.now();
+  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);
-  // The last --from-stage an earlier attempt redid, whose stale records still rerun as reached.
-  const redo = withEvents
-    ? lastRedo(await readAttempts({ dir: runDir }), recorded, attempt)
-    : undefined;
+  // 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
@@ -522,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({
@@ -559,12 +570,7 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
       });
     };
   const warn = say("warning");
-  const deprecations = new RunDeprecations((text) => warn(text));
-  if (definition.meta.whenToUse !== undefined) deprecations.used("whenToUse");
-  if ((definition as { [DEPRECATED_DEFINITION]?: unknown })[DEPRECATED_DEFINITION])
-    deprecations.used("defineExecutableWorkflow");
-  // 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 = {
@@ -575,19 +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 } : {}),
-    ...(redo === undefined ? {} : { redo }),
-    turns: () => turns,
     event: (body, at) => events.event(body, at),
   });
   const progress = new RunProgress();
@@ -601,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 {
@@ -615,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({
@@ -628,26 +634,23 @@ 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 { park } = options.run;
-  const waits = new RunMailbox({
+  const waits = new RunWaits({
     runDir,
-    attempt,
+    lines: options.run.lines,
     locked,
     now,
     ...(park
       ? {
           parking: {
-            idle: (stage) => owner.idle(stage),
+            idle: () => owner.idle(),
             timeout: (signal) => owner.timeout(signal),
             liveUntil: () => owner.liveUntil(),
             park: async (wait) => {
@@ -665,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,
@@ -696,7 +705,6 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
     ledger,
     onLog: warn,
     log: say("log"),
-    deprecations,
     events,
     onCallerStopped: options.onCallerStopped,
     livenessPolicy: options.livenessPolicy,
@@ -746,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) {
@@ -762,7 +770,6 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
       failure = ending;
     }
     bodyEnded = true;
-    deprecations.settle();
     // What the body left running enters no stage; one left open is failed once its turns settle.
     stages.seal(failed ? messageOf(failure) : "the workflow returned before the stage ended");
     const cutReading = () => reading.abort();
@@ -795,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();
@@ -942,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;
@@ -974,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;
@@ -992,20 +1012,21 @@ class WorkflowOwner {
       onLog?: Warn;
       /** The workflow's own log lines. */
       log(message: string, fields?: JsonObject): void;
-      deprecations: RunDeprecations;
       events: RunEventLog;
       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`. */
@@ -1033,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") {
@@ -1061,7 +1083,6 @@ class WorkflowOwner {
     this.#tools = new ToolCalls<ExecutionScope>({
       record: (event) => options.events.event(event),
       runIn: (scope, fn) => (scope ? scopes.run(scope, fn) : scopes.exit(fn)),
-      deprecated: (name, call) => options.deprecations.used(name, call),
     });
     options.control.attachTools(this.#tools);
     const holder = {
@@ -1074,8 +1095,9 @@ class WorkflowOwner {
       runId: options.runId,
       attempt: options.attempt,
       cwd: options.cwd,
+      // A new `Date` each time, so one a workflow changes isn't the run's.
       get deadline() {
-        return runDeadline(options.deadline, () => options.deprecations.used("run-deadline-ms"));
+        return options.deadline && new Date(options.deadline.unixMilliseconds);
       },
       agents: {
         open: (spec) => {
@@ -1085,14 +1107,6 @@ class WorkflowOwner {
             return Promise.reject(error);
           }
         },
-        stop: (key, reason) => {
-          options.deprecations.used("agents-stop");
-          try {
-            return this.stopAgent(key, reason, "agents.stop");
-          } catch (error) {
-            return Promise.reject(error);
-          }
-        },
         caller: (spec) => {
           try {
             return this.caller(spec.key);
@@ -1136,7 +1150,6 @@ class WorkflowOwner {
           const decided = this.track(
             options.decisions.decide(spec, {
               deadline: scope?.deadline ?? options.deadline,
-              deprecated: (name, call) => options.deprecations.used(name, call),
               ...(scope ? { add: (cancel) => scope.add((stop) => cancel(stop.reason)) } : {}),
               ...(scope?.stage === undefined ? {} : { stage: scope.stage }),
             }),
@@ -1173,12 +1186,7 @@ class WorkflowOwner {
         const inherited = scopes.getStore()?.deadline ?? options.deadline;
         let deadline: AbsoluteDeadline | undefined;
         try {
-          deadline = boundedDeadline(
-            { timeout: parallelOptions?.timeout, deadline: parallelOptions?.deadline },
-            inherited,
-            (name, call) => options.deprecations.used(name, call),
-            "on parallel",
-          );
+          deadline = boundedDeadline(parallelOptions?.timeout, inherited);
         } catch (error) {
           return Promise.reject(error);
         }
@@ -1216,7 +1224,7 @@ class WorkflowOwner {
           undefined,
         );
       },
-      // Every run waits on its own mailbox; one without events never parks, so it waits here.
+      // 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"],
@@ -1235,8 +1243,8 @@ class WorkflowOwner {
         return new Date(options.now() + milliseconds);
       },
       signal: ((name: string) => signalSource(name, options.declared)) as WorkflowContext["signal"],
-      ...(options.mailbox?.started
-        ? { started: options.mailbox.started as WorkflowContext["started"] }
+      ...(options.eventWaits?.started
+        ? { started: options.eventWaits.started as WorkflowContext["started"] }
         : {}),
     };
   }
@@ -1298,12 +1306,11 @@ class WorkflowOwner {
       // A turn's end taken: its agent takes other work again.
       for (const event of taken) {
         if (event.name !== "agent:ended") continue;
-        this.#reporting((event.data as { outcome?: unknown }).outcome);
         const { turn } = event.data as unknown as TurnEnd;
         if (this.#restored.get(event.from)?.turn === turn) this.#restored.delete(event.from);
         this.#logical.get(event.from)?.endTaken(turn);
       }
-      // The mailbox keeps awf's record names; the code is handed the names it declares.
+      // `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?.();
@@ -1312,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) {
@@ -1322,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`,
@@ -1331,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,
@@ -1368,7 +1375,7 @@ class WorkflowOwner {
     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;
     });
@@ -1376,7 +1383,7 @@ class WorkflowOwner {
     let event: WorkflowEvent<string, JsonValue>;
     try {
       [event] = (await this.#holdingWait(scope, async (signal) => {
-        const won = await mailbox.race(name, pairs, owned, label, signal);
+        const won = await waits.race(name, pairs, owned, label, signal);
         branch = won.branch;
         return [won.event];
       })) as [WorkflowEvent<string, JsonValue>];
@@ -1384,7 +1391,7 @@ class WorkflowOwner {
       // 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) => mailbox.cancelTimer(timer))).catch(
+        await Promise.all([...owned.values()].map((timer) => waits.cancelTimer(timer))).catch(
           () => undefined,
         );
       throw error;
@@ -1396,7 +1403,7 @@ class WorkflowOwner {
 
   /** A loop over the events `branches` take, one at a time. */
   private select(
-    mailbox: RunMailbox,
+    waits: RunWaits,
     branches: Branches,
     selectOptions: WaitOptions | undefined,
   ): AsyncIterable<Next<Branches>> {
@@ -1411,7 +1418,9 @@ 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);
@@ -1427,7 +1436,7 @@ class WorkflowOwner {
       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(selectOptions?.label), signal),
+        await waits.select(takes, labelOf(selectOptions?.label), signal),
       ]);
       const taken = event as WorkflowEvent<string, JsonValue>;
       const branch = branchOf(pairs, taken) as string;
@@ -1442,58 +1451,37 @@ class WorkflowOwner {
     };
   }
 
-  /** A started turn among a wait's branches, which naming its agent replaces. */
   /**
-   * A wait's branches as a run can take them: a started turn among them is deprecated, and 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.
+   * 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.mailbox) {
+    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`,
         );
     }
-    if (given.some(([, take]) => take.turn !== undefined))
-      this.options.deprecations.used("turn-source");
   }
 
-  /** `outcome`, which a deprecated name the contract defines reports its use on. */
-  // Best effort: an outcome the workflow copies or freezes, or a stage reuses, reports nothing.
-  #reporting = <T>(outcome: T): T => {
-    if (typeof outcome === "object" && outcome !== null && !Object.isFrozen(outcome))
-      Object.defineProperty(outcome, REPORT_DEPRECATED, {
-        value: this.options.deprecations.reported,
-        configurable: true,
-      });
-    return outcome;
-  };
-
   #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: () => {
-        const { declared, deprecations } = this.options;
-        if (declared.has(`${key}:ended`)) return;
-        // A workflow that declares an end has moved to declaring them; one written before can't have.
-        if ([...declared].some((name) => awfEventOf(name)?.kind === "ended"))
+        if (!this.options.declared.has(`${key}:ended`))
           throw new Error(
-            key.includes(":")
-              ? `agent ${key}: start()'s end arrives as {key}:ended, which a key with a colon can't name: rename it ${key.replaceAll(":", "-")} and declare "${key.replaceAll(":", "-")}:ended": AgentEnded in events`
-              : `agent ${key}: start()'s end arrives as ${key}:ended, which the workflow declares in events, "${key}:ended": AgentEnded, as it does its other agents' ends`,
+            `agent ${key}: start()'s end arrives as ${key}:ended, which the workflow declares in events, "${key}:ended": AgentEnded`,
           );
-        deprecations.used("undeclared-ended", key);
       },
       // Read when the agent opens: a wait before then may have taken the end.
       restored: () => this.#restored.get(key),
@@ -1518,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)
     );
@@ -1561,36 +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,
+    waits: RunWaits,
     spec: WaitOptions | undefined,
   ): Promise<WorkflowEvent<string, JsonValue>[]> {
     const scope = this.#beginWait("receive()");
-    const label = receiveLabel(spec);
-    if (scope?.stage !== undefined) this.options.deprecations.used("stage-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(label, 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. */
@@ -1621,27 +1589,14 @@ 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)}`);
-    const { declared, deprecations } = this.options;
-    const replies = declared.has(`${key}:reply`);
-    if (to === "code") {
-      if (!this.options.mailbox)
-        throw new Error(
-          "a participant routed to the code needs a workflow with events, whose waits take its replies",
-        );
-      // A workflow that declares a reply has moved to declaring them; one written before can't have.
-      if (!replies && [...declared].some((name) => awfEventOf(name)?.kind === "reply"))
-        throw new Error(
-          `participant ${key}: its messages reach the code when "${key}:reply": ParticipantReply is declared in events, as this workflow's other replies are; to: "code" is deprecated`,
-        );
-      deprecations.used("to-code", key);
-    }
+    if ((spec as { to?: unknown }).to !== undefined)
+      throw new Error(
+        `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" || replies ? "code" : undefined,
+      this.options.declared.has(`${key}:reply`) ? "code" : undefined,
     );
     const ref: ParticipantRef = {
       ...participantRef(key),
@@ -1656,21 +1611,6 @@ class WorkflowOwner {
         return this.#messaging.release(key, reason);
       },
     };
-    if (to === "code") {
-      const take = { name: "participant:reply", from: key };
-      const routed = asSource(
-        Object.freeze({
-          ...ref,
-          is: (event: { name: string; from: string }) => {
-            deprecations.used("participant-is");
-            return matches(event, take);
-          },
-        }),
-        take,
-      ) as unknown as CodeParticipantRef;
-      this.#outsideRefs.set(key, routed);
-      return routed;
-    }
     this.#outsideRefs.set(key, ref);
     return ref;
   }
@@ -1678,7 +1618,9 @@ class WorkflowOwner {
   /** 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(":"))
-      this.options.deprecations.used("colon-key", key);
+      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`,
@@ -1726,11 +1668,9 @@ 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) };
-    if (access.timeout != null && access.timeoutMs != null)
-      throw new Error("a route's timeout is given alone: timeoutMs is its deprecated form");
     const timeoutMs =
       access.timeout == null
-        ? (access.timeoutMs ?? undefined)
+        ? undefined
         : positiveDurationMilliseconds(access.timeout, "a route's timeout");
     this.#messaging.grant(ends, {
       purpose: access.purpose,
@@ -1738,8 +1678,6 @@ class WorkflowOwner {
       timeoutMs,
       scope: scope?.messages ?? this.#messaging.attempt,
     });
-    if (access.timeout == null && access.timeoutMs != null)
-      this.options.deprecations.used("timeout-ms", "on a route");
   }
 
   /** Who owns a message operation a route in `scope` opens: its stage, or the attempt. */
@@ -1911,22 +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))?.map((event) =>
-              presented(event, this.options.declared),
-            )
-          : undefined;
-      if (batch) {
-        this.options.deprecations.used("stage-receive");
-        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);
@@ -1944,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;
@@ -1979,52 +1889,31 @@ class WorkflowOwner {
       }
       throw error;
     } finally {
-      this.#stageBatches.delete(name);
       this.#messaging.closeScope(messages);
       this.#stageScopes.delete(messages);
       removeFromParent?.();
     }
   }
 
-  /** An agent's pane options as written, which a reopen is compared by; a deprecated one logged. */
-  private writtenPane(spec: {
-    pane?: PaneSpec;
-    layout?: PaneLayout;
-    keepPane?: KeepPane;
-  }): Pick<AgentIdentity, "pane" | "layout" | "keepPane"> {
-    if (spec.layout !== undefined) this.options.deprecations.used("pane-layout");
-    if (spec.keepPane !== undefined) this.options.deprecations.used("keep-pane");
-    return {
-      ...(spec.pane === undefined ? {} : { pane: storedLayout(spec.pane) }),
-      ...(spec.layout === undefined ? {} : { layout: storedLayout(spec.layout) }),
-      ...(spec.keepPane === undefined ? {} : { keepPane: spec.keepPane }),
-    };
-  }
-
   private openAgent(spec: AgentOpenSpec): Promise<AgentRef> {
     if (this.#closed || this.#cleanupFailures.length) throw new Error("workflow context is closed");
-    if (spec.labels !== undefined) this.options.deprecations.used("labels");
     scopes.getStore()?.assertAccepting();
     this.#assertFreeKey(spec.key, "an agent");
     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.keepAlive;
-    if (given !== undefined && !this.options.mailbox)
+    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`,
       );
-    const keepAlive =
-      given === undefined
-        ? undefined
-        : checkedKeepAlive(spec.key, given, () =>
-            this.options.deprecations.used("keep-alive-timeout-ms"),
-          );
+    const keepAlive = given === undefined ? undefined : checkedKeepAlive(spec.key, given);
     const execution = existing
       ? constrainExistingExecution(spec.runtime, existing.identity.execution)
       : withKnownEffort(resolveExecution(spec.runtime, this.options.runtime));
@@ -2034,25 +1923,19 @@ class WorkflowOwner {
         spec.sandbox !== undefined || existing?.identity.sandbox !== undefined || inRunSandbox,
     };
     checkPaneOptions(spec.key, spec, paneless);
-    const written = this.writtenPane(spec);
+    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) }),
-      ...written,
-      asked: paneAsked(written, this.options.panes, !paneless.headless && !paneless.sandboxed),
+      ...(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 = boundedDeadline(
-      { timeout: spec.timeout, deadline: spec.deadline },
-      inheritedDeadline,
-      (name, call) => this.options.deprecations.used(name, call),
-      "on open",
-    );
+    const effectiveDeadline = boundedDeadline(spec.timeout, inheritedDeadline);
     assertDeadline(effectiveDeadline);
     if (existing) {
       assertCompatibleAgent(spec.key, existing.identity, identity, spec);
@@ -2107,8 +1990,7 @@ 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 } : {}),
@@ -2148,7 +2030,7 @@ 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 | undefined, what: string): Promise<boolean> {
     if (this.#closed || this.#cleanupFailures.length) throw new Error("workflow context is closed");
@@ -2214,6 +2096,7 @@ class WorkflowOwner {
     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) {
@@ -2241,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(
@@ -2337,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,
@@ -2415,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;
@@ -2426,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) => {
@@ -2476,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),
@@ -2543,6 +2436,7 @@ class WorkflowOwner {
       execution,
       session,
       slots: this.options.slots,
+      ops: this.options.ops,
       endpoint,
       launcher,
       deadline: this.options.deadline,
@@ -2550,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(),
@@ -2559,7 +2458,7 @@ 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),
       close: (reason) => {
         try {
@@ -2568,8 +2467,6 @@ class WorkflowOwner {
           return Promise.reject(error);
         }
       },
-      deprecated: (name, subject) => this.options.deprecations.used(name, subject),
-      reporting: (outcome) => this.#reporting(outcome),
       keepPane: () => this.#agents.get(key)?.identity.asked?.keepPane,
       keepAlive: () => this.#agents.get(key)?.keepAlive,
       defaultWindowMs: this.options.defaultWindowMs ?? DEFAULT_WINDOW_MS,
@@ -2613,7 +2510,6 @@ class WorkflowOwner {
     unopened?: AgentEntry,
   ): Promise<AgentRef> {
     if (this.#closed || this.#cleanupFailures.length) throw new Error("workflow context is closed");
-    if (spec.labels !== undefined) this.options.deprecations.used("labels");
     const scope = scopes.getStore();
     scope?.assertAccepting();
     this.options.stages.checkOperation();
@@ -2621,20 +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.
     // 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, () => this.options.deprecations.used("fork-runtime")),
-    );
-    if (forkSpec.layout !== undefined) forkSpec.layout = storedLayout(forkSpec.layout);
-    if (forkSpec.pane !== undefined) forkSpec.pane = storedLayout(forkSpec.pane);
-    const deadline = boundedDeadline(
-      { timeout },
-      scope?.deadline ?? this.options.deadline,
-      (name, call) => this.options.deprecations.used(name, call),
-      "on fork",
-    );
+    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;
@@ -2662,7 +2551,7 @@ 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.runtime));
     // A fork of the calling session is an agent the run opened, on the model the session's files
@@ -2671,17 +2560,15 @@ class WorkflowOwner {
     delete execution.caller;
     const headless = placementOf(execution) === "headless";
     checkPaneOptions(spec.key, forkSpec, { headless, sandboxed });
-    const written = this.writtenPane(forkSpec);
     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 },
-      ...written,
-      asked: paneAsked(written, this.options.panes, !headless && !sandboxed),
+      ...(forkSpec.pane === undefined ? {} : { pane: forkSpec.pane }),
+      asked: paneAsked(forkSpec.pane, this.options.panes, !headless && !sandboxed),
     };
 
     this.options.progress.agentOpened(spec.key, scope?.group);
@@ -2746,7 +2633,6 @@ 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 } : {}),
@@ -2810,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,
@@ -2817,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,
     );
@@ -2876,22 +2775,57 @@ class WorkflowOwner {
   /** 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 { pane, layout, keepPane } = entry.identity;
-      return [
-        {
-          callPath: [],
-          agent,
-          ...(pane === undefined ? {} : { pane }),
-          ...(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,
@@ -2910,6 +2844,14 @@ 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>> {}
@@ -2918,18 +2860,6 @@ interface LogicalAgent extends Source<Taken<AgentEnded>> {}
 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. */
@@ -2970,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;
@@ -2978,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. */
@@ -2998,10 +2932,7 @@ class LogicalAgent implements AgentRef {
       ): Promise<AgentRef>;
       /** The workflow ends it: the run tears it down and its key is not opened again. */
       close(reason: string | undefined): Promise<boolean>;
-      deprecated(name: Deprecated, subject?: string): void;
-      /** An outcome as the workflow is handed it, which a deprecated name it is given reports on. */
-      reporting<T>(outcome: T): T;
-      /** As the workflow wrote it; decides, at close, whether its pane stays. */
+      /** 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;
@@ -3019,7 +2950,7 @@ class LogicalAgent implements AgentRef {
     const restored = options.turns?.restored();
     if (restored)
       this.#started = {
-        ref: turnRef(options.key, restored.turn, async () => false, options.deprecated),
+        ref: turnRef(restored.turn, async () => false),
         meta: restored.meta,
         ended: true,
         done: Promise.resolve(),
@@ -3138,30 +3069,24 @@ class LogicalAgent implements AgentRef {
     const refused = this.#refusedWhileStarted("start");
     if (refused) throw refused;
     const { meta = null, ...run } = spec;
-    if (run.id !== undefined) this.options.deprecated("call-id");
-    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) => {
-          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()");
-          if (inTool) throw inTool;
-          const stop = { kind: "cancelled" as const, reason: reason ?? "the turn was cancelled" };
-          // Its own operation only: one queued behind a message settles cancelled when it is reached.
-          const own = this.#stopsByTurn.get(id);
-          if (own) await own(stop);
-          else this.#cancelledTurns.set(id, stop.reason);
-          await started.done;
-          return written === "cancelled";
-        },
-        this.options.deprecated,
-      ),
+      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()");
+        if (inTool) throw inTool;
+        const stop = { kind: "cancelled" as const, reason: reason ?? "the turn was cancelled" };
+        // Its own operation only: one queued behind a message settles cancelled when it is reached.
+        const own = this.#stopsByTurn.get(id);
+        if (own) await own(stop);
+        else this.#cancelledTurns.set(id, stop.reason);
+        await started.done;
+        return written === "cancelled";
+      }),
       meta,
       ended: false,
       done: ended.promise,
@@ -3180,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(
@@ -3231,7 +3156,7 @@ class LogicalAgent implements AgentRef {
     Meta extends JsonValue = JsonValue,
     T extends JsonValue = JsonValue,
     E extends EventLike = EventLike,
-  >(event: E): event is E & AgentEndOf<E, Meta, T> {
+  >(event: E): event is E & AgentEndOf<Meta, T> {
     return matches(event, { name: "agent:ended", from: this.key });
   }
 
@@ -3240,54 +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();
-    if (spec.id !== undefined && !this.#launching) this.options.deprecated("call-id");
-    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, this.#launching ? "on start" : "on run");
-      const recoveryDeadline = spec.nudge ? spec.nudge.deadline : undefined;
-      if (recoveryDeadline) {
-        this.options.deprecated("nudge-deadline");
-        const own = { unixMilliseconds: recoveryDeadline.unixMilliseconds };
-        assertDeadlineValue(own);
-        deadline = earlierDeadline(deadline, own);
-      }
-    } 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);
@@ -3301,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);
@@ -3315,60 +3222,25 @@ class LogicalAgent implements AgentRef {
         await this.options.afterOperation?.();
       }
     });
-    const tracked = this.options.track(
-      result.then((settled) => {
-        this.options.reporting(settled.outcome);
-        return settled;
-      }),
-    );
-    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);
-    }
-    if (spec.id !== undefined) this.options.deprecated("call-id");
-    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, "on compact"));
-    } 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;
@@ -3380,48 +3252,23 @@ class LogicalAgent implements AgentRef {
         await this.options.afterOperation?.();
       }
     });
-    const tracked = this.options.track(result.then(this.options.reporting));
-    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);
-    }
-    if (spec.id !== undefined) this.options.deprecated("call-id");
-    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, "on set"));
-    } 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 {
@@ -3436,12 +3283,68 @@ class LogicalAgent implements AgentRef {
         this.#pendingSets.splice(this.#pendingSets.indexOf(change), 1);
       }
     });
-    const tracked = this.options.track(result.then(this.options.reporting));
+    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.
@@ -3450,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,
@@ -3463,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;
@@ -3484,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({
@@ -3499,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"],
@@ -3513,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);
   }
 
@@ -3540,11 +3442,7 @@ 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: TakeFork = (deadline, into) =>
-      this.queue(async () => {
-        if (this.#closed || this.options.isRunClosing()) {
-          throw new Error("logical agent is closed");
-        }
-        scope?.assertActive();
+      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))) {
@@ -3564,17 +3462,10 @@ class LogicalAgent implements AgentRef {
 
   /** Its `timeout`, never later than the scope's or the run's; else the earlier of those. */
   private operationDeadline(
-    spec: GivenBound,
+    spec: { timeout?: Timeout },
     scope: ExecutionScope | undefined,
-    call: string,
   ): AbsoluteDeadline | undefined {
-    const { timeout, deadline, timeoutMs } = spec;
-    return boundedDeadline(
-      { timeout, deadline, timeoutMs },
-      this.deadlineCeiling(scope),
-      this.options.deprecated,
-      call,
-    );
+    return boundedDeadline(spec.timeout, this.deadlineCeiling(scope));
   }
 
   /** The deadlines around an operation: its scope's and the run's, if either has one. */
@@ -3595,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`,
@@ -3732,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;
@@ -3776,7 +3681,7 @@ class LogicalAgent implements AgentRef {
   }
 
   private async executeOperation(
-    spec: AgentRunTextSpec | AgentRunStructuredSpec<JsonValue>,
+    spec: TurnSpec,
     scope: ExecutionScope | undefined,
     operationDeadline: AbsoluteDeadline | undefined,
     operation: OperationLog,
@@ -3787,10 +3692,10 @@ class LogicalAgent implements AgentRef {
   }
 
   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);
@@ -3852,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,
@@ -3863,6 +3768,7 @@ class LogicalAgent implements AgentRef {
       event: events.record,
       operationId,
       agentId: this.key,
+      ...(unrecorded === undefined ? {} : { unrecorded }),
       question: spec.prompt,
       schema,
       ...(deadline ? { deadline } : {}),
@@ -3884,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(
@@ -3904,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),
@@ -3918,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(),
         }),
       )
@@ -3955,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 {
@@ -4101,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({
@@ -4124,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 } };
@@ -4135,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,
@@ -4249,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 {
@@ -4265,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(
@@ -4296,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(
@@ -4304,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") {
@@ -4352,7 +4264,7 @@ class LogicalAgent implements AgentRef {
         state: "failed",
         detail: messageOf(error),
         resultEvidence: { kind: "unavailable" },
-        chargesUsd: [],
+        reportedCostsUsd: [],
       });
     }
     times.deliveredAt = Date.now();
@@ -4366,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?.();
     }
@@ -4464,6 +4382,10 @@ 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)`,
     );
+  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`);
 }
 
@@ -4487,32 +4409,27 @@ function signalSource(name: string, declared: ReadonlySet<string>): unknown {
     throw new Error(
       `signal ${name}: an agent's end is waited on by naming the agent, { done: ${awf.key} }, not a signal`,
     );
-  // The mailbox keeps a reply under its record name, from the participant's key.
+  // `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>,
-  deprecated: (name: Deprecated) => void,
-): StartedTurn {
-  const take = { name: "agent:ended", from: agent, turn: id };
-  const is = (event: { name: string; from: string; data?: unknown }) => {
-    deprecated("turn-is");
-    return matches(event, take);
-  };
-  return asSource(Object.freeze({ id, cancel, is }), take) 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 {
@@ -4689,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.
@@ -4775,17 +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> {
@@ -4948,7 +4880,10 @@ function withKnownEffort(execution: AgentExecution): AgentExecution {
 /** What `set` changes. */
 type SettingsChange = Partial<Pick<AgentExecution, "model" | "effort">>;
 
-const SETTINGS_FIELDS = new Set(["id", "model", "effort", "timeout", "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 }) };
@@ -4996,22 +4931,17 @@ function forkExecution(parent: AgentExecution, runtime: ForkRuntime = {}): Agent
 
 const FORK_RUNTIME_FIELDS = ["placement", "metered", "effort"] as const;
 
-/**
- * A fork's spec with its runtime written one way, `runtime`, so a repeat in either form compares
- * equal. The flat fields are deprecated, and refused beside `runtime` rather than merged with it.
- */
-function forkSpecOf(spec: CallerForkSpec, deprecated: () => void): CallerForkSpec {
-  const { placement, metered, effort, runtime, ...rest } = spec;
-  const flat = definedFields({ placement, metered, effort });
-  if (Object.keys(flat).length > 0) {
-    if (runtime !== undefined) {
-      throw new Error(
-        `agent ${spec.key}: a fork's placement, metered and effort go in its runtime, not beside it`,
-      );
-    }
-    deprecated();
-    return { ...rest, runtime: flat };
-  }
+/** 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(
@@ -5103,7 +5033,7 @@ function assertCompatibleAgent(
   if (spec.skills !== undefined && !isDeepStrictEqual(existing.skills, requested.skills)) {
     conflict(key, "skills");
   }
-  for (const field of ["instructions", "labels", "pane", "layout", "keepPane"] as const) {
+  for (const field of ["instructions", "pane"] as const) {
     if (spec[field] !== undefined && !isDeepStrictEqual(existing[field], requested[field])) {
       conflict(key, field);
     }
@@ -5118,18 +5048,14 @@ function stoppedError(key: string, reason: string): Error {
   return new Error(`agent ${key} was stopped (${reason}); its key is not opened again`);
 }
 
-/**
- * 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 },
+    ]),
+  );
 }
 
 /**
@@ -5140,25 +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, or logs the deprecation, unless the workflow declares this agent's `{key}:ended`. */
+  /** Throws unless the workflow declares this agent's `{key}:ended`. */
   checkDeclared(): void;
 };
-
-/**
- * The run's deadline as `wf.deadline` hands it: a new `Date` each time, so one a workflow changes
- * isn't the run's, whose deprecated `unixMilliseconds` reports its use.
- */
-function runDeadline(
-  deadline: AbsoluteDeadline | undefined,
-  deprecated: () => void,
-): WorkflowContext["deadline"] {
-  if (!deadline) return undefined;
-  const date = new Date(deadline.unixMilliseconds);
-  Object.defineProperty(date, "unixMilliseconds", {
-    get() {
-      deprecated();
-      return date.getTime();
-    },
-  });
-  return date as WorkflowContext["deadline"];
-}