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

package/src/workflow-runner.ts

@@ -13,6 +13,7 @@ import type {
   AgentPaneRecord,
   AgentSkillsRecord,
   RunAccounting,
+  RunPanes,
   SandboxRecord,
   SettledDecision,
   SettledOperation,
@@ -31,7 +32,8 @@ import {
 } from "@agentswf/contract/schema";
 import {
   type AbsoluteDeadline,
-  type AgentEndedEvent,
+  type AgentEnded,
+  type AgentEndOf,
   type AgentExecution,
   type AgentForkSpec,
   type AgentKey,
@@ -40,42 +42,49 @@ import {
   type AgentRunStructuredSpec,
   type AgentRunTextSpec,
   type AgentStartSpec,
+  awfEventOf,
   type Branches,
+  type CallerForkSpec,
   type CodeParticipantRef,
   type CompactionId,
   type CompactSpec,
+  DEPRECATED_DEFINITION,
   DeadlineExceededError,
   type Duration,
+  durationMilliseconds,
   type EmitOutcome,
-  type EventAgentOpenSpec,
-  type EventAgentRef,
+  type EventLike,
+  type ForkRuntime,
   type HarnessAllowance,
   isEventWorkflow,
   isJsonValue,
   type JsonObject,
   type JsonValue,
   type KeepPane,
-  type Matched,
   type MessageAccess,
   type Next,
   nameProblem,
   type OperationRecord,
   type OutputSchema,
   type PaneLayout,
+  type PaneSpec,
+  type ParticipantDirectory,
   type ParticipantRef,
   type ParticipantSpec,
   type PlacementChoice,
   placementOf,
+  positiveDurationMilliseconds,
   type RaceBranches,
-  type ReceiveOptions,
+  REPORT_DEPRECATED,
   type RunResult,
   type RuntimeSelection,
-  type SelectOptions,
   type SettingsSpec,
   type SkillSource,
+  type Source,
   type StageOptions,
   type StageSummary,
   type StartedTurn,
+  type Taken,
   type TimeRead,
   type Timer,
   type TurnId,
@@ -83,8 +92,8 @@ import {
   type WaitOptions,
   type When,
   type WorkflowContext,
-  type WorkflowDefinition,
   type WorkflowEvent,
+  type WorkflowMeta,
 } from "@agentswf/contract/workflow";
 import {
   type AgentSkills,
@@ -122,8 +131,10 @@ import type { CoordinatorPort } from "./coordinator-port";
 import {
   assertDeadline,
   assertDeadlineValue,
+  boundedDeadline,
   deadlineWithin,
   earlierDeadline,
+  type GivenBound,
   harnessDeadline,
   runUntilStopped,
   scheduleAt,
@@ -132,6 +143,7 @@ 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";
@@ -165,7 +177,14 @@ import {
   type SupervisedOutcome,
   superviseOperation,
 } from "./operation-liveness";
-import { besideOf, checkPaneOptions, keepsPane, storedLayout } from "./pane-layout";
+import {
+  besideOf,
+  checkPaneOptions,
+  keepsPane,
+  type PaneAsked,
+  paneAsked,
+  storedLayout,
+} from "./pane-layout";
 import { createResultSlotRegistry, type ResultSlotRegistry } from "./result-slots";
 import { RunEventLog } from "./run-event-log";
 import {
@@ -181,7 +200,7 @@ import {
   type OperationTags,
   type RunLedger,
 } from "./run-usage";
-import { endTurnsLine, readStageRecords, readTurns } from "./runs";
+import { endTurnsLine, readAttempts, readStageRecords, readTurns } from "./runs";
 import { type CredentialLocks, placeCarried, seedHome } from "./sandbox-homes";
 import {
   RUN_SANDBOX_ONLY,
@@ -191,18 +210,35 @@ import {
 } from "./sandboxes";
 import { QUOTING_RULE, simpleInput, takesText, usageLine } from "./simple-input";
 import { placeSkills, RunSkills, readSkillSources } from "./skills/run-skills";
-import { asSource, branchOf, branchValue, source, takeOf } from "./sources";
+import {
+  asSource,
+  branchOf,
+  branchValue,
+  isSignal,
+  matches,
+  presented,
+  signalOf,
+  source,
+  takeOf,
+} from "./sources";
 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 type { EventWorkflow } from "./workflow-loader";
 
 export { WorkflowCancelledError } from "./deadlines";
 
+/** What the runner needs of a workflow: its meta and its run. */
+export type RunnableWorkflow<Args extends JsonValue, Result extends JsonValue> = {
+  readonly meta: WorkflowMeta;
+  run(context: WorkflowContext, args: Args): Promise<Result>;
+};
+
 export type RunWorkflowOptions = {
   /** Internal timing policy; workflow authors use the operation deadline. */
   livenessPolicy?: LivenessPolicy;
-  /** A `keepAlive` window that gives no `timeoutMs`; absent, an hour. A test's is short. */
+  /** A `keepAlive` that gives no `window`; absent, an hour. A test's is short. */
   defaultWindowMs?: number;
   /** The run's time, which its timers and `wf.now()` read; absent, the clock's. A test's is virtual. */
   now?: () => number;
@@ -218,6 +254,8 @@ export type RunWorkflowOptions = {
     fromStage?: string;
     /** `--values`: the values of stages before `fromStage` that have no record to reuse. */
     values?: ReadonlyMap<string, JsonValue>;
+    /** `--workspace` and `--keep-panes`, as the run's record keeps them for every attempt. */
+    panes?: RunPanes;
     /** A run of a workflow with `events`. */
     events?: true;
     /** With `events`: runs `work` holding the run's lock, as every append to the mailbox is made. */
@@ -244,7 +282,7 @@ export type RunWorkflowOptions = {
   deadline?: AbsoluteDeadline;
   cwd?: string;
   onLog?: (message: string, fields?: JsonObject) => void;
-  /** The operator hands the session back once agents.stop has released it. */
+  /** The operator hands the session back once close() has released it. */
   onCallerStopped?: (reason: string) => Promise<void>;
   signal?: AbortSignal;
   /** The sandbox providers agents may run in; without them, a sandboxed agent is refused. */
@@ -304,7 +342,7 @@ export type SettledRun = {
   sandboxes?: SandboxRecord[];
   /** Each agent's skills; absent when no agent opened. */
   skills?: AgentSkillsRecord[];
-  /** Where each pane agent's pane went; absent when the run placed none. */
+  /** Where each TUI agent's pane went; absent when the run placed none. */
   panes?: AgentPaneRecord[];
   /** Every decision the run asked, in the order asked; absent when it asked none. */
   decisions?: SettledDecision[];
@@ -392,7 +430,7 @@ type AgentEntry = {
    * `undefined` when the channel never opened; the agent state carries the reason.
    */
   channel: Promise<ResultChannel | undefined>;
-  /** Why `agents.stop` ended it; its key is not opened again. */
+  /** Why `close()` ended it; its key is not opened again. */
   stopped?: string;
   stopping?: Promise<boolean>;
   stopComplete?: boolean;
@@ -418,10 +456,13 @@ type AgentIdentity = {
   instructions?: string;
   labels?: AgentOpenSpec["labels"];
   /** The agent it was forked from, and the spec it was forked with. */
-  forkedFrom?: { parent: AgentKey; spec: AgentForkSpec };
+  forkedFrom?: { parent: AgentKey; spec: CallerForkSpec };
   /** As written; a reopen compares them 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. */
+  asked?: PaneAsked;
 };
 
 const CLEANUP_GRACE_MILLISECONDS = 5_000;
@@ -434,7 +475,7 @@ const FORK_TIMEOUT_MS = 60_000;
 const scopes = new AsyncLocalStorage<ExecutionScope>();
 
 export async function runWorkflow<Args extends JsonValue, Result extends JsonValue>(
-  definition: WorkflowDefinition<Args, Result>,
+  definition: RunnableWorkflow<Args, Result>,
   args: Args,
   options: RunWorkflowOptions,
 ): Promise<WorkflowRunResult<Result>> {
@@ -447,7 +488,7 @@ export async function runWorkflow<Args extends JsonValue, Result extends JsonVal
  * handle's `result`'s.
  */
 export async function startWorkflow<Args extends JsonValue, Result extends JsonValue>(
-  definition: WorkflowDefinition<Args, Result>,
+  definition: RunnableWorkflow<Args, Result>,
   args: Args,
   options: RunWorkflowOptions,
 ): Promise<WorkflowRunHandle<Result>> {
@@ -456,14 +497,20 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
   // Before anything opens, so a refusal leaves nothing to close.
   const withEvents = isEventWorkflow(definition);
   const locked = options.run.locked ?? (<T>(work: () => Promise<T>) => work());
-  if (withEvents && (options.run.fromStage !== undefined || options.run.values))
-    throw new Error("a run of a workflow with events takes no --from-stage or --values");
+  if (withEvents && options.run.values)
+    throw new Error(
+      "a run of a workflow with events takes no --values: before --from-stage, a stage with no record runs",
+    );
   const { dir: runDir, id: runId, attempt } = options.run;
   const startedAt = Date.now();
   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;
   // The log is observation: one that cannot be written says so as it is, and fails nothing.
   await endTurnsLine(runDir).catch(() => undefined);
   const slots = createResultSlotRegistry({
@@ -512,6 +559,10 @@ 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 ledger = createRunLedger({ accounting: options.runtime.host.accounting, startedAt });
@@ -535,6 +586,7 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
     ...(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),
   });
@@ -586,18 +638,26 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
       : undefined;
   // Every run's timers live in a mailbox; a run of a workflow with events takes its events there too.
   // A plain run without `park` waits for its timers in its process.
+  const { park } = options.run;
   const waits = new RunMailbox({
     runDir,
     attempt,
     locked,
     now,
-    ...(options.run.park
+    ...(park
       ? {
           parking: {
             idle: (stage) => owner.idle(stage),
             timeout: (signal) => owner.timeout(signal),
             liveUntil: () => owner.liveUntil(),
-            park: options.run.park,
+            park: async (wait) => {
+              // No wake carries `--from-stage`: parked short of it, the redo would be lost unsaid.
+              const unreached = stages.fromStageUnreached;
+              if (unreached === undefined) return park(wait);
+              const stop = new FromStageUnreached(unreached, stages.recorded);
+              fatal.reject(stop);
+              throw stop;
+            },
             ...(options.run.live ? { live: options.run.live } : {}),
             ...(options.run.skip ? { skip: options.run.skip } : {}),
           },
@@ -636,6 +696,7 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
     ledger,
     onLog: warn,
     log: say("log"),
+    deprecations,
     events,
     onCallerStopped: options.onCallerStopped,
     livenessPolicy: options.livenessPolicy,
@@ -644,6 +705,8 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
     coordinators: options.coordinators ?? [],
     emit: options.emit ?? machineEmitter,
     workflow: definition.meta.name,
+    declared: new Set(withEvents ? Object.keys(definition.events) : []),
+    ...(options.run.panes ? { panes: options.run.panes } : {}),
   });
   const stopped = new AbortController();
   // Aborted by a stop that comes after the body ended; the one that ended it does not cut short the
@@ -699,6 +762,7 @@ 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();
@@ -928,6 +992,7 @@ 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"]>;
@@ -945,6 +1010,10 @@ class WorkflowOwner {
       emit: Emitter;
       /** The workflow's name, which with the run's id is the ref its events are `from`. */
       workflow: string;
+      /** The names its `events` declares, which `signal` takes. */
+      declared: ReadonlySet<string>;
+      /** The operator's choices for every TUI agent's pane on the host. */
+      panes?: RunPanes;
     },
   ) {
     this.#restored = new Map(options.restoredTurns ?? []);
@@ -992,6 +1061,7 @@ 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 = {
@@ -1004,7 +1074,9 @@ class WorkflowOwner {
       runId: options.runId,
       attempt: options.attempt,
       cwd: options.cwd,
-      deadline: options.deadline,
+      get deadline() {
+        return runDeadline(options.deadline, () => options.deprecations.used("run-deadline-ms"));
+      },
       agents: {
         open: (spec) => {
           try {
@@ -1013,20 +1085,10 @@ class WorkflowOwner {
             return Promise.reject(error);
           }
         },
-        attach: (key, runtime) => {
-          if (this.#caller?.key !== key) return unavailable("agents.attach");
-          const stopped = this.#agents.get(key)?.stopped;
-          if (stopped !== undefined) return Promise.reject(stoppedError(key, stopped));
-          if (runtime !== undefined) {
-            return Promise.reject(
-              new Error(`agent ${key} is the calling session, whose runtime is the operator's`),
-            );
-          }
-          return this.#caller.state;
-        },
         stop: (key, reason) => {
+          options.deprecations.used("agents-stop");
           try {
-            return this.stopAgent(key, reason);
+            return this.stopAgent(key, reason, "agents.stop");
           } catch (error) {
             return Promise.reject(error);
           }
@@ -1074,6 +1136,7 @@ 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 }),
             }),
@@ -1083,17 +1146,10 @@ class WorkflowOwner {
         },
       },
       participants: {
-        connect: async (spec) => this.connectParticipant(spec),
-        get: async (key) =>
-          (this.#messaging.connected().includes(key) ? this.#outsideRefs.get(key) : undefined) ??
-          (this.#logical.get(key) as AgentRef | undefined) ??
-          null,
+        connect: (async (spec: ParticipantSpec) =>
+          this.connectParticipant(spec)) as ParticipantDirectory["connect"],
       },
       messages: { allow: async (access) => this.allowRoute(access) },
-      steps: {
-        run: () => unavailable("steps.run"),
-        sleep: () => unavailable("steps.sleep"),
-      },
       emit: async (target, run, name, data, emitOptions) => {
         if (this.#closed || this.#cleanupFailures.length)
           throw new Error("workflow context is closed");
@@ -1115,9 +1171,17 @@ class WorkflowOwner {
       },
       parallel: (items, operation, parallelOptions) => {
         const inherited = scopes.getStore()?.deadline ?? options.deadline;
-        const deadline = parallelOptions?.deadline
-          ? earlierDeadline(parallelOptions.deadline, inherited)
-          : inherited;
+        let deadline: AbsoluteDeadline | undefined;
+        try {
+          deadline = boundedDeadline(
+            { timeout: parallelOptions?.timeout, deadline: parallelOptions?.deadline },
+            inherited,
+            (name, call) => options.deprecations.used(name, call),
+            "on parallel",
+          );
+        } catch (error) {
+          return Promise.reject(error);
+        }
         const label = parallelOptions?.label;
         return runParallel(items, operation, deadline, parallelOptions?.concurrency, () =>
           label === undefined ? undefined : options.progress.group(label, items.length),
@@ -1129,7 +1193,6 @@ class WorkflowOwner {
       },
       stage: ((name: string, ...rest: unknown[]) =>
         this.runStage(name, rest)) as WorkflowContext["stage"],
-      call: () => unavailable("call"),
       usage: () => options.ledger.records(),
       allowance: async (harness) => {
         if (this.#closed || this.#cleanupFailures.length)
@@ -1153,33 +1216,29 @@ class WorkflowOwner {
           undefined,
         );
       },
+      // Every run waits on its own mailbox; one without events never parks, so it waits here.
+      receive: (spec?: WaitOptions) => this.receive(options.waits, spec),
+      race: ((name: string, branches: RaceBranches, raceOptions?: WaitOptions) =>
+        this.race(options.waits, name, branches, raceOptions)) as WorkflowContext["race"],
+      select: ((branches: Branches, selectOptions?: WaitOptions) =>
+        this.select(options.waits, branches, selectOptions)) as WorkflowContext["select"],
+      timer: (name: string, when: When) => this.timer(options.waits, name, when),
+      at: (read: () => Date | null) => timeRead(read),
+      after: (duration: Duration) => {
+        this.#notReading("wf.after()");
+        let milliseconds: number;
+        try {
+          milliseconds = durationMilliseconds(duration);
+        } catch (error) {
+          throw new Error(`wf.after takes a duration: ${messageOf(error)}`);
+        }
+        return new Date(options.now() + milliseconds);
+      },
+      signal: ((name: string) => signalSource(name, options.declared)) as WorkflowContext["signal"],
+      ...(options.mailbox?.started
+        ? { started: options.mailbox.started as WorkflowContext["started"] }
+        : {}),
     };
-    const { mailbox } = options;
-    Object.assign(
-      this.context,
-      mailbox
-        ? {
-            receive: (spec?: ReceiveOptions) => this.receive(mailbox, spec),
-            race: (name: string, branches: RaceBranches, raceOptions?: WaitOptions) =>
-              this.race(mailbox, name, branches, raceOptions),
-            select: (branches: Branches, selectOptions?: SelectOptions) =>
-              this.select(mailbox, branches, selectOptions),
-            timer: (name: string, when: When) => this.timer(mailbox, name, when),
-            timers: () => source({}, { name: "timer:due" }),
-            at: (read: () => Date | null) => timeRead(read),
-            after: (duration: Duration) => {
-              this.#notReading("wf.after()");
-              if (typeof duration !== "string" || !/^\d+(?:\.\d+)?[dhm]$/.test(duration))
-                throw new Error(
-                  `wf.after takes days, hours or minutes, "1d", "3h", "1.5h"; not ${String(duration)}`,
-                );
-              return new Date(parseWhen(duration, options.now()).due);
-            },
-            signal: (name: string) => signalSource(name),
-            ...(mailbox.started ? { started: mailbox.started } : {}),
-          }
-        : { receive: () => Promise.reject(new Error("receive needs a workflow with events")) },
-    );
   }
 
   /** Set while a select reads a time from state. */
@@ -1239,11 +1298,13 @@ 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);
       }
-      return taken;
+      // The mailbox keeps awf's record names; the code is handed the names it declares.
+      return taken.map((event) => presented(event, this.options.declared));
     } finally {
       removeFromScope?.();
       this.#waiting = false;
@@ -1291,8 +1352,7 @@ class WorkflowOwner {
       throw new Error(
         `race ${name} has answered in this attempt; a wait in a loop is named per round, as approval-\${round}`,
       );
-    this.#raced.add(name);
-    const label = checkedLabel(raceOptions?.label);
+    const label = labelOf(raceOptions?.label);
     const given = branchesOf(`race ${name}`, branches, true);
     // A sleep's time may be a Date, its own timer as a duration is.
     const own = (source: unknown) => typeof source === "string" || source instanceof Date;
@@ -1302,6 +1362,9 @@ class WorkflowOwner {
         own(source) ? [] : [[branch, sourceTake(`race ${name}`, branch, source)] as const],
       ),
     );
+    this.#checkSources(`race ${name}`, takes.entries());
+    // Only once its label and branches are checked: a refused race leaves its name to a retry.
+    this.#raced.add(name);
     const owned = new Map<string, string>();
     const pairs: (readonly [string, WaitTake])[] = given.map(([branch, source]) => {
       if (!own(source)) return [branch, takes.get(branch) as WaitTake] as const;
@@ -1309,29 +1372,33 @@ class WorkflowOwner {
       owned.set(branch, timer.name);
       return [branch, { name: "timer:due", from: timer.name }] as const;
     });
-    let won: { branch: string; event: WorkflowEvent<string, JsonValue> } | undefined;
+    let branch: string | undefined;
+    let event: WorkflowEvent<string, JsonValue>;
     try {
-      await this.#holdingWait(scope, async (signal) => {
-        won = await mailbox.race(name, pairs, owned, label, signal);
+      [event] = (await this.#holdingWait(scope, async (signal) => {
+        const won = await mailbox.race(name, pairs, owned, label, signal);
+        branch = won.branch;
         return [won.event];
-      });
+      })) as [WorkflowEvent<string, JsonValue>];
     } catch (error) {
-      // Cut short, not parked: its own timers would fire into a later wait. A park's rerun races again.
-      if (!(error instanceof RunParked))
+      // 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(
           () => undefined,
         );
       throw error;
     }
-    const { branch, event } = won as { branch: string; event: WorkflowEvent<string, JsonValue> };
-    return { key: branch, [branch]: branchValue(event) } as Next<RaceBranches>;
+    const key = branch as string;
+    const whole = isSignal(given.find(([each]) => each === key)?.[1]);
+    return { key, [key]: branchValue(event, whole) } as Next<RaceBranches>;
   }
 
   /** A loop over the events `branches` take, one at a time. */
   private select(
     mailbox: RunMailbox,
     branches: Branches,
-    selectOptions: SelectOptions | undefined,
+    selectOptions: WaitOptions | undefined,
   ): AsyncIterable<Next<Branches>> {
     const given = branchesOf("select", branches, false);
     const reads = new Map(
@@ -1347,6 +1414,7 @@ class WorkflowOwner {
           reads.has(branch) ? { name: AT_DUE, from: branch } : sourceTake("select", branch, source),
         ] as const,
     );
+    this.#checkSources("select", pairs);
     // Read at each pass of the wait: a time follows the state as it moves.
     const takes = (): WaitTake[] =>
       pairs.map(([branch, take]) => {
@@ -1354,20 +1422,17 @@ class WorkflowOwner {
         const due = read && this.#readTime(branch, read);
         return due === undefined ? take : { ...take, due };
       });
-    const labelOf = () => {
-      const given = selectOptions?.label;
-      return checkedLabel(typeof given === "function" ? given() : given);
-    };
     const next = async (): Promise<Next<Branches>> => {
       const scope = this.#beginWait("select");
       if (scope?.stage !== undefined)
         throw new Error(`select is in stage ${scope.stage}: a loop's wait is not a stage's`);
       const [event] = await this.#holdingWait(scope, async (signal) => [
-        await mailbox.select(takes, labelOf(), signal),
+        await mailbox.select(takes, labelOf(selectOptions?.label), signal),
       ]);
       const taken = event as WorkflowEvent<string, JsonValue>;
       const branch = branchOf(pairs, taken) as string;
-      return { key: branch, [branch]: branchValue(taken) } as Next<Branches>;
+      const whole = isSignal(given.find(([each]) => each === branch)?.[1]);
+      return { key: branch, [branch]: branchValue(taken, whole) } as Next<Branches>;
     };
     return {
       [Symbol.asyncIterator]: () => ({
@@ -1377,6 +1442,36 @@ 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.
+   */
+  #checkSources(what: string, takes: Iterable<readonly [string, WaitTake]>): void {
+    const given = [...takes];
+    if (!this.options.mailbox) {
+      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>();
@@ -1388,6 +1483,18 @@ class WorkflowOwner {
     return {
       begin: (turn, meta, execution) => mailbox.beginTurn(key, turn, meta, execution),
       end: (turn, meta, outcome) => mailbox.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"))
+          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`,
+          );
+        deprecations.used("undeclared-ended", key);
+      },
       // Read when the agent opens: a wait before then may have taken the end.
       restored: () => this.#restored.get(key),
     };
@@ -1442,7 +1549,7 @@ class WorkflowOwner {
       if (!onTimeout) continue;
       try {
         await runUntilStopped(
-          async () => asTimeoutHandler(() => onTimeout(agent as unknown as EventAgentRef)),
+          async () => asTimeoutHandler(() => onTimeout(agent)),
           signal,
           undefined,
         );
@@ -1462,14 +1569,16 @@ class WorkflowOwner {
   /** A wait: one at a time, and in a stage, the stage's batch. */
   private async receive(
     mailbox: RunMailbox,
-    spec: ReceiveOptions | undefined,
+    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(spec, scope?.stage, signal),
+        mailbox.receive(label, scope?.stage, signal),
       );
       if (scope?.stage !== undefined) {
         this.#stageBatches.set(scope.stage, taken);
@@ -1515,17 +1624,32 @@ class WorkflowOwner {
     const to = (spec as { to?: unknown }).to;
     if (to !== undefined && to !== "code")
       throw new Error(`a participant's messages go to agents, or to: "code"; not ${String(to)}`);
-    if (to === "code" && !this.options.mailbox)
-      throw new Error(
-        "a participant routed to the code needs a workflow with events, whose waits take its replies",
-      );
+    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);
+    }
     this.#messaging.connect(
       key,
       labels === undefined ? undefined : structuredClone(labels),
-      to === "code" ? "code" : undefined,
+      to === "code" || replies ? "code" : undefined,
     );
     const ref: ParticipantRef = {
       ...participantRef(key),
+      post: async (text: string) => {
+        if (typeof text !== "string" || text.trim() === "")
+          throw new Error("post takes the text to write");
+        await this.#messaging.post(key, text);
+      },
       release: async (reason) => {
         if (reason !== undefined && typeof reason !== "string")
           throw new Error("a release's reason is a string");
@@ -1533,16 +1657,16 @@ class WorkflowOwner {
       },
     };
     if (to === "code") {
-      const routed = source(
-        {
+      const take = { name: "participant:reply", from: key };
+      const routed = asSource(
+        Object.freeze({
           ...ref,
-          post: async (text: string) => {
-            if (typeof text !== "string" || text.trim() === "")
-              throw new Error("post takes the text to write");
-            await this.#messaging.post(key, text);
+          is: (event: { name: string; from: string }) => {
+            deprecations.used("participant-is");
+            return matches(event, take);
           },
-        },
-        { name: "participant:reply", from: key },
+        }),
+        take,
       ) as unknown as CodeParticipantRef;
       this.#outsideRefs.set(key, routed);
       return routed;
@@ -1553,6 +1677,8 @@ 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);
     if ((RESERVED_PARTICIPANT_KEYS as readonly string[]).includes(key.toLowerCase()))
       throw new Error(
         `${key} is reserved: an agent could read a message from it as authority; ${who} takes another key`,
@@ -1600,12 +1726,20 @@ 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)
+        : positiveDurationMilliseconds(access.timeout, "a route's timeout");
     this.#messaging.grant(ends, {
       purpose: access.purpose,
       maxMessages: access.maxMessages,
-      timeoutMs: access.timeoutMs,
+      timeoutMs,
       scope: scope?.messages ?? this.#messaging.attempt,
     });
+    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. */
@@ -1694,7 +1828,7 @@ class WorkflowOwner {
                     : "cancelled",
                 reason: "workflow closing",
               })
-              .then(() => state.close("workflow complete")),
+              .then(() => state.terminate("workflow complete")),
           () => undefined,
         ),
       );
@@ -1780,9 +1914,12 @@ class WorkflowOwner {
       // 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)
+          ? (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`,
@@ -1849,8 +1986,24 @@ class WorkflowOwner {
     }
   }
 
+  /** 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) {
@@ -1861,20 +2014,27 @@ class WorkflowOwner {
       throw new Error(`agent ${spec.key}: ${RUN_SANDBOX_ONLY}`);
     const existing = this.#agents.get(spec.key);
     if (existing?.stopped !== undefined) throw stoppedError(spec.key, existing.stopped);
-    const given = (spec as EventAgentOpenSpec).keepAlive;
+    const given = spec.keepAlive;
     if (given !== undefined && !this.options.mailbox)
       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);
+    const keepAlive =
+      given === undefined
+        ? undefined
+        : checkedKeepAlive(spec.key, given, () =>
+            this.options.deprecations.used("keep-alive-timeout-ms"),
+          );
     const execution = existing
       ? constrainExistingExecution(spec.runtime, existing.identity.execution)
       : withKnownEffort(resolveExecution(spec.runtime, this.options.runtime));
-    checkPaneOptions(spec.key, spec, {
+    const paneless = {
       headless: placementOf(execution) === "headless",
       sandboxed:
         spec.sandbox !== undefined || existing?.identity.sandbox !== undefined || inRunSandbox,
-    });
+    };
+    checkPaneOptions(spec.key, spec, paneless);
+    const written = this.writtenPane(spec);
     const identity: AgentIdentity = {
       execution,
       cwd: spec.cwd ?? this.options.cwd,
@@ -1882,14 +2042,17 @@ class WorkflowOwner {
       ...(spec.labels === undefined ? {} : { labels: structuredClone(spec.labels) }),
       ...(spec.sandbox === undefined ? {} : { sandbox: spec.sandbox }),
       ...(spec.skills === undefined ? {} : { skills: readSkillSources(spec.skills) }),
-      ...(spec.layout === undefined ? {} : { layout: storedLayout(spec.layout) }),
-      ...(spec.keepPane === undefined ? {} : { keepPane: spec.keepPane }),
+      ...written,
+      asked: paneAsked(written, this.options.panes, !paneless.headless && !paneless.sandboxed),
     };
     const scope = scopes.getStore();
     const inheritedDeadline = scope?.deadline ?? this.options.deadline;
-    const effectiveDeadline = spec.deadline
-      ? earlierDeadline(spec.deadline, inheritedDeadline)
-      : inheritedDeadline;
+    const effectiveDeadline = boundedDeadline(
+      { timeout: spec.timeout, deadline: spec.deadline },
+      inheritedDeadline,
+      (name, call) => this.options.deprecations.used(name, call),
+      "on open",
+    );
     assertDeadline(effectiveDeadline);
     if (existing) {
       assertCompatibleAgent(spec.key, existing.identity, identity, spec);
@@ -1950,9 +2113,9 @@ class WorkflowOwner {
         ...(seated?.webSearch ? { webSearch: true } : {}),
         ...(skills ? { skills } : {}),
         ...(home ? { home } : {}),
-        ...paneOptions(identity),
+        ...identity.asked,
       }),
-      layoutFallback: this.besideFallback(identity.layout, effectiveDeadline)(),
+      layoutFallback: this.besideFallback(identity.asked?.layout, effectiveDeadline)(),
     };
     let skills: Promise<PlacedSkills | undefined> = Promise.resolve(undefined);
     let opened: { state: Promise<LogicalAgent>; channel: Promise<ResultChannel> };
@@ -1987,9 +2150,9 @@ 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.
    */
-  private stopAgent(key: string, reason?: string): Promise<boolean> {
+  private stopAgent(key: string, reason: string | undefined, what: string): Promise<boolean> {
     if (this.#closed || this.#cleanupFailures.length) throw new Error("workflow context is closed");
-    const inTool = refusedInTool(key, "agents.stop");
+    const inTool = refusedInTool(key, what);
     if (inTool) throw inTool;
     const scope = scopes.getStore();
     scope?.assertAccepting();
@@ -2014,7 +2177,7 @@ class WorkflowOwner {
         }
         this.options.progress.agentStopped(key, entry.stopped!);
         try {
-          await state.close(entry.stopped);
+          await state.terminate(entry.stopped);
         } finally {
           await entry.channel.then((channel) => channel?.close());
         }
@@ -2044,7 +2207,7 @@ class WorkflowOwner {
   /**
    * The session the run was started from, under the key the workflow names: `null` when there is
    * none. It is found, not opened: its harness, directory and skills are the operator's, and it
-   * answers through a launcher by path as any pane agent does (ADR 0010).
+   * answers through a launcher by path as any TUI agent does (ADR 0010).
    */
   private caller(key: string): Promise<AgentRef | null> {
     if (this.#closed || this.#cleanupFailures.length) throw new Error("workflow context is closed");
@@ -2121,7 +2284,7 @@ class WorkflowOwner {
    * it is that agent's own fork, taken in its queue; otherwise it is taken now, from a parent the
    * run never opened. `null`, and the reason logged, where there is none to fork.
    */
-  private forkCaller(spec: AgentForkSpec): Promise<AgentRef | null> {
+  private forkCaller(spec: CallerForkSpec): Promise<AgentRef | null> {
     if (this.#closed || this.#cleanupFailures.length) throw new Error("workflow context is closed");
     const scope = scopes.getStore();
     scope?.assertAccepting();
@@ -2150,11 +2313,10 @@ class WorkflowOwner {
       channel: Promise.resolve(undefined),
     };
     parent.state.catch(() => undefined);
-    const deadline = scope?.deadline ?? this.options.deadline;
     return this.forkAgent(
       CALLING,
       spec,
-      (into) =>
+      (deadline, into) =>
         calling
           .fork(deadlineWithin(FORK_TIMEOUT_MS, deadline), into, this.#closingRun.signal)
           .then((native) => ({ native, after: null })),
@@ -2399,7 +2561,16 @@ class WorkflowOwner {
       livenessPolicy: this.options.livenessPolicy,
       ...(this.options.mailbox ? { turns: this.#turnsOf(key, this.options.mailbox) } : {}),
       fork: (spec, take, settings) => this.forkAgent(key, spec, take, settings),
-      keepPane: () => this.#agents.get(key)?.identity.keepPane,
+      close: (reason) => {
+        try {
+          return this.stopAgent(key, reason, "close()");
+        } catch (error) {
+          return Promise.reject(error);
+        }
+      },
+      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,
       now: this.options.now,
@@ -2431,14 +2602,18 @@ class WorkflowOwner {
   private forkAgent(
     parentKey: string,
     spec: AgentForkSpec,
-    /** Queues the native fork, or its copy `into` another home; or why its host cannot fork. */
-    take: ((into?: SessionCopy) => Promise<TakenFork>) | string,
+    /**
+     * Queues the native fork, or its copy `into` another home, within the fork's `deadline`; or why
+     * its host cannot fork.
+     */
+    take: TakeFork | string,
     /** The parent's settings once every `set` queued before the fork has run. */
     parentSettings: AgentExecution,
     /** A parent the run never opened: the session it was started from. */
     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();
@@ -2447,10 +2622,19 @@ class WorkflowOwner {
     }
     this.#assertFreeKey(spec.key, "an agent");
     // Out before the clone, which throws on a handler, and out of the spec a repeat is compared by.
-    const { tools, ...cloned } = spec;
-    const forkSpec = structuredClone(cloned);
+    // 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);
-    const deadline = scope?.deadline ?? this.options.deadline;
+    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",
+    );
     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;
@@ -2480,15 +2664,14 @@ class WorkflowOwner {
       sandboxed || opening.accounted.home !== undefined
         ? join(this.options.runDir, "forks", randomUUID())
         : undefined;
-    const execution = withKnownEffort(forkExecution(parentSettings, forkSpec));
+    const execution = withKnownEffort(forkExecution(parentSettings, forkSpec.runtime));
     // A fork of the calling session is an agent the run opened, on the model the session's files
     // show, which the fork reads: `""` until then (ADR 0010).
     const ofCaller = execution.caller === true;
     delete execution.caller;
-    checkPaneOptions(spec.key, forkSpec, {
-      headless: placementOf(execution) === "headless",
-      sandboxed,
-    });
+    const headless = placementOf(execution) === "headless";
+    checkPaneOptions(spec.key, forkSpec, { headless, sandboxed });
+    const written = this.writtenPane(forkSpec);
     const identity: AgentIdentity = {
       execution,
       cwd: parent.identity.cwd,
@@ -2497,8 +2680,8 @@ class WorkflowOwner {
       ...(parent.identity.skills ? { skills: parent.identity.skills } : {}),
       ...(parent.identity.sandbox === undefined ? {} : { sandbox: parent.identity.sandbox }),
       forkedFrom: { parent: from, spec: forkSpec },
-      ...(forkSpec.layout === undefined ? {} : { layout: forkSpec.layout }),
-      ...(forkSpec.keepPane === undefined ? {} : { keepPane: forkSpec.keepPane }),
+      ...written,
+      asked: paneAsked(written, this.options.panes, !headless && !sandboxed),
     };
 
     this.options.progress.agentOpened(spec.key, scope?.group);
@@ -2512,11 +2695,11 @@ class WorkflowOwner {
       sessions: () => reportedSessions(sessions),
       forkedAt: () => forkedAt,
     };
-    const besideAtFork = this.besideFallback(identity.layout, deadline);
+    const besideAtFork = this.besideFallback(identity.asked?.layout, deadline);
     let continues: NativeFork | undefined;
     // The fork is asked for now, in the parent's queue; the child opens once it is made. One that
     // was not made leaves nothing behind: its key may be forked again, after the parent's turn.
-    const forked = take(copy === undefined ? undefined : { directory: copy })
+    const forked = take(deadline, copy === undefined ? undefined : { directory: copy })
       .then(({ native: fork, after }) => {
         if (ofCaller) {
           if (!fork.model) throw new Error(`agent ${parentKey}'s fork named no model to run on`);
@@ -2569,7 +2752,7 @@ class WorkflowOwner {
         ...(given ? { skills: given } : {}),
         ...(home ? { home } : {}),
         ...(continues ? { continues } : {}),
-        ...paneOptions(identity),
+        ...identity.asked,
       }),
       // The target as it stands when `fork` is called, waited for once the fork is made.
       layoutFallback: forked.then(besideAtFork, () => undefined),
@@ -2690,16 +2873,17 @@ class WorkflowOwner {
       );
   }
 
-  /** Where each pane agent's pane went, as its host reported it, in the order opened. */
+  /** Where each TUI agent's pane went, as its host reported it, in the order opened. */
   panes(): AgentPaneRecord[] {
     return [...this.#agents].flatMap(([agent, entry]) => {
       const placed = entry.opening?.sessions.harness?.pane?.();
       if (!placed) return [];
-      const { layout, keepPane } = entry.identity;
+      const { pane, layout, keepPane } = entry.identity;
       return [
         {
           callPath: [],
           agent,
+          ...(pane === undefined ? {} : { pane }),
           ...(layout === undefined ? {} : { layout }),
           ...(keepPane === undefined ? {} : { keepPane }),
           placed,
@@ -2726,6 +2910,11 @@ class WorkflowOwner {
   }
 }
 
+// What a wait takes of it is type-only, and `asSource` marks it at run time.
+// biome-ignore lint/correctness/noUnusedVariables: merged into the class below.
+interface LogicalAgent extends Source<Taken<AgentEnded>> {}
+
+// biome-ignore lint/suspicious/noUnsafeDeclarationMerging: the interface adds a type-only member.
 class LogicalAgent implements AgentRef {
   readonly [PARTICIPANT] = true as const;
   readonly #operationStops = new Set<(stop: OperationStop) => Promise<void>>();
@@ -2804,14 +2993,19 @@ class LogicalAgent implements AgentRef {
        */
       fork(
         spec: AgentForkSpec,
-        take: ((into?: SessionCopy) => Promise<TakenFork>) | string,
+        take: TakeFork | string,
         settings: AgentExecution,
       ): 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. */
       keepPane(): KeepPane | undefined;
       /** As the workflow's last open of it gave it. */
       keepAlive(): KeepAlive | undefined;
-      /** Its window when `keepAlive` gives no `timeoutMs`. */
+      /** Its window when `keepAlive` gives no `window`. */
       defaultWindowMs: number;
       /** The run's time, which its window is measured on. */
       now: () => number;
@@ -2825,7 +3019,7 @@ class LogicalAgent implements AgentRef {
     const restored = options.turns?.restored();
     if (restored)
       this.#started = {
-        ref: turnRef(options.key, restored.turn, async () => false),
+        ref: turnRef(options.key, restored.turn, async () => false, options.deprecated),
         meta: restored.meta,
         ended: true,
         done: Promise.resolve(),
@@ -2865,7 +3059,7 @@ class LogicalAgent implements AgentRef {
   liveUntil(now = this.options.now()): number | undefined {
     const keepAlive = this.options.keepAlive();
     if (this.#closed || !keepAlive || this.#lastEnd === undefined) return undefined;
-    const until = this.#lastEnd + (keepAlive.timeoutMs ?? this.options.defaultWindowMs);
+    const until = this.#lastEnd + (keepAlive.windowMs ?? this.options.defaultWindowMs);
     return until > now ? until : undefined;
   }
 
@@ -2928,8 +3122,12 @@ class LogicalAgent implements AgentRef {
 
   async start(spec: AgentStartSpec): Promise<StartedTurn> {
     const { turns } = this.options;
-    if (!turns) return unavailable("AgentRef.start");
+    if (!turns)
+      throw new Error(
+        `agent ${this.key}: start() is for a workflow with events, at whose waits its end arrives; run() waits for the end here`,
+      );
     if (this.#closed) throw new Error("logical agent is closed");
+    turns.checkDeclared();
     const inTool = refusedInTool(this.key, "start()");
     if (inTool) throw inTool;
     const scope = scopes.getStore();
@@ -2940,24 +3138,30 @@ 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();
     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";
-      }),
+      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,
+      ),
       meta,
       ended: false,
       done: ended.promise,
@@ -3023,11 +3227,12 @@ class LogicalAgent implements AgentRef {
       );
   }
 
-  is<Meta extends JsonValue = JsonValue, T extends JsonValue = JsonValue>(event: {
-    readonly name: string;
-    readonly from: string;
-  }): event is AgentEndedEvent<Meta, T> & Matched {
-    return event.name === "agent:ended" && event.from === this.key;
+  is<
+    Meta extends JsonValue = JsonValue,
+    T extends JsonValue = JsonValue,
+    E extends EventLike = EventLike,
+  >(event: E): event is E & AgentEndOf<E, Meta, T> {
+    return matches(event, { name: "agent:ended", from: this.key });
   }
 
   run(spec: AgentRunTextSpec): Promise<RunResult<string>>;
@@ -3046,6 +3251,7 @@ class LogicalAgent implements AgentRef {
       return Promise.reject(error);
     }
     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
@@ -3064,11 +3270,13 @@ class LogicalAgent implements AgentRef {
     }
     let deadline: AbsoluteDeadline | undefined;
     try {
-      deadline = this.operationDeadline(spec, scope);
+      deadline = this.operationDeadline(spec, scope, this.#launching ? "on start" : "on run");
       const recoveryDeadline = spec.nudge ? spec.nudge.deadline : undefined;
       if (recoveryDeadline) {
-        assertDeadlineValue(recoveryDeadline);
-        deadline = earlierDeadline(deadline, 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);
@@ -3107,7 +3315,12 @@ class LogicalAgent implements AgentRef {
         await this.options.afterOperation?.();
       }
     });
-    const tracked = this.options.track(result);
+    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>>;
@@ -3124,6 +3337,7 @@ class LogicalAgent implements AgentRef {
     } 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);
@@ -3140,7 +3354,7 @@ class LogicalAgent implements AgentRef {
     }
     let deadline: AbsoluteDeadline;
     try {
-      deadline = harnessDeadline(this.operationDeadline(spec, scope));
+      deadline = harnessDeadline(this.operationDeadline(spec, scope, "on compact"));
     } catch (error) {
       const rejected = Promise.reject<TurnOutcome<string>>(error);
       scope?.track(rejected);
@@ -3166,7 +3380,7 @@ class LogicalAgent implements AgentRef {
         await this.options.afterOperation?.();
       }
     });
-    const tracked = this.options.track(result);
+    const tracked = this.options.track(result.then(this.options.reporting));
     scope?.track(tracked);
     this.#compactions.set(id, { spec: completeSpec, result: tracked });
     return tracked;
@@ -3183,6 +3397,7 @@ class LogicalAgent implements AgentRef {
     } 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);
@@ -3201,7 +3416,7 @@ class LogicalAgent implements AgentRef {
     let deadline: AbsoluteDeadline;
     try {
       change = this.settingsChange(spec);
-      deadline = harnessDeadline(this.operationDeadline(spec, scope));
+      deadline = harnessDeadline(this.operationDeadline(spec, scope, "on set"));
     } catch (error) {
       const rejected = Promise.reject<TurnOutcome<null>>(error);
       scope?.track(rejected);
@@ -3221,7 +3436,7 @@ class LogicalAgent implements AgentRef {
         this.#pendingSets.splice(this.#pendingSets.indexOf(change), 1);
       }
     });
-    const tracked = this.options.track(result);
+    const tracked = this.options.track(result.then(this.options.reporting));
     scope?.track(tracked);
     this.#sets.set(id, { spec: completeSpec, result: tracked });
     return tracked;
@@ -3306,7 +3521,6 @@ class LogicalAgent implements AgentRef {
     const refused = this.#refusedWhileStarted("fork");
     if (refused) return Promise.reject(refused);
     const scope = scopes.getStore();
-    const deadline = this.deadlineCeiling(scope);
     const { session, execution } = this.options;
     const settings = this.queuedExecution();
     const fork = session.fork?.bind(session);
@@ -3325,7 +3539,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 = (into?: SessionCopy) =>
+    const take: TakeFork = (deadline, into) =>
       this.queue(async () => {
         if (this.#closed || this.options.isRunClosing()) {
           throw new Error("logical agent is closed");
@@ -3348,19 +3562,19 @@ class LogicalAgent implements AgentRef {
     }
   }
 
-  /** `deadline` or `timeoutMs`, never later than the scope's or the run's; else the earlier of those. */
+  /** Its `timeout`, never later than the scope's or the run's; else the earlier of those. */
   private operationDeadline(
-    spec: { deadline?: AbsoluteDeadline; timeoutMs?: number },
+    spec: GivenBound,
     scope: ExecutionScope | undefined,
+    call: string,
   ): AbsoluteDeadline | undefined {
-    if (spec.deadline && spec.timeoutMs !== undefined) {
-      throw new Error("an operation cannot specify both deadline and timeoutMs");
-    }
-    const ceiling = this.deadlineCeiling(scope);
-    if (spec.timeoutMs !== undefined) return deadlineWithin(spec.timeoutMs, ceiling);
-    if (!spec.deadline) return ceiling;
-    assertDeadlineValue(spec.deadline);
-    return earlierDeadline(spec.deadline, ceiling);
+    const { timeout, deadline, timeoutMs } = spec;
+    return boundedDeadline(
+      { timeout, deadline, timeoutMs },
+      this.deadlineCeiling(scope),
+      this.options.deprecated,
+      call,
+    );
   }
 
   /** The deadlines around an operation: its scope's and the run's, if either has one. */
@@ -3432,7 +3646,7 @@ class LogicalAgent implements AgentRef {
       };
     }
     const next: AgentExecution = { ...this.#execution, ...change };
-    const pane = placementOf(next) === "pane";
+    const pane = placementOf(next) === "tui";
     let cancelled: string | undefined;
     // A pane's switch waits on its screen; a scope cancelled meanwhile closes the agent, as a
     // half-made switch leaves it at settings nobody knows. A headless one takes no time.
@@ -3440,7 +3654,7 @@ class LogicalAgent implements AgentRef {
       ? scope?.add(async (stop) => {
           cancelled = stop.reason;
           this.#last = "cancelled";
-          await this.close(stop.reason);
+          await this.terminate(stop.reason);
         })
       : undefined;
     try {
@@ -3477,10 +3691,15 @@ class LogicalAgent implements AgentRef {
     if (this.options.execution.caller) return;
     // Before its outcome is recorded: whether its pane stays turns on how this one ended.
     this.#last = ended;
-    void this.close(reason).catch(() => undefined);
+    void this.terminate(reason).catch(() => undefined);
+  }
+
+  close(reason?: string): Promise<boolean> {
+    return this.options.close(reason);
   }
 
-  close(reason?: string): Promise<void> {
+  /** What `close()`, a failed operation and the run's end each come to. */
+  terminate(reason?: string): Promise<void> {
     const first = !this.#closed;
     this.#closed = true;
     if (first) {
@@ -3564,7 +3783,6 @@ class LogicalAgent implements AgentRef {
   ): Promise<RunResult<JsonValue>> {
     const nudge = spec.nudge === false ? undefined : (spec.nudge ?? this.defaultNudge());
     scope?.assertActive();
-    if (nudge?.deadline) assertDeadlineValue(nudge.deadline);
     return this.executeWaitingOperation(spec, scope, operationDeadline, operation, nudge);
   }
 
@@ -4183,10 +4401,27 @@ function checkedWhen(when: unknown): string | Date {
   throw new Error('sleep is for a duration, "2h", or until a Date');
 }
 
-function checkedLabel(label: unknown): string | undefined {
-  if (label !== undefined && typeof label !== "string")
-    throw new Error("a wait's label is a string");
-  return label;
+/** Receive's options as given, checked: what a typed caller can't get wrong, a plain one can. */
+function receiveLabel(options: unknown): string | undefined {
+  if (options === undefined) return undefined;
+  if (typeof options !== "object" || options === null) throw new Error("receive takes { label? }");
+  // `take: "all"` was the default, so only "oldest" asked for what receive no longer does.
+  const { take } = options as { take?: unknown };
+  if (take !== undefined && take !== "all")
+    throw new Error(
+      "receive takes every event not yet acknowledged; wf.select takes one at a time",
+    );
+  if ("until" in options)
+    throw new Error("receive has no until: a timer, wf.timer(name, when), wakes it");
+  return labelOf((options as WaitOptions).label);
+}
+
+/** A wait's label, a function's asked now. */
+function labelOf(label: unknown): string | undefined {
+  const given = typeof label === "function" ? label() : label;
+  if (given !== undefined && typeof given !== "string")
+    throw new Error("a wait's label is a string, or a function that returns one");
+  return given;
 }
 
 /** A wait's branches, by name, checked: a race may give a duration where a select may not. */
@@ -4229,16 +4464,32 @@ function sourceTake(what: string, branch: string, source: unknown): WaitTake {
     throw new Error(
       `${what}'s ${branch} is wf.at(), a select's: a race answers once, so it takes a timer, wf.timer(name, date)`,
     );
-  throw new Error(
-    `${what}'s ${branch} is not a source: a timer, a signal, a participant routed to the code, an agent, or a started turn`,
-  );
+  throw new Error(`${what}'s ${branch} is not a source: a timer, a signal, or an agent`);
 }
 
+/** The sources only a run of a workflow with events hears. */
+const HEARD_WITH_EVENTS: ReadonlySet<string> = new Set(["agent:ended", "participant:reply"]);
+
 /** One of the workflow's own events, by name, as a source. */
-function signalSource(name: string): unknown {
-  if (typeof name !== "string" || name.includes(":"))
-    throw new Error(`a signal is one of the workflow's own events, by name; not ${String(name)}`);
-  return source({ name }, { name });
+function signalSource(name: string, declared: ReadonlySet<string>): unknown {
+  if (typeof name !== "string")
+    throw new Error(
+      `a signal is one of the workflow's declared events, by name; not ${String(name)}`,
+    );
+  if (!declared.has(name))
+    throw new Error(
+      declared.size === 0
+        ? `signal ${name}: the workflow declares no events`
+        : `signal ${name}: the workflow declares no such event; its events are ${[...declared].join(", ")}`,
+    );
+  const awf = awfEventOf(name);
+  if (awf?.kind === "ended")
+    throw new Error(
+      `signal ${name}: an agent's end is waited on by naming the agent, { done: ${awf.key} }, not a signal`,
+    );
+  // The mailbox 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. */
@@ -4254,11 +4505,14 @@ function turnRef(
   agent: string,
   id: string,
   cancel: (reason?: string) => Promise<boolean>,
+  deprecated: (name: Deprecated) => void,
 ): StartedTurn {
-  return source(
-    { id, cancel },
-    { name: "agent:ended", from: agent, turn: id },
-  ) as unknown as 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;
 }
 
 class ExecutionScope {
@@ -4529,6 +4783,7 @@ type OperationLog = {
 
 /** 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`. */
 type RecordTurn = (outcome: TurnOutcome<JsonValue>, kind: TurnRecord["kind"]) => void;
@@ -4693,46 +4948,101 @@ function withKnownEffort(execution: AgentExecution): AgentExecution {
 /** What `set` changes. */
 type SettingsChange = Partial<Pick<AgentExecution, "model" | "effort">>;
 
-const SETTINGS_FIELDS = new Set(["id", "model", "effort", "deadline", "timeoutMs"]);
+const SETTINGS_FIELDS = new Set(["id", "model", "effort", "timeout", "deadline", "timeoutMs"]);
 
 function sessionSettings({ model, effort }: AgentExecution): SessionSettings {
   return { model, ...(effort === undefined ? {} : { effort }) };
 }
 
 /**
- * A pane is the default and is left unsaid, and `metered` is kept only where it means something,
+ * A TUI is the default and is left unsaid, and `metered` is kept only where it means something,
  * so the same agent always has one identity.
  */
 function storedPlacement(choice: PlacementChoice): PlacementChoice {
-  // A workflow is untyped JavaScript at run time; a misspelt placement must not become a pane.
+  knownPlacement(choice);
+  return placementOf(choice) === "headless"
+    ? { placement: "headless", ...(choice.metered === true ? { metered: true as const } : {}) }
+    : {};
+}
+
+/** A workflow is untyped JavaScript at run time; a misspelt placement must not become a TUI. */
+function knownPlacement(choice: PlacementChoice): void {
   if (
     choice.placement !== undefined &&
-    choice.placement !== "pane" &&
+    choice.placement !== "tui" &&
     choice.placement !== "headless"
   ) {
+    const renamed = (choice.placement as string) === "pane" ? ` ("pane" is now "tui")` : "";
     throw new Error(
-      `unknown placement ${JSON.stringify(choice.placement)}; expected pane or headless`,
+      `unknown placement ${JSON.stringify(choice.placement)}; expected tui or headless${renamed}`,
     );
   }
-  return placementOf(choice) === "headless"
-    ? { placement: "headless", ...(choice.metered === true ? { metered: true as const } : {}) }
-    : {};
 }
 
 /**
  * The parent's harness, model and effort, in the placement and at the effort the fork names, else
  * its parent's.
  */
-function forkExecution(parent: AgentExecution, spec: AgentForkSpec): AgentExecution {
+function forkExecution(parent: AgentExecution, runtime: ForkRuntime = {}): AgentExecution {
   const { placement: _placement, metered: _metered, ...target } = parent;
-  const choice = spec.placement === undefined && spec.metered === undefined ? parent : spec;
+  const choice =
+    runtime.placement === undefined && runtime.metered === undefined ? parent : runtime;
   return {
     ...target,
-    ...(spec.effort === undefined ? {} : { effort: spec.effort }),
+    ...(runtime.effort === undefined ? {} : { effort: runtime.effort }),
     ...storedPlacement(choice),
   };
 }
 
+const FORK_RUNTIME_FIELDS = ["placement", "metered", "effort"] as const;
+
+/**
+ * A fork's spec 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 };
+  }
+  if (runtime === undefined) return rest;
+  if (typeof runtime !== "object" || runtime === null || Array.isArray(runtime)) {
+    throw new Error(
+      `agent ${spec.key}: a fork's runtime is { placement?, metered?, effort? }, not ${JSON.stringify(runtime)}`,
+    );
+  }
+  // A workflow is untyped JavaScript at run time; a harness or model asked for must not be dropped.
+  const others = Object.keys(runtime).filter(
+    (field) =>
+      !(FORK_RUNTIME_FIELDS as readonly string[]).includes(field) &&
+      (runtime as Record<string, unknown>)[field] !== undefined,
+  );
+  if (others.length > 0) {
+    throw new Error(
+      `agent ${spec.key}: a fork continues its parent's session on its harness and model; its runtime takes placement, metered and effort, not ${others.join(", ")}`,
+    );
+  }
+  const given = definedFields({
+    placement: runtime.placement,
+    metered: runtime.metered,
+    effort: runtime.effort,
+  });
+  return Object.keys(given).length === 0 ? rest : { ...rest, runtime: given };
+}
+
+function definedFields<T extends object>(fields: T): Partial<T> {
+  return Object.fromEntries(
+    Object.entries(fields).filter(([, value]) => value !== undefined),
+  ) as Partial<T>;
+}
+
 function constrainExistingExecution(
   selection: RuntimeSelection,
   existing: AgentExecution,
@@ -4757,6 +5067,7 @@ function constrainExistingExecution(
   if (selection.effort !== undefined && selection.effort !== existing.effort) {
     throw new Error("existing agent was opened at a different effort");
   }
+  knownPlacement(selection);
   const placed = placementOf(existing);
   if (
     (selection.placement !== undefined && placementOf(selection) !== placed) ||
@@ -4792,23 +5103,13 @@ function assertCompatibleAgent(
   if (spec.skills !== undefined && !isDeepStrictEqual(existing.skills, requested.skills)) {
     conflict(key, "skills");
   }
-  for (const field of ["instructions", "labels", "layout", "keepPane"] as const) {
+  for (const field of ["instructions", "labels", "pane", "layout", "keepPane"] as const) {
     if (spec[field] !== undefined && !isDeepStrictEqual(existing[field], requested[field])) {
       conflict(key, field);
     }
   }
 }
 
-function paneOptions({
-  layout,
-  keepPane,
-}: AgentIdentity): Pick<HarnessActivation, "layout" | "keepPane"> {
-  return {
-    ...(layout === undefined ? {} : { layout }),
-    ...(keepPane === undefined ? {} : { keepPane }),
-  };
-}
-
 function conflict(key: string, field: string): never {
   throw new Error(`agent ${key} is already open with different ${field}`);
 }
@@ -4817,10 +5118,6 @@ function stoppedError(key: string, reason: string): Error {
   return new Error(`agent ${key} was stopped (${reason}); its key is not opened again`);
 }
 
-function unavailable(name: string): Promise<never> {
-  return Promise.reject(new Error(`${name} is not implemented by the minimum workflow runner`));
-}
-
 /**
  * Each root agent's last native session in a run's turns, where its harness can resume it: what a
  * event run's continue reopens it on.
@@ -4843,4 +5140,25 @@ 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`. */
+  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"];
+}