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

package/src/workflow-runner.ts

@@ -1,9 +1,14 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { randomUUID } from "node:crypto";
 import { mkdir, realpath, rm } from "node:fs/promises";
+import { homedir } from "node:os";
 import { dirname, join, relative } from "node:path";
 import { isDeepStrictEqual } from "node:util";
-import { PARTICIPANT } from "@agentswf/contract/participant";
+import {
+  PARTICIPANT,
+  participantRef,
+  RESERVED_PARTICIPANT_KEYS,
+} from "@agentswf/contract/participant";
 import type {
   AgentPaneRecord,
   AgentSkillsRecord,
@@ -16,6 +21,7 @@ import {
   TURN_OPERATION_FIELDS,
   TURN_RECORD_VERSION,
   type TurnRecord,
+  type WaitTake,
 } from "@agentswf/contract/records";
 import {
   formatErrors,
@@ -25,6 +31,7 @@ import {
 } from "@agentswf/contract/schema";
 import {
   type AbsoluteDeadline,
+  type AgentEndedEvent,
   type AgentExecution,
   type AgentForkSpec,
   type AgentKey,
@@ -32,35 +39,59 @@ import {
   type AgentRef,
   type AgentRunStructuredSpec,
   type AgentRunTextSpec,
-  type AgentStructuredTurnSpec,
-  type AgentTextTurnSpec,
+  type AgentStartSpec,
+  type Branches,
+  type CodeParticipantRef,
   type CompactionId,
   type CompactSpec,
   DeadlineExceededError,
+  type Duration,
+  type EmitOutcome,
+  type EventAgentOpenSpec,
+  type EventAgentRef,
+  type HarnessAllowance,
+  isEventWorkflow,
   isJsonValue,
   type JsonObject,
   type JsonValue,
   type KeepPane,
+  type Matched,
   type MessageAccess,
+  type Next,
+  nameProblem,
   type OperationRecord,
   type OutputSchema,
   type PaneLayout,
+  type ParticipantRef,
+  type ParticipantSpec,
   type PlacementChoice,
   placementOf,
+  type RaceBranches,
+  type ReceiveOptions,
   type RunResult,
   type RuntimeSelection,
+  type SelectOptions,
   type SettingsSpec,
   type SkillSource,
   type StageOptions,
   type StageSummary,
+  type StartedTurn,
+  type TimeRead,
+  type Timer,
+  type TurnId,
   type TurnOutcome,
+  type WaitOptions,
+  type When,
   type WorkflowContext,
   type WorkflowDefinition,
+  type WorkflowEvent,
 } from "@agentswf/contract/workflow";
 import {
   type AgentSkills,
   effortRefusal,
   findHarness,
+  HARNESS_NAMES,
+  type Harness,
   hostHome,
   settingsRefusal,
   skillsLayout,
@@ -87,11 +118,13 @@ import {
   type ResultControlPlane,
   startResultControlPlane,
 } from "./control-plane";
+import type { CoordinatorPort } from "./coordinator-port";
 import {
   assertDeadline,
   assertDeadlineValue,
   deadlineWithin,
   earlierDeadline,
+  harnessDeadline,
   runUntilStopped,
   scheduleAt,
   WorkflowCancelledError,
@@ -99,9 +132,28 @@ import {
 } from "./deadlines";
 import { RunDecisions } from "./decisions/directory";
 import type { DecisionInstallation } from "./decisions/seam";
+import { parseWhen } from "./duration";
+import { emitEvent } from "./emit";
 import { messageOf } from "./errors";
+import {
+  asTimeoutHandler,
+  checkedKeepAlive,
+  DEFAULT_WINDOW_MS,
+  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";
 import { type AgentView, type Delivery, Messaging, type OperationEnd } from "./messaging/messaging";
 import type { Scope as MessagingScope } from "./messaging/routes";
 import { createOperationEvents } from "./operation-events";
@@ -129,7 +181,7 @@ import {
   type OperationTags,
   type RunLedger,
 } from "./run-usage";
-import { endTurnsLine, readStageRecords } from "./runs";
+import { endTurnsLine, readStageRecords, readTurns } from "./runs";
 import { type CredentialLocks, placeCarried, seedHome } from "./sandbox-homes";
 import {
   RUN_SANDBOX_ONLY,
@@ -137,15 +189,23 @@ import {
   type RunSandboxOptions,
   type SeatedAgent,
 } from "./sandboxes";
+import { QUOTING_RULE, simpleInput, usageLine } from "./simple-input";
 import { placeSkills, RunSkills, readSkillSources } from "./skills/run-skills";
+import { asSource, branchOf, branchValue, source, takeOf } from "./sources";
 import { StageLedger, type StageProgress } from "./stage-ledger";
 import { FromStageUnreached } from "./stopped";
+import { inToolHandler, outsideTools, refusedInTool, ToolCalls, toolsLesson } from "./tools";
+import type { EventWorkflow } from "./workflow-loader";
 
 export { WorkflowCancelledError } from "./deadlines";
 
 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. */
+  defaultWindowMs?: number;
+  /** The run's time, which its timers and `workflow.now()` read; absent, the clock's. A test's is virtual. */
+  now?: () => number;
   runRoot: string;
   /** The run this is an attempt of, whose folder the operator claimed under `runRoot`. */
   run: {
@@ -158,9 +218,30 @@ export type RunWorkflowOptions = {
     fromStage?: string;
     /** `--values`: the values of stages before `fromStage` that have no record to reuse. */
     values?: ReadonlyMap<string, JsonValue>;
+    /** 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. */
+    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. */
+    listenNudges?(nudge: () => void): void;
+    /**
+     * Writes the attempt's `parked` ending, which the run's wait calls holding the run's lock: an
+     * event run's, or a test's. Absent, the run never parks and waits in its process.
+     */
+    park?(wait: { label?: string; until?: string }): Promise<void>;
+    /** With `park`: the wait stays live to `until` for an agent's window instead. A test's hook. */
+    live?(until: number): Promise<void>;
+    /** With `park`: moves a virtual clock to the timer due at `until` rather than parking. A test's hook. */
+    skip?(until: number): Promise<boolean>;
   };
   runtime: AgentRuntimeConfig;
-  deadline: AbsoluteDeadline;
+  /** The run's deadline; absent, it has none, and only deadlines the workflow sets bound it. */
+  deadline?: AbsoluteDeadline;
   cwd?: string;
   onLog?: (message: string, fields?: JsonObject) => void;
   /** The operator hands the session back once agents.stop has released it. */
@@ -172,13 +253,36 @@ export type RunWorkflowOptions = {
   skillCache?: string;
   /** The decision models workflows may ask; without them, `decisions.decide` is refused. */
   decisions?: DecisionInstallation;
+  /** How `workflow.allowance` reads a harness's plan; without it, every harness reads `none`. */
+  allowance?: (harness: Harness) => Promise<HarnessAllowance>;
   /**
    * Where an agent may `--await-reply`: the engine's list by harness and placement unless given. A
    * workflow's test allows it everywhere, as the fake harness can.
    */
   awaitReply?: (execution: AgentExecution, confirmsDelivery: boolean) => boolean;
+  /**
+   * Whatever answers for the run's outside participants, each told everything: `awf run`'s prompt,
+   * the socket `awf reply` and `awf send` reach, or a test's scripts. Unsupported outside the engine.
+   * @internal
+   */
+  coordinators?: readonly CoordinatorPort[];
+  /**
+   * Sends `workflow.emit`'s event through the one way in; absent, `emitEvent` on this machine. A
+   * test records them instead.
+   */
+  emit?: Emitter;
 };
 
+/** Sends an event from a run to its target. */
+export type Emitter = (
+  target: EventWorkflow,
+  event: { run: string; name: string; data: JsonValue; id?: string },
+  from: string,
+) => Promise<EmitOutcome>;
+
+const machineEmitter: Emitter = async (target, event, from) =>
+  (await emitEvent(target, event, { from, home: homedir(), environment: process.env })).outcome;
+
 /** What a run is known by once it has ended, whether or not it succeeded. */
 export type SettledRun = {
   runId: string;
@@ -263,6 +367,8 @@ export type WorkflowRunSnapshot = {
     key: AgentKey;
     /** Messages held for it and not yet shown; absent when none are. */
     queued?: number;
+    /** Idle with `keepAlive`, the end of its window: the run stays live to it. */
+    liveUntil?: number;
     execution: AgentExecution;
     state:
       | "starting"
@@ -291,6 +397,8 @@ type AgentEntry = {
   stopping?: Promise<boolean>;
   stopComplete?: boolean;
   releasedAt?: number;
+  /** As the open last gave it: a reopen that gives one replaces it. */
+  keepAlive?: KeepAlive;
   /** How it was opened, or found for the calling session, which its forks reuse. */
   opening?: {
     sessions: AgentSessions;
@@ -345,6 +453,11 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
 ): Promise<WorkflowRunHandle<Result>> {
   assertDeadline(options.deadline);
   if (options.signal?.aborted) throw new WorkflowCancelledError(options.signal.reason);
+  // Before anything opens, so a refusal leaves nothing to close.
+  const withEvents = isEventWorkflow(definition);
+  const locked = options.run.locked ?? (<T>(work: () => Promise<T>) => work());
+  if (withEvents && (options.run.fromStage !== undefined || options.run.values))
+    throw new Error("a run of a workflow with events takes no --from-stage or --values");
   const { dir: runDir, id: runId, attempt } = options.run;
   const startedAt = Date.now();
   const cwd = options.cwd ?? process.cwd();
@@ -369,7 +482,7 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
       runId,
       ...(options.run.label === undefined ? {} : { label: options.run.label }),
       cwd,
-      deadline: options.deadline,
+      deadline: harnessDeadline(options.deadline),
     }),
   );
   try {
@@ -421,6 +534,7 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
     ...(options.run.fromStage === undefined ? {} : { fromStage: options.run.fromStage }),
     ...(options.run.values === undefined ? {} : { values: options.run.values }),
     ...(definition.meta.version === undefined ? {} : { workflowVersion: definition.meta.version }),
+    ...(withEvents ? { byContent: true } : {}),
     turns: () => turns,
     event: (body, at) => events.event(body, at),
   });
@@ -461,9 +575,47 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
   });
   const fatal = Promise.withResolvers<never>();
   void fatal.promise.catch(() => undefined);
-  const owner = new WorkflowOwner({
+  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.
+  const keptSessions =
+    withEvents && options.run.resumeSessions !== false
+      ? keptSessionsOf(await readTurns(runDir))
+      : 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 waits = new RunMailbox({
+    runDir,
+    attempt,
+    locked,
+    now,
+    ...(options.run.park
+      ? {
+          parking: {
+            idle: (stage) => owner.idle(stage),
+            timeout: (signal) => owner.timeout(signal),
+            liveUntil: () => owner.liveUntil(),
+            park: options.run.park,
+            ...(options.run.live ? { live: options.run.live } : {}),
+            ...(options.run.skip ? { skip: options.run.skip } : {}),
+          },
+        }
+      : {}),
+  });
+  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 owner: WorkflowOwner = new WorkflowOwner({
+    ...(mailbox ? { mailbox } : {}),
+    waits,
+    ...(keptSessions ? { keptSessions } : {}),
+    ...(restoredTurns ? { restoredTurns } : {}),
     failRun: (error) => fatal.reject(error),
     decisions,
+    ...(options.allowance ? { allowance: options.allowance } : {}),
     sandboxes,
     skills,
     runDir,
@@ -475,6 +627,7 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
     runId,
     attempt,
     cwd,
+    now,
     deadline: options.deadline,
     runtime: options.runtime,
     host,
@@ -486,7 +639,11 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
     events,
     onCallerStopped: options.onCallerStopped,
     livenessPolicy: options.livenessPolicy,
+    ...(options.defaultWindowMs === undefined ? {} : { defaultWindowMs: options.defaultWindowMs }),
     awaitReply: options.awaitReply ?? ((execution, confirms) => canAwaitReply(execution, confirms)),
+    coordinators: options.coordinators ?? [],
+    emit: options.emit ?? machineEmitter,
+    workflow: definition.meta.name,
   });
   const stopped = new AbortController();
   // Aborted by a stop that comes after the body ended; the one that ended it does not cut short the
@@ -510,6 +667,8 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
               return returned;
             }),
             fatal.promise,
+            // A park ends the body, even code that caught it.
+            waits.whenParked,
           ]),
         signal,
         options.deadline,
@@ -524,6 +683,13 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
       failed = true;
       failure = error;
     }
+    if (mailbox && !mailbox.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) {
+      failed = true;
+      failure = waits.parked;
+    }
     const ending = stages.settle(
       failed ? failure : undefined,
       signal.aborted || failure instanceof DeadlineExceededError,
@@ -619,10 +785,12 @@ export async function startWorkflow<Args extends JsonValue, Result extends JsonV
         messages: known.messages,
         agents: agents.map((agent) => {
           const queued = owner.held(agent.key);
+          const liveUntil = owner.liveUntilOf(agent.key);
           return {
             ...known.agents.get(agent.key),
             ...agent,
             ...(queued > 0 ? { queued } : {}),
+            ...(liveUntil === undefined ? {} : { liveUntil }),
           };
         }),
       };
@@ -681,7 +849,7 @@ type PlacedSkills = { given: AgentSkills; writeBack?: () => Promise<void> };
 type AgentOpening = {
   spec: AgentOpenSpec;
   execution: AgentExecution;
-  deadline: AbsoluteDeadline;
+  deadline: AbsoluteDeadline | undefined;
   sessions: AgentSessions;
   ledger: AgentLedger;
   /** Its skills' sources, resolved when it opens; absent when it has the operator's. */
@@ -713,6 +881,7 @@ class WorkflowOwner {
   /** 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;
+  readonly #tools: ToolCalls<ExecutionScope>;
   /** A stage's execution scope, by its messaging scope: what owns the operations its routes open. */
   readonly #stageScopes = new Map<MessagingScope, ExecutionScope>();
   /** Message operations routes outside any stage opened, which the attempt owns. */
@@ -728,6 +897,8 @@ class WorkflowOwner {
   #caller: { key: string; state: Promise<LogicalAgent> } | undefined;
   /** Stops a fork of the session the run was started from, whose process is not an agent's. */
   readonly #closingRun = new AbortController();
+  /** Outside participants the workflow connected, by key: the refs a route's ends must be. */
+  readonly #outsideRefs = new Map<string, ParticipantRef>();
 
   constructor(
     private readonly options: {
@@ -736,14 +907,16 @@ class WorkflowOwner {
       failRun(error: Error): void;
       runDir: string;
       livenessPolicy?: LivenessPolicy;
+      defaultWindowMs?: number;
       locks: CredentialLocks;
       environment: Readonly<Record<string, string | undefined>>;
       decisions: RunDecisions;
+      allowance?: (harness: Harness) => Promise<HarnessAllowance>;
       stages: StageLedger;
       runId: string;
       attempt: number;
       cwd: string;
-      deadline: AbsoluteDeadline;
+      deadline: AbsoluteDeadline | undefined;
       runtime: AgentRuntimeConfig;
       host: AgentRunHost;
       slots: ResultSlotRegistry;
@@ -758,13 +931,31 @@ class WorkflowOwner {
       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;
+      /** 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. */
+      keptSessions?: ReadonlyMap<string, NativeFork>;
+      /** With `mailbox`: each agent's turn an earlier attempt started whose end no wait took. */
+      restoredTurns?: ReadonlyMap<string, RestoredTurn>;
+      emit: Emitter;
+      /** The workflow's name, which with the run's id is the ref its events are `from`. */
+      workflow: string;
     },
   ) {
+    this.#restored = new Map(options.restoredTurns ?? []);
     this.#messaging = new Messaging({
       agent: (key) => this.#agentView(key),
       canAwait: (key) => {
         const agent = this.#logical.get(key);
-        return agent ? options.awaitReply(agent.execution, agent.confirmsDelivery) : false;
+        // One with a started turn takes messages only once a wait has its end: a reply awaited from
+        // it could wait on code that is itself waiting.
+        if (!agent || agent.hasStartedTurn) return false;
+        return options.awaitReply(agent.execution, agent.confirmsDelivery);
       },
       launcher: (key) => this.#logical.get(key)?.launcher ?? "wf",
       changed: (key) => {
@@ -788,9 +979,27 @@ class WorkflowOwner {
         if (!(await options.events.event({ ...event, callPath: [] }))) {
           throw new Error("the run's event log was not written");
         }
+        for (const port of options.coordinators) {
+          try {
+            port.recorded(event);
+          } catch (error) {
+            options.onLog?.(`awf: a coordinator did not take an event: ${messageOf(error)}`);
+          }
+        }
       },
     });
     options.control.attach(this.#messaging);
+    this.#tools = new ToolCalls<ExecutionScope>({
+      record: (event) => options.events.event(event),
+      runIn: (scope, fn) => (scope ? scopes.run(scope, fn) : scopes.exit(fn)),
+    });
+    options.control.attachTools(this.#tools);
+    const holder = {
+      reply: (request: HolderRequest) => this.#messaging.holderReply(request),
+      send: (request: HolderRequest) => this.#messaging.holderSend(request),
+      open: () => this.#messaging.openQuestions(),
+    };
+    for (const port of options.coordinators) port.attach(holder);
     this.context = {
       runId: options.runId,
       attempt: options.attempt,
@@ -830,6 +1039,8 @@ class WorkflowOwner {
           }
         },
         forkCaller: (spec) => {
+          if ((spec as AgentForkSpec).tools !== undefined)
+            return Promise.reject(new Error("a fork of the calling session takes no tools"));
           try {
             return this.forkCaller(spec);
           } catch (error) {
@@ -872,15 +1083,36 @@ class WorkflowOwner {
         },
       },
       participants: {
-        connect: () => unavailable("participants.connect"),
-        get: () => unavailable("participants.get"),
+        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,
       },
       messages: { allow: async (access) => this.allowRoute(access) },
       steps: {
         run: () => unavailable("steps.run"),
         sleep: () => unavailable("steps.sleep"),
       },
-      signals: { receive: () => unavailable("signals.receive") },
+      emit: async (target, run, name, data, emitOptions) => {
+        if (this.#closed || this.#cleanupFailures.length)
+          throw new Error("workflow context is closed");
+        scopes.getStore()?.assertAccepting();
+        if (!isEventWorkflow(target))
+          throw new Error("emit's target is a workflow with events, as its file exports it");
+        return this.track(
+          options.emit(
+            target,
+            {
+              run,
+              name,
+              data: data as JsonValue,
+              ...(emitOptions?.eventId === undefined ? {} : { id: emitOptions.eventId }),
+            },
+            `${options.workflow}/${options.runId}`,
+          ),
+        );
+      },
       parallel: (items, operation, parallelOptions) => {
         const inherited = scopes.getStore()?.deadline ?? options.deadline;
         const deadline = parallelOptions?.deadline
@@ -899,8 +1131,357 @@ class WorkflowOwner {
         this.runStage(name, rest)) as WorkflowContext["stage"],
       call: () => unavailable("call"),
       usage: () => options.ledger.records(),
+      allowance: async (harness) => {
+        if (this.#closed || this.#cleanupFailures.length)
+          throw new Error("workflow context is closed");
+        if (!(HARNESS_NAMES as readonly string[]).includes(harness))
+          throw new Error(`allowance: no harness ${harness}; awf has ${HARNESS_NAMES.join(", ")}`);
+        if (!options.allowance)
+          return { harness, read: "none", reason: "this run has no allowance reader" };
+        return this.track(options.allowance(harness as Harness));
+      },
       log: (message, fields) => options.log(message, fields),
+      now: () => {
+        this.#notReading("workflow.now()");
+        return new Date(options.now());
+      },
+      sleep: async (name, when) => {
+        await this.race(
+          options.waits,
+          name,
+          { sleep: checkedWhen(when) } as RaceBranches,
+          undefined,
+        );
+      },
     };
+    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("workflow.after()");
+              if (typeof duration !== "string" || !/^\d+(?:\.\d+)?[dhm]$/.test(duration))
+                throw new Error(
+                  `workflow.after takes days, hours or minutes, "1d", "3h", "1.5h"; not ${String(duration)}`,
+                );
+              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. */
+  #reading = false;
+
+  /** Refuses `what` in a time read from state: a time made at the read is never due. */
+  #notReading(what: string): void {
+    if (this.#reading)
+      throw new Error(
+        `${what} in workflow.at's read: a time made at the read moves with every wait and never comes due; keep the time in the run's state where it is set`,
+      );
+  }
+
+  /** Branch `branch`'s time, read from state now: an ISO time, or undefined for `null`. */
+  #readTime(branch: string, read: () => Date | null): string | undefined {
+    this.#reading = true;
+    let value: unknown;
+    try {
+      value = read();
+    } finally {
+      this.#reading = false;
+    }
+    if (value === null) return undefined;
+    if (!(value instanceof Date) || !Number.isFinite(value.getTime()))
+      throw new Error(
+        `select's ${branch}: workflow.at reads a valid Date or null from the run's state, not ${
+          value instanceof Date ? "an invalid Date" : (JSON.stringify(value) ?? String(value))
+        }`,
+      );
+    return value.toISOString();
+  }
+
+  /** Checks a wait may begin here: one at a time, outside a tool's handler, in an open scope. */
+  #beginWait(what: string): ExecutionScope | undefined {
+    if (this.#closed || this.#cleanupFailures.length) throw new Error("workflow context is closed");
+    if (inToolHandler())
+      throw new Error(`${what} is refused in a tool's handler: it would take the run's events`);
+    const scope = scopes.getStore();
+    scope?.assertAccepting();
+    if (this.#waiting)
+      throw new Error(`${what} was called while another wait is waiting; one wait at a time`);
+    return scope;
+  }
+
+  /** Runs a wait, which ends with the run, as its owner closes, or with the scope it waits in. */
+  async #holdingWait(
+    scope: ExecutionScope | undefined,
+    wait: (signal: AbortSignal) => Promise<WorkflowEvent<string, JsonValue>[]>,
+  ): Promise<WorkflowEvent<string, JsonValue>[]> {
+    this.#waiting = true;
+    const cancelled = new AbortController();
+    const removeFromScope = scope?.add(async (stop) =>
+      cancelled.abort(new Error(String(stop.reason ?? "the wait's scope was cancelled"))),
+    );
+    try {
+      const taken = await wait(AbortSignal.any([this.#closingRun.signal, cancelled.signal]));
+      // A turn's end taken: its agent takes other work again.
+      for (const event of taken) {
+        if (event.name !== "agent:ended") continue;
+        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;
+    } finally {
+      removeFromScope?.();
+      this.#waiting = false;
+    }
+  }
+
+  /** 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 {
+    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) {
+      const problem = name.includes("@")
+        ? "without @, which a race's own timers use"
+        : nameProblem(name);
+      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);
+    if (timer.cancelled)
+      this.options.onLog?.(
+        `awf: timer ${name} was cancelled; a name stays cancelled, so it won't fire`,
+      );
+    else if (asked !== undefined)
+      this.options.onLog?.(
+        `awf: timer ${name} is due ${timer.due}, as first set (${timer.when}); ${asked} is ignored`,
+      );
+    return timerSource(mailbox, name, timer.due);
+  }
+
+  /** Waits for the first of `branches`, recorded under `name`. */
+  private async race(
+    mailbox: RunMailbox,
+    name: string,
+    branches: RaceBranches,
+    raceOptions: WaitOptions | undefined,
+  ): Promise<Next<RaceBranches>> {
+    const scope = this.#beginWait(`race ${name}`);
+    if (typeof name !== "string" || nameProblem(name))
+      throw new Error(
+        `a race's name is ${typeof name === "string" ? nameProblem(name) : "a string"}`,
+      );
+    if (scope?.stage !== undefined)
+      throw new Error(`race ${name} is in stage ${scope.stage}: a race is recorded on its own`);
+    if (this.#raced.has(name))
+      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 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;
+    // Every branch checked before a timer is set, so a refused race leaves none behind.
+    const takes = new Map(
+      given.flatMap(([branch, source]) =>
+        own(source) ? [] : [[branch, sourceTake(`race ${name}`, branch, source)] as const],
+      ),
+    );
+    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);
+      owned.set(branch, timer.name);
+      return [branch, { name: "timer:due", from: timer.name }] as const;
+    });
+    let won: { branch: string; event: WorkflowEvent<string, JsonValue> } | undefined;
+    try {
+      await this.#holdingWait(scope, async (signal) => {
+        won = await mailbox.race(name, pairs, owned, label, signal);
+        return [won.event];
+      });
+    } catch (error) {
+      // Cut short, not parked: its own timers would fire into a later wait. A park's rerun races again.
+      if (!(error instanceof RunParked))
+        await Promise.all([...owned.values()].map((timer) => mailbox.cancelTimer(timer))).catch(
+          () => undefined,
+        );
+      throw error;
+    }
+    const { branch, event } = won as { branch: string; event: WorkflowEvent<string, JsonValue> };
+    return { key: branch, [branch]: branchValue(event) } as Next<RaceBranches>;
+  }
+
+  /** A loop over the events `branches` take, one at a time. */
+  private select(
+    mailbox: RunMailbox,
+    branches: Branches,
+    selectOptions: SelectOptions | undefined,
+  ): AsyncIterable<Next<Branches>> {
+    const given = branchesOf("select", branches, false);
+    const reads = new Map(
+      given.flatMap(([branch, source]) => {
+        const read = readOf(source);
+        return read ? [[branch, read] as const] : [];
+      }),
+    );
+    const pairs = given.map(
+      ([branch, source]) =>
+        [
+          branch,
+          reads.has(branch) ? { name: AT_DUE, from: branch } : sourceTake("select", branch, source),
+        ] as const,
+    );
+    // Read at each pass of the wait: a time follows the state as it moves.
+    const takes = (): WaitTake[] =>
+      pairs.map(([branch, take]) => {
+        const read = reads.get(branch);
+        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),
+      ]);
+      const taken = event as WorkflowEvent<string, JsonValue>;
+      const branch = branchOf(pairs, taken) as string;
+      return { key: branch, [branch]: branchValue(taken) } as Next<Branches>;
+    };
+    return {
+      [Symbol.asyncIterator]: () => ({
+        next: async () => ({ done: false, value: await next() }),
+        return: async () => ({ done: true, value: undefined }),
+      }),
+    };
+  }
+
+  #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 {
+    return {
+      begin: (turn, meta, execution) => mailbox.beginTurn(key, turn, meta, execution),
+      end: (turn, meta, outcome) => mailbox.endTurn(key, { turn, meta, outcome }),
+      // Read when the agent opens: a wait before then may have taken the end.
+      restored: () => this.#restored.get(key),
+    };
+  }
+
+  /**
+   * The code returned or threw: each started turn still running is cancelled, and its end written,
+   * before the attempt's ending.
+   */
+  async endStartedTurns(reason: string): Promise<void> {
+    // Bounded as cleanup is: what is cut, a continue's recovery ends.
+    await waitForDeadline(
+      Promise.all([...this.#logical.values()].map((agent) => agent.endStarted(reason))),
+      { unixMilliseconds: Date.now() + CLEANUP_GRACE_MILLISECONDS },
+    ).catch((error: unknown) =>
+      this.options.onLog?.(`awf: a started turn's end was not written: ${messageOf(error)}`),
+    );
+  }
+
+  /**
+   * 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;
+    return (
+      (open === undefined || open === waitStage) &&
+      this.#inFlight.size === 0 &&
+      [...this.#logical.values()].every((agent) => !agent.busy)
+    );
+  }
+
+  /** The end of an idle agent's open window. */
+  liveUntilOf(key: AgentKey): number | undefined {
+    const agent = this.#logical.get(key);
+    return agent && !agent.busy ? agent.liveUntil() : undefined;
+  }
+
+  /** The end of the earliest window an agent holds open: the run stays live to it. */
+  liveUntil(): number | undefined {
+    const ends = [...this.#logical.values()].flatMap((agent) => agent.liveUntil() ?? []);
+    return ends.length > 0 ? Math.min(...ends) : undefined;
+  }
+
+  /**
+   * Calls one agent's due `onTimeout`, in the scope of the wait that calls this, and says whether
+   * it did. A stop or the scope's cancellation stops waiting on it.
+   */
+  async timeout(signal?: AbortSignal): Promise<boolean> {
+    for (const agent of this.#logical.values()) {
+      const onTimeout = agent.takeTimeout();
+      if (!onTimeout) continue;
+      try {
+        await runUntilStopped(
+          async () => asTimeoutHandler(() => onTimeout(agent as unknown as EventAgentRef)),
+          signal,
+          undefined,
+        );
+      } catch (error) {
+        if (signal?.aborted) throw error;
+        this.options.onLog?.(`awf: agent ${agent.key}'s onTimeout threw: ${messageOf(error)}`);
+      }
+      return true;
+    }
+    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. */
+  private async receive(
+    mailbox: RunMailbox,
+    spec: ReceiveOptions | undefined,
+  ): Promise<WorkflowEvent<string, JsonValue>[]> {
+    const scope = this.#beginWait("receive()");
+    if (scope?.stage !== undefined && this.#stageBatches.has(scope.stage))
+      throw new Error(`stage ${scope.stage} has waited once; a stage holds one wait`);
+    try {
+      const taken = await this.#holdingWait(scope, (signal) =>
+        mailbox.receive(spec, scope?.stage, signal),
+      );
+      if (scope?.stage !== undefined) {
+        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;
+    }
   }
 
   /** An agent as messaging sees it, from its entry and its operations. */
@@ -913,6 +1494,73 @@ class WorkflowOwner {
     return { state: agent.busy ? "working" : agent.hasRun ? "idle" : "not-started", ...caller };
   }
 
+  /** Connects a participant outside the run under a key no agent holds and none reserved. */
+  private connectParticipant(spec: ParticipantSpec): ParticipantRef {
+    if (this.#closed || this.#cleanupFailures.length) throw new Error("workflow context is closed");
+    scopes.getStore()?.assertAccepting();
+    if (typeof spec !== "object" || spec === null || typeof spec.key !== "string" || !spec.key)
+      throw new Error("a participant is connected as { key, labels? }");
+    const { key, labels } = spec;
+    this.#assertFreeKey(key, "a participant");
+    if (this.#agents.has(key) || this.#logical.has(key) || this.#caller?.key === key)
+      throw new Error(`${key} is an agent's key; a participant takes a key of its own`);
+    if (
+      labels !== undefined &&
+      (typeof labels !== "object" ||
+        labels === null ||
+        Array.isArray(labels) ||
+        !isJsonValue(labels))
+    )
+      throw new Error("a participant's labels are a JSON object");
+    const to = (spec as { to?: unknown }).to;
+    if (to !== undefined && to !== "code")
+      throw new Error(`a participant's messages go to agents, or to: "code"; not ${String(to)}`);
+    if (to === "code" && !this.options.mailbox)
+      throw new Error(
+        "a participant routed to the code needs a workflow with events, whose waits take its replies",
+      );
+    this.#messaging.connect(
+      key,
+      labels === undefined ? undefined : structuredClone(labels),
+      to === "code" ? "code" : undefined,
+    );
+    const ref: ParticipantRef = {
+      ...participantRef(key),
+      release: async (reason) => {
+        if (reason !== undefined && typeof reason !== "string")
+          throw new Error("a release's reason is a string");
+        return this.#messaging.release(key, reason);
+      },
+    };
+    if (to === "code") {
+      const routed = source(
+        {
+          ...ref,
+          post: async (text: string) => {
+            if (typeof text !== "string" || text.trim() === "")
+              throw new Error("post takes the text to write");
+            await this.#messaging.post(key, text);
+          },
+        },
+        { name: "participant:reply", from: key },
+      ) as unknown as CodeParticipantRef;
+      this.#outsideRefs.set(key, routed);
+      return routed;
+    }
+    this.#outsideRefs.set(key, ref);
+    return ref;
+  }
+
+  /** A key an agent may not take: a reserved one, or an outside participant's. */
+  #assertFreeKey(key: string, who: string): void {
+    if ((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`,
+      );
+    if (this.#messaging.isOutside(key))
+      throw new Error(`${key} is a participant outside the run; ${who} takes another key`);
+  }
+
   #messagesChanged(): void {
     const change = this.#messagingChange;
     this.#messagingChange = Promise.withResolvers<void>();
@@ -930,13 +1578,16 @@ class WorkflowOwner {
     const end = (ref: unknown): string => {
       const key =
         typeof ref === "object" && ref !== null ? (ref as { key?: unknown }).key : undefined;
-      const agent = typeof key === "string" ? this.#logical.get(key) : undefined;
-      if (!agent || agent !== ref) {
+      const issued =
+        typeof key === "string"
+          ? (this.#logical.get(key) ?? this.#outsideRefs.get(key))
+          : undefined;
+      if (!issued || issued !== ref) {
         throw new Error(
-          `a route's ends are agents this workflow opened; ${typeof key === "string" ? key : "this"} is not one`,
+          `a route's ends are agents this workflow opened or participants it connected; ${typeof key === "string" ? key : "this"} is not one`,
         );
       }
-      return agent.key;
+      return issued.key;
     };
     if (typeof access !== "object" || access === null)
       throw new Error("a route is { from, to } or { between }, with a purpose");
@@ -952,6 +1603,7 @@ class WorkflowOwner {
     this.#messaging.grant(ends, {
       purpose: access.purpose,
       maxMessages: access.maxMessages,
+      timeoutMs: access.timeoutMs,
       scope: scope?.messages ?? this.#messaging.attempt,
     });
   }
@@ -1007,7 +1659,8 @@ class WorkflowOwner {
 
   /**
    * The workflow returned: its routes outside any stage take nothing new, and the message
-   * operations they opened are waited for, as a stage waits for its own.
+   * operations they opened are waited for, as a stage waits for its own. A question open to an
+   * outside participant keeps it waiting too; once none is, each one still connected is released.
    */
   async settleMessages(): Promise<void> {
     const attempt = this.#messaging.attempt;
@@ -1017,6 +1670,9 @@ class WorkflowOwner {
       const failed = settled.find((each) => each.status === "rejected");
       if (failed?.status === "rejected") throw failed.reason;
     });
+    for (const key of this.#messaging.connected()) {
+      this.#messaging.release(key, "the workflow returned");
+    }
   }
 
   async close(deadline: AbsoluteDeadline): Promise<unknown[]> {
@@ -1033,7 +1689,9 @@ class WorkflowOwner {
             state
               .stopOperations({
                 kind:
-                  Date.now() >= this.options.deadline.unixMilliseconds ? "timed-out" : "cancelled",
+                  this.options.deadline && Date.now() >= this.options.deadline.unixMilliseconds
+                    ? "timed-out"
+                    : "cancelled",
                 reason: "workflow closing",
               })
               .then(() => state.close("workflow complete")),
@@ -1119,7 +1777,19 @@ class WorkflowOwner {
     });
     if (entered.kind === "reuse") {
       entered.release();
-      return entered.value;
+      // A stage around a wait returns the batch it took, which its record doesn't hold.
+      const batch =
+        entered.value === undefined && !options
+          ? await this.options.mailbox?.batchOf(name)
+          : undefined;
+      if (batch) {
+        if (this.#waitedStages.has(name))
+          throw new Error(
+            `stage ${name} around a wait was entered again in this attempt, and would return the same batch forever; name it by what it waits for`,
+          );
+        this.#waitedStages.add(name);
+      }
+      return (batch as JsonValue | undefined) ?? entered.value;
     }
     const open = entered.stage;
     const messages = this.#messaging.scope(name);
@@ -1137,7 +1807,22 @@ 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.
+      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;
@@ -1149,12 +1834,15 @@ class WorkflowOwner {
       }).catch(() => undefined);
       const stopped = this.options.stages.stopped;
       if (stopped && error === stopped && stopped.stage === name) await open.stop(stopped.reason);
+      // Parked at a wait in it: not ended, so the next attempt runs it again.
+      else if (error instanceof RunParked) this.options.stages.abandon(name);
       else {
         this.options.stages.failedIn(name, error);
         await open.fail(messageOf(error));
       }
       throw error;
     } finally {
+      this.#stageBatches.delete(name);
       this.#messaging.closeScope(messages);
       this.#stageScopes.delete(messages);
       removeFromParent?.();
@@ -1164,6 +1852,7 @@ class WorkflowOwner {
   private openAgent(spec: AgentOpenSpec): Promise<AgentRef> {
     if (this.#closed || this.#cleanupFailures.length) throw new Error("workflow context is closed");
     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`);
     }
@@ -1172,6 +1861,12 @@ 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;
+    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 execution = existing
       ? constrainExistingExecution(spec.runtime, existing.identity.execution)
       : withKnownEffort(resolveExecution(spec.runtime, this.options.runtime));
@@ -1198,6 +1893,8 @@ class WorkflowOwner {
     assertDeadline(effectiveDeadline);
     if (existing) {
       assertCompatibleAgent(spec.key, existing.identity, identity, spec);
+      this.#tools.reopen(spec.key, spec.tools);
+      if (keepAlive) existing.keepAlive = keepAlive;
       const seated =
         spec.sandbox === undefined
           ? existing.state
@@ -1209,7 +1906,20 @@ class WorkflowOwner {
       return attached;
     }
 
+    this.#tools.give(spec.key, spec.tools ?? {});
     this.options.progress.agentOpened(spec.key, scope?.group);
+    const found = this.options.keptSessions?.get(spec.key);
+    // Reopened only where it can be: a key the code now opens on another harness starts afresh, and
+    // so does an agent with a home of its own, skills or a sandbox, made anew at every open, which
+    // its kept session isn't in. Either is given its instructions again.
+    const homeOfItsOwn = spec.skills !== undefined || spec.sandbox !== undefined || inRunSandbox;
+    const kept = found?.harness === execution.harness && !homeOfItsOwn ? found : undefined;
+    if (found && !kept)
+      this.options.onLog?.(
+        homeOfItsOwn
+          ? `agent ${spec.key} has skills or a sandbox, whose home is made anew; it starts a new session`
+          : `agent ${spec.key} now runs ${execution.harness}, not the ${found.harness} its session was kept on; it starts a new session`,
+      );
     // Opened before the session so registration below stays synchronous: two concurrent `agent()`
     // calls for one key must not each build an agent.
     const sessions: AgentSessions = { launcher: new Set(), forks: [] };
@@ -1228,10 +1938,13 @@ class WorkflowOwner {
       ...(identity.skills ? { skills: identity.skills } : {}),
       activation: (cwd, seated, skills, home) => ({
         key: spec.key,
-        deadline: effectiveDeadline,
+        deadline: harnessDeadline(effectiveDeadline),
         cwd,
         execution,
-        ...(spec.instructions === undefined ? {} : { instructions: spec.instructions }),
+        // 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 }),
         ...(seated ? { occupant: seated.occupant } : {}),
         ...(seated?.webSearch ? { webSearch: true } : {}),
@@ -1263,6 +1976,7 @@ class WorkflowOwner {
         (opened) => opened,
         () => undefined,
       ),
+      ...(keepAlive ? { keepAlive } : {}),
     });
     const activated = this.track(waitForDeadline(ownedState, effectiveDeadline));
     scope?.track(activated);
@@ -1275,6 +1989,8 @@ class WorkflowOwner {
    */
   private stopAgent(key: string, reason?: string): Promise<boolean> {
     if (this.#closed || this.#cleanupFailures.length) throw new Error("workflow context is closed");
+    const inTool = refusedInTool(key, "agents.stop");
+    if (inTool) throw inTool;
     const scope = scopes.getStore();
     scope?.assertAccepting();
     this.options.stages.checkOperation();
@@ -1334,6 +2050,7 @@ class WorkflowOwner {
     if (this.#closed || this.#cleanupFailures.length) throw new Error("workflow context is closed");
     const scope = scopes.getStore();
     scope?.assertAccepting();
+    this.#assertFreeKey(key, "an agent");
     const found = this.options.runtime.host.caller;
     if (!found) return Promise.resolve(null);
     if (this.#caller) {
@@ -1371,7 +2088,7 @@ class WorkflowOwner {
         );
         const session = await this.options.host.openAgent({
           key,
-          deadline: this.options.deadline,
+          deadline: harnessDeadline(this.options.deadline),
           cwd: found.cwd,
           execution,
         });
@@ -1659,6 +2376,7 @@ class WorkflowOwner {
       key,
       runDir: this.options.runDir,
       messaging: this.#messaging,
+      tools: this.#tools,
       messageOwner: (scope) => this.#messageOwner(scope),
       execution,
       session,
@@ -1679,8 +2397,12 @@ class WorkflowOwner {
         this.options.failRun(error);
       },
       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,
+      keepAlive: () => this.#agents.get(key)?.keepAlive,
+      defaultWindowMs: this.options.defaultWindowMs ?? DEFAULT_WINDOW_MS,
+      now: this.options.now,
       // Its socket is its authority: a kept agent's harness lives on, and must not answer.
       revoke: () =>
         this.#agents
@@ -1723,12 +2445,17 @@ class WorkflowOwner {
     if (this.#caller?.key === spec.key) {
       throw new Error(`agent ${spec.key} is the calling session; it is not opened`);
     }
-    const forkSpec = structuredClone(spec);
+    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);
     if (forkSpec.layout !== undefined) forkSpec.layout = storedLayout(forkSpec.layout);
     const deadline = 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;
+    if (from === CALLING && tools !== undefined)
+      throw new Error(`agent ${spec.key}: a fork of the calling session takes no tools`);
     const existing = this.#agents.get(spec.key);
     if (existing) {
       if (existing.stopped !== undefined) throw stoppedError(spec.key, existing.stopped);
@@ -1736,6 +2463,7 @@ class WorkflowOwner {
       if (forked?.parent !== from || !isDeepStrictEqual(forked.spec, forkSpec)) {
         throw new Error(`agent ${spec.key} is already open, not as this fork of ${from}`);
       }
+      this.#tools.reopen(spec.key, tools);
       const attached = this.track(waitForDeadline(existing.state, deadline));
       scope?.track(attached);
       return attached;
@@ -1743,6 +2471,8 @@ class WorkflowOwner {
     const parent = unopened ?? this.#agents.get(parentKey)!;
     const opening = parent.opening!;
     if (typeof take === "string") throw new Error(take);
+    // The parent's tools, with the handlers they have now, unless it gives its own.
+    this.#tools.give(spec.key, tools ?? this.#tools.of(parentKey));
     const sandboxed = parent.identity.sandbox !== undefined || this.options.sandboxes.hasRunSandbox;
     // A parent with a harness home of its own has its session copied out, and the fork made in the
     // child's home: anything added to the parent's would be read as the parent's.
@@ -1829,7 +2559,7 @@ class WorkflowOwner {
       ...(sandboxed && copy ? { carried: { parent: parentKey, forked, copy } } : {}),
       activation: (cwd, seated, given, home) => ({
         key: spec.key,
-        deadline,
+        deadline: harnessDeadline(deadline),
         cwd,
         execution,
         ...(forkSpec.instructions === undefined ? {} : { instructions: forkSpec.instructions }),
@@ -1937,7 +2667,7 @@ class WorkflowOwner {
    */
   private besideFallback(
     layout: PaneLayout | undefined,
-    deadline: AbsoluteDeadline,
+    deadline: AbsoluteDeadline | undefined,
   ): () => Promise<string | undefined> {
     const known = (reason: string | undefined) => () => Promise.resolve(reason);
     const target = besideOf(layout);
@@ -2030,12 +2760,17 @@ class LogicalAgent implements AgentRef {
   #hasRun = false;
   /** Supervisors of its open operation, woken when something arrives for it. */
   readonly #watchers = new Set<() => void>();
+  /** When its last turn this attempt that opens a window ended. */
+  #lastEnd: number | undefined;
+  /** A turn that opens a window ended since its `onTimeout` was last called. */
+  #timeoutOwed = false;
 
   constructor(
     private readonly options: {
       key: string;
       runDir: string;
       messaging: Messaging;
+      tools: ToolCalls<ExecutionScope>;
       /**
        * What owns a message operation a route in `scope` opens: its stage, or the attempt outside
        * any stage. Undefined once that scope has closed: nothing opens for it then.
@@ -2049,7 +2784,7 @@ class LogicalAgent implements AgentRef {
       endpoint: string;
       /** The path this agent is told to run; see `installAgentLauncher`. */
       launcher: string;
-      deadline: AbsoluteDeadline;
+      deadline: AbsoluteDeadline | undefined;
       ledger: AgentLedger;
       progress: RunProgress;
       recordTurn: RecordTurn;
@@ -2062,6 +2797,7 @@ class LogicalAgent implements AgentRef {
       livenessPolicy?: LivenessPolicy;
       /** After each operation settles, whatever its outcome. */
       afterOperation?(): Promise<void>;
+      turns?: LogicalAgentTurns;
       /**
        * Opens `spec`'s agent on the native fork `take` queues in this agent's operations, at
        * `settings`, this agent's once the operations before the fork have run.
@@ -2073,11 +2809,27 @@ class LogicalAgent implements AgentRef {
       ): Promise<AgentRef>;
       /** 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`. */
+      defaultWindowMs: number;
+      /** The run's time, which its window is measured on. */
+      now: () => number;
       /** Closes its result channel, once its pane is kept. */
       revoke(): Promise<void> | undefined;
     },
   ) {
     this.#execution = options.execution;
+    asSource(this, { name: "agent:ended", from: options.key });
+    // A turn an earlier attempt started whose end no wait took is this agent's turn again.
+    const restored = options.turns?.restored();
+    if (restored)
+      this.#started = {
+        ref: turnRef(options.key, restored.turn, async () => false),
+        meta: restored.meta,
+        ended: true,
+        done: Promise.resolve(),
+      };
   }
 
   get key(): string {
@@ -2109,21 +2861,172 @@ class LogicalAgent implements AgentRef {
     return this.#closed ? (this.#closedReason ?? "closed") : undefined;
   }
 
+  /** The end of its window while one is open; a closed agent holds none. */
+  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);
+    return until > now ? until : undefined;
+  }
+
+  /**
+   * Its `onTimeout`, once its window has passed with it idle and a turn owed it, taken: it isn't
+   * due again until another turn ends.
+   */
+  takeTimeout(now = this.options.now()): KeepAlive["onTimeout"] {
+    const onTimeout = this.options.keepAlive()?.onTimeout;
+    if (!onTimeout || !this.#timeoutOwed || this.#closed || this.busy || this.#started)
+      return undefined;
+    if (this.liveUntil(now) !== undefined) return undefined;
+    this.#timeoutOwed = false;
+    return onTimeout;
+  }
+
   /**
    * Something arrived for it: its open operation's supervisor looks again, and an agent with
    * nothing queued wakes for a held message, in a message operation.
    */
   messagesChanged(): void {
     for (const wake of this.#watchers) wake();
-    if (this.#queued > 0 || this.#closed || this.options.isRunClosing()) return;
+    // A started turn holds messages until a wait has taken its end.
+    if (this.#queued > 0 || this.#started || this.#closed || this.options.isRunClosing()) return;
     const opening = this.options.messaging.opening(this.key);
     if (opening) this.startMessageOperation(opening.scope);
   }
 
-  enqueue(_spec: AgentTextTurnSpec): Promise<never>;
-  enqueue<T extends JsonValue>(_spec: AgentStructuredTurnSpec<T>): Promise<never>;
-  enqueue(): Promise<never> {
-    return unavailable("AgentRef.enqueue");
+  /** The turn `start()` began, until a wait takes its end. */
+  #started: { ref: StartedTurn; meta: JsonValue; ended: boolean; done: Promise<void> } | undefined;
+  /** While `start()` hands its turn to `run()`, which refuses one otherwise. */
+  #launching = false;
+  /** Each running turn's own stop, by its id: what a started turn's `cancel()` stops. */
+  readonly #stopsByTurn = new Map<string, (stop: OperationStop) => Promise<void>>();
+  /** Started turns cancelled while still queued behind other work: they settle cancelled. */
+  readonly #cancelledTurns = new Map<string, string>();
+
+  get turn(): StartedTurn | null {
+    return this.#started?.ref ?? null;
+  }
+
+  /** Whether a started turn is set: messages wait, and awaited replies are refused. */
+  get hasStartedTurn(): boolean {
+    return this.#started !== undefined;
+  }
+
+  /** A wait took this turn's end: the agent takes other work again. */
+  endTaken(turn: TurnId): void {
+    if (this.#started?.ref.id !== turn) return;
+    this.#started = undefined;
+    this.messagesChanged();
+  }
+
+  /** Cancels a started turn still running and waits for its end: the code returned or threw. */
+  async endStarted(reason: string): Promise<void> {
+    const started = this.#started;
+    if (!started || started.ended) return;
+    await started.ref.cancel(reason);
+  }
+
+  async start(spec: AgentStartSpec): Promise<StartedTurn> {
+    const { turns } = this.options;
+    if (!turns) return unavailable("AgentRef.start");
+    if (this.#closed) throw new Error("logical agent is closed");
+    const inTool = refusedInTool(this.key, "start()");
+    if (inTool) throw inTool;
+    const scope = scopes.getStore();
+    if (scope !== undefined)
+      throw new Error(
+        `agent ${this.key}: start() is called at the run's root, as a turn not awaited would outlive a stage or a parallel`,
+      );
+    const refused = this.#refusedWhileStarted("start");
+    if (refused) throw refused;
+    const { meta = null, ...run } = spec;
+    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";
+      }),
+      meta,
+      ended: false,
+      done: ended.promise,
+    };
+    // Claimed before anything is awaited, so a second start() at once is refused.
+    this.#started = started;
+    try {
+      // Recorded before the agent is launched: a crash between leaves a turn a continue ends.
+      await turns.begin(id, meta, this.options.execution);
+    } catch (error) {
+      this.#started = undefined;
+      // A message held while it began is taken now.
+      this.messagesChanged();
+      throw error;
+    }
+    this.#launching = true;
+    let launched: Promise<RunResult<JsonValue>>;
+    try {
+      launched = outsideTools(() => this.run({ ...run, id } as AgentRunStructuredSpec<JsonValue>));
+    } 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.
+    this.options.track(
+      launched
+        .then(
+          ({ outcome }) => outcome,
+          (error: unknown): TurnOutcome<JsonValue> => ({
+            kind: "failed",
+            reason: messageOf(error),
+            retryable: false,
+            usage: unrunUsage(this.key, id, this.options.execution),
+          }),
+        )
+        .then(async (outcome) => {
+          await turns.end(id, meta, outcome);
+          written = outcome.kind;
+        })
+        // An end that can't be written leaves the turn set for good: the run can't go on.
+        .catch((error: unknown) =>
+          this.options.cleanupUnresolved(
+            `agent ${this.key}'s turn ${id} ended, and its end was not written: ${messageOf(error)}`,
+          ),
+        )
+        .finally(() => {
+          started.ended = true;
+          ended.resolve();
+        }),
+    );
+    return started.ref;
+  }
+
+  #refusedWhileStarted(what: string): Error | undefined {
+    // First: from a handler this agent is in, its turn waits for the handler, started or not.
+    const inTool = refusedInTool(this.key, `${what}()`);
+    if (inTool) return inTool;
+    if (this.#started && !this.#launching)
+      return new Error(
+        `agent ${this.key} has a turn started (${this.#started.ref.id}) whose end no wait has taken; ${what}() waits for it`,
+      );
+  }
+
+  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;
   }
 
   run(spec: AgentRunTextSpec): Promise<RunResult<string>>;
@@ -2132,6 +3035,8 @@ class LogicalAgent implements AgentRef {
     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();
@@ -2139,6 +3044,7 @@ class LogicalAgent implements AgentRef {
     } catch (error) {
       return Promise.reject(error);
     }
+    const opensWindow = !inTimeoutHandler();
     const id = spec.id ?? randomUUID();
     const completeSpec = structuredClone({ ...spec, id }) as
       | AgentRunTextSpec
@@ -2155,7 +3061,7 @@ class LogicalAgent implements AgentRef {
       scope?.track(existing.result);
       return existing.result as Promise<RunResult<string | T>>;
     }
-    let deadline: AbsoluteDeadline;
+    let deadline: AbsoluteDeadline | undefined;
     try {
       deadline = this.operationDeadline(spec, scope);
       const recoveryDeadline = spec.nudge ? spec.nudge.deadline : undefined;
@@ -2173,13 +3079,24 @@ class LogicalAgent implements AgentRef {
         throw new Error("logical agent is closed");
       }
       scope?.assertActive();
+      const cancelled = this.#cancelledTurns.get(id);
+      if (cancelled !== undefined) {
+        this.#cancelledTurns.delete(id);
+        return {
+          outcome: {
+            kind: "cancelled",
+            reason: cancelled,
+            usage: unrunUsage(this.key, id, this.options.execution),
+          },
+        } as RunResult<JsonValue>;
+      }
       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);
       this.options.progress.turnStarted(this.key, tags);
       try {
         const settled = await this.executeOperation(completeSpec, scope, deadline, operation);
-        this.turnEnded(settled.outcome, "turn");
+        this.turnEnded(settled.outcome, "turn", opensWindow);
         return settled;
       } catch (error) {
         operation.failed(error);
@@ -2197,6 +3114,8 @@ class LogicalAgent implements AgentRef {
 
   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();
@@ -2220,7 +3139,7 @@ class LogicalAgent implements AgentRef {
     }
     let deadline: AbsoluteDeadline;
     try {
-      deadline = this.operationDeadline(spec, scope);
+      deadline = harnessDeadline(this.operationDeadline(spec, scope));
     } catch (error) {
       const rejected = Promise.reject<TurnOutcome<string>>(error);
       scope?.track(rejected);
@@ -2255,6 +3174,8 @@ class LogicalAgent implements AgentRef {
   /** 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();
@@ -2279,7 +3200,7 @@ class LogicalAgent implements AgentRef {
     let deadline: AbsoluteDeadline;
     try {
       change = this.settingsChange(spec);
-      deadline = this.operationDeadline(spec, scope);
+      deadline = harnessDeadline(this.operationDeadline(spec, scope));
     } catch (error) {
       const rejected = Promise.reject<TurnOutcome<null>>(error);
       scope?.track(rejected);
@@ -2363,7 +3284,16 @@ class LogicalAgent implements AgentRef {
   }
 
   /** A turn or compaction that settled, as the view shows it and `turns.jsonl` keeps it. */
-  private turnEnded(outcome: TurnOutcome<JsonValue>, kind: TurnRecord["kind"]): void {
+  private turnEnded(
+    outcome: TurnOutcome<JsonValue>,
+    kind: TurnRecord["kind"],
+    opensWindow = false,
+  ): void {
+    // A failure has closed it by now, and a closed agent holds no window.
+    if (opensWindow && !this.#closed) {
+      this.#lastEnd = this.options.now();
+      this.#timeoutOwed = true;
+    }
     this.#last = outcome.kind;
     const reason = "reason" in outcome ? outcome.reason : undefined;
     this.options.progress.turnSettled(this.key, outcome.kind, reason);
@@ -2372,6 +3302,8 @@ class LogicalAgent implements AgentRef {
 
   fork(spec: AgentForkSpec): Promise<AgentRef> {
     if (this.#closed) return Promise.reject(new Error("logical agent is closed"));
+    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;
@@ -2419,7 +3351,7 @@ class LogicalAgent implements AgentRef {
   private operationDeadline(
     spec: { deadline?: AbsoluteDeadline; timeoutMs?: number },
     scope: ExecutionScope | undefined,
-  ): AbsoluteDeadline {
+  ): AbsoluteDeadline | undefined {
     if (spec.deadline && spec.timeoutMs !== undefined) {
       throw new Error("an operation cannot specify both deadline and timeoutMs");
     }
@@ -2430,8 +3362,9 @@ class LogicalAgent implements AgentRef {
     return earlierDeadline(spec.deadline, ceiling);
   }
 
-  private deadlineCeiling(scope: ExecutionScope | undefined): AbsoluteDeadline {
-    return scope ? earlierDeadline(scope.deadline, this.options.deadline) : this.options.deadline;
+  /** The deadlines around an operation: its scope's and the run's, if either has one. */
+  private deadlineCeiling(scope: ExecutionScope | undefined): AbsoluteDeadline | undefined {
+    return earlierDeadline(scope?.deadline, this.options.deadline);
   }
 
   /** Its settings once every `set` queued so far has run. */
@@ -2619,7 +3552,7 @@ class LogicalAgent implements AgentRef {
   private async executeOperation(
     spec: AgentRunTextSpec | AgentRunStructuredSpec<JsonValue>,
     scope: ExecutionScope | undefined,
-    operationDeadline: AbsoluteDeadline,
+    operationDeadline: AbsoluteDeadline | undefined,
     operation: OperationLog,
   ): Promise<RunResult<JsonValue>> {
     const nudge = spec.nudge === false ? undefined : (spec.nudge ?? this.defaultNudge());
@@ -2631,7 +3564,7 @@ class LogicalAgent implements AgentRef {
   private async executeWaitingOperation(
     spec: AgentRunTextSpec | AgentRunStructuredSpec<JsonValue>,
     scope: ExecutionScope | undefined,
-    deadline: AbsoluteDeadline,
+    initial: AbsoluteDeadline | undefined,
     { operationId, tags, delivered, session }: OperationLog,
     nudge: Exclude<AgentRunTextSpec["nudge"], false>,
   ): Promise<RunResult<JsonValue>> {
@@ -2639,14 +3572,25 @@ class LogicalAgent implements AgentRef {
     const binding = { endpoint: this.options.endpoint, operationId };
     const entry = this.options.ledger.reserve(operationId, () => this.#execution, tags);
     const { messaging } = this.options;
+    // Moves out by any wait on an outside participant, within the deadlines around it.
+    let deadline = initial;
+    const ceiling = this.deadlineCeiling(scope);
     messaging.opened({
       id: operationId,
       agent: this.key,
       kind: "workflow",
-      deadline: deadline.unixMilliseconds,
-      ceiling: this.options.deadline.unixMilliseconds,
+      ...(deadline ? { deadline: deadline.unixMilliseconds } : {}),
+      ...(ceiling ? { ceiling: ceiling.unixMilliseconds } : {}),
       scope: scope?.messages ?? messaging.attempt,
     });
+    this.options.tools.opened({
+      id: operationId,
+      agent: this.key,
+      callPath: [],
+      ...(scope?.stage === undefined ? {} : { stage: scope.stage }),
+      scope,
+      deadline: () => deadline?.unixMilliseconds,
+    });
     // After its prompt: how to use its routes, then each message held for it, wrapped.
     const joined = messaging.take(operationId, "joins");
     const prompt = [spec.prompt, messaging.lesson(this.key), joined?.text]
@@ -2675,12 +3619,16 @@ class LogicalAgent implements AgentRef {
             "Finish or stop work needed for this answer before submitting the result.",
             `If waiting for work to finish, report it now using: ${this.options.launcher} waiting ${operationId} --reason 'what you are waiting for' [--timeout 2m]`,
             "Omit the square brackets when running the optional timeout flag. This command acknowledges your wait immediately; it does not sleep.",
-            `The fixed answer deadline is ${new Date(deadline.unixMilliseconds).toISOString()}. Waiting never extends it.`,
+            ...(deadline
+              ? [
+                  `The answer deadline is ${new Date(deadline.unixMilliseconds).toISOString()}. ${this.options.launcher} waiting never extends it.`,
+                ]
+              : []),
           ].join("\n")
         : "");
     const events = createOperationEvents(this.options.runDir, operationId);
     const messages = this.operationMessages(operationId, `${spec.id!}:message`, {
-      deadline: () => deadline,
+      deadline: () => harnessDeadline(deadline),
       authored,
       session,
       record: events.record,
@@ -2692,7 +3640,17 @@ class LogicalAgent implements AgentRef {
       agentId: this.key,
       question: spec.prompt,
       schema,
-      deadline,
+      ...(deadline ? { deadline } : {}),
+      ...(ceiling ? { ceiling: ceiling.unixMilliseconds } : {}),
+      extended: (moved, waiting) => {
+        const next = moved === undefined ? undefined : { unixMilliseconds: moved };
+        this.options.slots.extend(operationId, next);
+        if (waiting || moved === undefined || moved <= (deadline?.unixMilliseconds ?? Infinity))
+          return;
+        deadline = next;
+        messaging.extended(operationId, moved);
+        events.record({ kind: "deadline-extended", at: Date.now(), sequence: 0, until: moved });
+      },
       slots: this.options.slots,
       waitingSupported,
       nudge: nudge !== undefined,
@@ -2702,8 +3660,17 @@ class LogicalAgent implements AgentRef {
           .start(
             {
               id: spec.id!,
-              prompt: operationPrompt(prompt, schema, this.options.launcher, operationId),
-              deadline,
+              prompt: [
+                operationPrompt(prompt, schema, this.options.launcher, operationId),
+                toolsLesson(
+                  this.options.tools.taught(this.key),
+                  this.options.launcher,
+                  simpleInput(schema) !== undefined,
+                ),
+              ]
+                .filter(Boolean)
+                .join("\n\n"),
+              deadline: harnessDeadline(deadline),
               authored,
               onSession: session,
             },
@@ -2713,17 +3680,24 @@ class LogicalAgent implements AgentRef {
       successor: (turn, sequence, deliverySignal) =>
         turn.nudge({
           id: `${spec.id!}:check-in:${sequence}`,
-          deadline,
+          deadline: harnessDeadline(deadline),
           deliverySignal,
           prompt: checkInPrompt(recoveryPrompt),
           // A check-in delivers no messages: those its first prompt carried are not its own.
           authored: { ...withoutMessages(authored), prompt: recoveryPrompt },
         }),
-      onStop: (stop) => {
+      onStop: (settle) => {
+        // A cancel or stop reaches a running tool call at once: the turn may be waiting on it.
+        const stop = (request: OperationStop) => {
+          this.options.tools.abort(operationId, request.kind);
+          return settle(request);
+        };
         this.#operationStops.add(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!);
           remove?.();
         };
       },
@@ -2741,6 +3715,8 @@ class LogicalAgent implements AgentRef {
         }),
       )
       .finally(() => events.close());
+    // A call still running is stopped and waited for: run() resolves once its calls have settled.
+    await this.options.tools.ended(operationId);
     // Its wait is dropped and what it still owed fails, before a failure closes the agent.
     messaging.ended(operationId, operationEnd(outcome.kind));
     if (outcome.cleanupUnresolved) {
@@ -2870,14 +3846,17 @@ class LogicalAgent implements AgentRef {
   private startMessageOperation(scope: MessagingScope): void {
     const owner = this.options.messageOwner(scope);
     if (!owner) return;
-    const result = this.queue(async () => {
-      if (this.#closed || this.options.isRunClosing()) return;
-      // What is first now: a message dropped since this was queued leaves another route's, which
-      // waits for an operation of its own scope.
-      const opening = this.options.messaging.opening(this.key);
-      if (opening?.scope !== scope) return;
-      await this.executeMessageOperation(opening.from, scope, owner.stage);
-    });
+    // Whatever code made the message due, a handler included, nothing waits for its operation.
+    const result = outsideTools(() =>
+      this.queue(async () => {
+        if (this.#closed || this.options.isRunClosing()) return;
+        // What is first now: a message dropped since this was queued leaves another route's, which
+        // waits for an operation of its own scope.
+        const opening = this.options.messaging.opening(this.key);
+        if (opening?.scope !== scope) return;
+        await this.executeMessageOperation(opening.from, scope, owner.stage);
+      }),
+    );
     this.options.track(result).catch(() => undefined);
     owner.adopt(result);
   }
@@ -2889,8 +3868,8 @@ class LogicalAgent implements AgentRef {
   ): Promise<void> {
     const { messaging } = this.options;
     const operationId = randomUUID();
-    const ceiling = this.deadlineCeiling(stage).unixMilliseconds;
-    let deadline = Math.min(Date.now() + messaging.limits.operationMs, ceiling);
+    const ceiling = this.deadlineCeiling(stage)?.unixMilliseconds;
+    let deadline = Math.min(Date.now() + messaging.limits.operationMs, ceiling ?? Infinity);
     messaging.opened({
       id: operationId,
       agent: this.key,
@@ -2899,6 +3878,14 @@ class LogicalAgent implements AgentRef {
       ceiling,
       scope,
     });
+    this.options.tools.opened({
+      id: operationId,
+      agent: this.key,
+      callPath: [],
+      ...(stage?.stage === undefined ? {} : { stage: stage.stage }),
+      scope: stage,
+      deadline: () => deadline,
+    });
     /** How it ended; unset until its supervisor says, or if it never opened. */
     let end: SupervisedOutcome["kind"] | undefined;
     try {
@@ -2934,9 +3921,13 @@ class LogicalAgent implements AgentRef {
         }
         throw error;
       } finally {
+        // Its agent ended its turn with a call running, say: the call is stopped and waited for, so
+        // nothing after it, nor the next operation, runs with this one's call still running.
+        await this.options.tools.ended(operationId);
         await this.options.afterOperation?.();
       }
     } finally {
+      await this.options.tools.ended(operationId);
       // A message operation that simply ends settles; its wait is dropped and what it owed fails.
       messaging.ended(
         operationId,
@@ -2968,16 +3959,32 @@ class LogicalAgent implements AgentRef {
       cause,
       messages: opening.messages,
     };
+    const extended = (later: number) => {
+      if (later <= deadline) return;
+      deadline = later;
+      messaging.extended(operationId, later);
+      this.options.tools.extended(operationId, later);
+      events.record({ kind: "deadline-extended", at: Date.now(), sequence: 0, until: later });
+    };
+    const ceiling = this.deadlineCeiling(stage)?.unixMilliseconds;
     let outcome: SupervisedOutcome;
     try {
       outcome = await superviseMessageOperation({
         deadline: () => deadline,
+        ...(ceiling === undefined ? {} : { ceiling }),
+        extended,
         start: () =>
           this.options.session
             .start(
               {
                 id: operationId,
-                prompt: opening.text,
+                // A message turn's tools block, as a workflow turn's: after what it opens on.
+                prompt: [
+                  opening.text,
+                  toolsLesson(this.options.tools.taught(this.key), this.options.launcher, false),
+                ]
+                  .filter(Boolean)
+                  .join("\n\n"),
                 deadline: { unixMilliseconds: deadline },
                 authored,
                 onSession: operation.session,
@@ -2990,14 +3997,13 @@ class LogicalAgent implements AgentRef {
           authored,
           session: operation.session,
           record: events.record,
-          extended: (later) => {
-            if (later <= deadline) return;
-            deadline = later;
-            messaging.extended(operationId, later);
-            events.record({ kind: "deadline-extended", at: Date.now(), sequence: 0, until: later });
-          },
+          extended,
         }),
-        onStop: (stop) => {
+        onStop: (settle) => {
+          const stop = (request: OperationStop) => {
+            this.options.tools.abort(operationId, request.kind);
+            return settle(request);
+          };
           this.#operationStops.add(stop);
           const remove = stage?.add(stop);
           return () => {
@@ -3035,6 +4041,7 @@ class LogicalAgent implements AgentRef {
           ? { kind: "failed", reason: outcome.reason, retryable: false, usage }
           : { kind: outcome.kind, reason: outcome.reason, usage },
       "turn",
+      true,
     );
     return outcome;
   }
@@ -3144,6 +4151,94 @@ class LogicalAgent implements AgentRef {
   }
 }
 
+/** A sleep's time, checked where it is given. */
+function checkedWhen(when: unknown): string | Date {
+  if (when instanceof Date || typeof when === "string") return when;
+  if (readOf(when))
+    throw new Error(
+      "sleep is for a duration or a Date; workflow.at() is a select's branch, read at each of its waits",
+    );
+  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;
+}
+
+/** A wait's branches, by name, checked: a race may give a duration where a select may not. */
+function branchesOf(what: string, branches: unknown, durations: boolean): [string, unknown][] {
+  if (typeof branches !== "object" || branches === null || Array.isArray(branches))
+    throw new Error(`${what} takes its branches as an object, { name: source }`);
+  const entries = Object.entries(branches);
+  if (entries.length === 0) throw new Error(`${what} has no branches: it would never return`);
+  if ("key" in branches) throw new Error(`${what}: no branch is named key, which the answer uses`);
+  for (const [branch, source] of entries)
+    if (typeof source === "string" && !durations)
+      throw new Error(`${what}'s ${branch} is a duration: a timer in a loop is workflow.timer()'s`);
+  return entries;
+}
+
+/** What a time read from state reads, by its source. */
+const timeReads = new WeakMap<object, () => Date | null>();
+
+/** `workflow.at(read)`: a select's branch, due at the time `read` returns. */
+function timeRead(read: () => Date | null): TimeRead {
+  if (typeof read !== "function")
+    throw new Error(
+      "workflow.at takes a function that reads a Date or null from the run's state, as () => ledger.nextNudge()",
+    );
+  const value = Object.freeze({});
+  timeReads.set(value, read);
+  return value as unknown as TimeRead;
+}
+
+/** What a time read from state reads; undefined for any other value. */
+function readOf(value: unknown): (() => Date | null) | undefined {
+  return typeof value === "object" && value !== null ? timeReads.get(value) : undefined;
+}
+
+/** What `source` takes, as a branch gives it. */
+function sourceTake(what: string, branch: string, source: unknown): WaitTake {
+  const take = takeOf(source);
+  if (take) return take;
+  if (readOf(source))
+    throw new Error(
+      `${what}'s ${branch} is workflow.at(), a select's: a race answers once, so it takes a timer, workflow.timer(name, date)`,
+    );
+  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`,
+  );
+}
+
+/** 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 });
+}
+
+/** Timer `name`'s source. */
+function timerSource(mailbox: RunMailbox, name: string, due: string): Timer {
+  return source(
+    { name, due, cancel: () => mailbox.cancelTimer(name) },
+    { name: "timer:due", from: name },
+  ) as unknown as Timer;
+}
+
+/** A started turn, as the code holds it: its id, its cancel, and a source of its end. */
+function turnRef(
+  agent: string,
+  id: string,
+  cancel: (reason?: string) => Promise<boolean>,
+): StartedTurn {
+  return source(
+    { id, cancel },
+    { name: "agent:ended", from: agent, turn: id },
+  ) as unknown as StartedTurn;
+}
+
 class ExecutionScope {
   readonly #cancellers = new Set<(stop: OperationStop) => Promise<unknown>>();
   readonly #owned = new Set<Promise<unknown>>();
@@ -3153,7 +4248,7 @@ class ExecutionScope {
   #cancellation: Promise<void> | undefined;
 
   constructor(
-    readonly deadline: AbsoluteDeadline,
+    readonly deadline: AbsoluteDeadline | undefined,
     /** The labelled `parallel` it runs in, for progress. */
     readonly group?: GroupProgress,
     /** The workflow stage everything in this scope runs in. */
@@ -3167,8 +4262,8 @@ class ExecutionScope {
   }
 
   assertActive(): void {
-    if (this.#cancelled || Date.now() >= this.deadline.unixMilliseconds) {
-      throw new DeadlineExceededError(this.deadline);
+    if (this.#cancelled || (this.deadline && Date.now() >= this.deadline.unixMilliseconds)) {
+      throw new DeadlineExceededError(this.deadline ?? { unixMilliseconds: Date.now() });
     }
   }
 
@@ -3236,7 +4331,7 @@ class ExecutionScope {
 function runParallel<Item, Result>(
   items: readonly Item[],
   operation: (item: Item, index: number) => Promise<Result>,
-  deadline: AbsoluteDeadline,
+  deadline: AbsoluteDeadline | undefined,
   requestedConcurrency?: number,
   openGroup?: () => GroupProgress | undefined,
 ): Promise<Result[]> {
@@ -3256,7 +4351,7 @@ function runParallel<Item, Result>(
 async function executeParallel<Item, Result>(
   items: readonly Item[],
   operation: (item: Item, index: number) => Promise<Result>,
-  deadline: AbsoluteDeadline,
+  deadline: AbsoluteDeadline | undefined,
   concurrency: number,
   parent: ExecutionScope | undefined,
   group?: GroupProgress,
@@ -3293,6 +4388,7 @@ async function executeParallel<Item, Result>(
   });
   let cancelTimer: (() => void) | undefined;
   const expiry = new Promise<never>((_resolve, reject) => {
+    if (!deadline) return;
     cancelTimer = scheduleAt(deadline, () => {
       void scope
         .cancel({ kind: "timed-out", reason: "parallel deadline exceeded" })
@@ -3301,9 +4397,9 @@ async function executeParallel<Item, Result>(
   });
   try {
     await Promise.race([completion, expiry]);
-    if (scope.cancelled || Date.now() >= deadline.unixMilliseconds) {
+    if (scope.cancelled || (deadline && Date.now() >= deadline.unixMilliseconds)) {
       await scope.cancel({ kind: "timed-out", reason: "parallel deadline exceeded" });
-      throw new DeadlineExceededError(deadline);
+      throw new DeadlineExceededError(deadline ?? { unixMilliseconds: Date.now() });
     }
     return results;
   } catch (error) {
@@ -3480,7 +4576,20 @@ function operationPrompt(
   // A quoted heredoc passes the JSON through untouched: a quoted argument broke on shell quoting
   // (story 002). Not indented: a copied terminator with leading spaces never closes the heredoc.
   // The schema itself, not a rendering of it: without its bounds, first answers were 0/160 valid
-  // (E5). `wf` says what to do about a rejection, so the prompt does not.
+  // (E5). `wf` says what to do about a rejection, so the prompt does not. A simple schema is taught
+  // as flags instead, its usage line carrying every bound, which held them as well (story 035, M1).
+  const simple = simpleInput(schema);
+  if (simple) {
+    return [
+      prompt,
+      "",
+      "When the answer is ready, return it by running:",
+      "",
+      `${launcher} result ${callId} ${usageLine(simple)}`,
+      "",
+      QUOTING_RULE,
+    ].join("\n");
+  }
   return [
     prompt,
     "",
@@ -3664,3 +4773,27 @@ function stoppedError(key: string, reason: string): Error {
 function unavailable(name: string): Promise<never> {
   return Promise.reject(new Error(`${name} is not implemented by the minimum workflow runner`));
 }
+
+/**
+ * Each root agent's last native session in a run's turns, where its harness can resume it: what a
+ * event run's continue reopens it on.
+ */
+export function keptSessionsOf(turns: readonly TurnRecord[]): Map<string, NativeFork> {
+  const kept = new Map<string, NativeFork>();
+  for (const turn of turns) {
+    if ((turn.callPath?.length ?? 0) > 0) continue;
+    const session = turn.sessions.at(-1);
+    if (session) kept.set(turn.agent, { harness: session.harness, sessionRef: session.id });
+  }
+  return kept;
+}
+
+/**
+ * In a run of a workflow with `events`: how an agent records a turn `start()` begins and its end,
+ * and the turn an earlier attempt started whose end no wait took, which `turn` is from the start.
+ */
+type LogicalAgentTurns = {
+  begin(turn: TurnId, meta: JsonValue, execution: AgentExecution): Promise<void>;
+  end(turn: TurnId, meta: JsonValue, outcome: TurnOutcome<JsonValue>): Promise<void>;
+  restored(): RestoredTurn | undefined;
+};