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

package/src/holder-command.ts

@@ -2,7 +2,8 @@ import { homedir } from "node:os";
 import type { ParticipantResultJson } from "@agentswf/contract/records";
 import { type ParticipantCode, WIRE_VERSION } from "@agentswf/contract/wire";
 import { liveCoordinatorSocket } from "./coordinator-socket";
-import { deliver, eventIdProblem } from "./emit";
+import { deprecationLine } from "./deprecations";
+import { deliverReply, emitToRun, eventIdProblem } from "./emit";
 import { printEmit } from "./emit-command";
 import { messageOf } from "./errors";
 import { isCode } from "./files";
@@ -71,7 +72,7 @@ export async function holderCommand(
       );
     return result.code === "delivered" ? 0 : 1;
   };
-  const refused = (code: ParticipantCode, error: string) => say({ v: 1, code, error }, "");
+  const refused = (code: ParticipantCode, error: string) => say({ v: 2, code, error }, "");
   const usage = (problem: string) => {
     io.stderr(`awf: ${problem}\n\n${replyUsage}`);
     return 2;
@@ -122,7 +123,7 @@ export async function holderCommand(
     }
     if (!answer)
       throw new Error(
-        `${status.ref} did not answer the request; it may run another version of awf`,
+        `${status.ref} did not answer, most likely as it runs an older awf than this one, which speaks wire version ${WIRE_VERSION}: reach it with the awf it started with, or let it end and continue it under this one.`,
       );
     const result = JSON.parse(answer) as ParticipantResultJson;
     if (result.code !== "delivered") return say(result, "");
@@ -178,11 +179,12 @@ function parseHolder(command: "reply" | "send", rest: readonly string[]): Option
     let agent: string | undefined;
     [ref, agent, text, ...extra] = words;
     if (author !== undefined) throw new Error("--author goes with --event-id");
-    if (!ref || !agent)
+    if (!ref || !agent?.trim())
       throw new Error(`${command} needs a run, <workflow>/<id> or <id>, and an agent`);
     target = { agent, ...(as === undefined ? {} : { as }) };
   }
   if (extra.length > 0) throw new Error("the text is one argument: quote it, or pipe it in");
+  if (as !== undefined && as.trim() === "") throw new Error("--as needs a participant's key");
   if (to !== undefined && !/^\d+\.\d+$/.test(to))
     throw new Error(`--to takes a question's id as awf inbox prints it, such as 1.5, not ${to}`);
   return {
@@ -221,9 +223,11 @@ async function awaitedBy(
 }
 
 /**
- * `awf send {ref} --as {participant} --event-id {message id} {text}`: a reply on a participant the run
- * routed to the code, delivered through the one way in as `participant:reply`, so it continues a
- * parked run. The run is found here, or in a project awf started an event run in (Q15).
+ * `awf send {ref} --as {participant} --event-id {message id} {text}`, deprecated: `awf emit {ref}
+ * {participant}:reply`. It keeps its own refusals and exit codes for the beta: a participant the
+ * run never connected is refused; one the run recorded as routed to the code, declared or by the
+ * deprecated `to: "code"`, gets the reply as before, the workflow's file not loaded; any other is
+ * `awf emit`'s to check against the definition.
  */
 async function toTheCode(
   options: Extract<Options, { id: string }>,
@@ -236,6 +240,7 @@ async function toTheCode(
   const environment = io.environment ?? process.env;
   const { id, as } = options;
   const { refused } = say;
+  io.stderr(deprecationLine("send-event-id"));
   let found: RunStatus;
   try {
     found = await findRunByRef(options.ref, place, home);
@@ -243,37 +248,37 @@ async function toTheCode(
     if (error instanceof RunNotFound) return refused("not-found", error.message);
     return failed(error, place, io, messageOf(error));
   }
-  const { run } = found;
-  const routed = (await readEvents(run.dir)).some(
-    (line) =>
-      line.kind === "participant-connected" && line.participant === as && line.to === "code",
+  const connected = (await readEvents(found.run.dir)).filter(
+    (line) => line.kind === "participant-connected" && line.participant === as,
   );
-  if (!run.record.events || !routed)
+  // As it always did: only a participant the run has connected; `awf emit` doesn't ask.
+  if (!found.run.record.events || connected.length === 0)
     return refused(
       "no-participant",
-      `${found.ref} has no participant ${as} routed to its code; --event-id is for one`,
+      `${found.ref} has no participant ${as} connected to its code; --event-id is for one`,
     );
   const text = options.text ?? (await io.stdin());
   if (text.trim() === "") return say.usage("nothing to say: stdin was empty");
+  const data = { text, ...(options.author === undefined ? {} : { author: options.author }) };
+  const context = { home, environment };
+  // Recorded as routed to the code, by either form: delivered as before, the file not loaded.
+  if (connected.some((line) => line.kind === "participant-connected" && line.to)) {
+    try {
+      return printEmit(await deliverReply(found, as, { data, id }, context), json, io);
+    } catch (error) {
+      return failed(error, place, io, messageOf(error));
+    }
+  }
+  // Connected to agents only, which send has always refused: whatever stops `awf emit`, a file
+  // that won't load included, is that refusal, with its reason.
+  let result: Awaited<ReturnType<typeof emitToRun>>;
   try {
-    const result = await deliver(
-      {
-        runRoot: run.root,
-        workflow: run.record.workflow,
-        runId: run.record.id,
-        event: {
-          id,
-          name: "participant:reply",
-          data: { text, ...(options.author === undefined ? {} : { author: options.author }) },
-          from: as,
-          at: new Date().toISOString(),
-        },
-        deduplicate: true,
-      },
-      { home, environment },
-    );
-    return printEmit(result, json, io);
+    result = await emitToRun(found, { name: `${as}:reply`, data, id }, context);
   } catch (error) {
-    return failed(error, place, io, messageOf(error));
+    return refused(
+      "no-participant",
+      `${found.ref} has no participant ${as} whose messages go to its code: ${messageOf(error)}`,
+    );
   }
+  return printEmit(result, json, io);
 }

package/src/inbox-command.ts

@@ -11,7 +11,7 @@ import type {
 import type { InboxCode } from "@agentswf/contract/wire";
 import type { JsonObject } from "@agentswf/contract/workflow";
 import { maskCredentials } from "@agentswf/harness";
-import { duration } from "./duration";
+import { formatDuration, parseWait } from "./duration";
 import { messageOf } from "./errors";
 import { exists } from "./files";
 import help from "./help/inbox.txt" with { type: "text" };
@@ -100,7 +100,7 @@ export async function inboxCommand(
     const parsed = parsePlace(argv, shellCwd);
     place = parsed.place;
     json = parsed.json;
-    options = parseInbox(parsed.rest);
+    options = parseInbox(parsed.rest, (line) => out.stderr(line));
   } catch (error) {
     out.stderr(`awf: ${messageOf(error)}\n\n${inboxUsage}`);
     return 2;
@@ -198,7 +198,7 @@ export async function inboxCommand(
   }
 }
 
-function parseInbox(rest: readonly string[]): Options {
+function parseInbox(rest: readonly string[], deprecated: (line: string) => void): Options {
   const options: Options = { all: false, open: false, waitSeconds: 0 };
   for (let index = 0; index < rest.length; index += 1) {
     const arg = rest[index]!;
@@ -212,12 +212,9 @@ function parseInbox(rest: readonly string[]): Options {
     else if (arg === "--workflow") options.workflow = value();
     else if (arg === "--as") options.as = value();
     else if (arg === "--after") options.after = value();
-    else if (arg === "--wait") {
-      const seconds = Number(value());
-      if (!Number.isFinite(seconds) || seconds < 0 || seconds > MAX_WAIT_SECONDS)
-        throw new Error(`--wait needs seconds from 0 to ${MAX_WAIT_SECONDS}`);
-      options.waitSeconds = seconds;
-    } else if (arg.startsWith("-")) throw new Error(`unknown option: ${arg}`);
+    else if (arg === "--wait")
+      options.waitSeconds = parseWait(value(), MAX_WAIT_SECONDS, deprecated);
+    else if (arg.startsWith("-")) throw new Error(`unknown option: ${arg}`);
     else if (options.ref === undefined) options.ref = arg;
     else throw new Error(`one run at a time: ${options.ref} and ${arg}`);
   }
@@ -658,7 +655,7 @@ function textOf(item: InboxItemJson, all: boolean): string {
             ? `${item.agent} → ${item.participant}`
             : `${item.participant} → ${item.agent}`;
       return item.state === "opened"
-        ? `${head}route ${arrow} opened  “${item.purpose}”${item.timeoutMs === undefined ? "" : `  ${duration(item.timeoutMs)}`}`
+        ? `${head}route ${arrow} opened  “${item.purpose}”${item.timeoutMs === undefined ? "" : `  ${formatDuration(item.timeoutMs)}`}`
         : `${head}route ${arrow} closed  ${item.reason}`;
     }
     case "message": {

package/src/init-template/hello/workflow.test.ts.template

@@ -1,9 +1,9 @@
 import { expect, test } from "bun:test";
-import { answer, reply, testWorkflow } from "agentswf/testing";
+import { answer, noAnswer, testWorkflow } from "agentswf/testing";
 import hello, { ANSWER } from "./workflow";
 
 test("returns the agent's answer", async () => {
-  const run = await testWorkflow(hello, null, {
+  const run = await testWorkflow(hello, {
     agents: { hello: answer(ANSWER, { answer: 391 }) },
   });
   expect(run.value).toEqual({ answer: 391 });
@@ -11,7 +11,7 @@ test("returns the agent's answer", async () => {
 });
 
 test("an agent that never answers is nudged once, then the result says why", async () => {
-  const run = await testWorkflow(hello, null, { agents: { hello: reply.silent() } });
+  const run = await testWorkflow(hello, { agents: { hello: noAnswer.silent() } });
   expect(run.value).toHaveProperty("unanswered");
   expect(run.turnsOf("hello").map((turn) => turn.nudge)).toEqual([false, true]);
 });

package/src/init-template/hello/workflow.ts.template

@@ -7,7 +7,7 @@ export default defineWorkflow({
   meta: { name: "hello", description: "Ask one agent a question with a known answer." },
   async run(wf) {
     // A headless agent needs neither Herdr nor a sandbox. Swap in any harness and model your
-    // account has: "claude" in a pane, the default placement, runs on a subscription.
+    // account has: "claude" in its TUI, the default placement, runs on a subscription.
     const agent = await wf.agents.open({
       key: "hello",
       runtime: { harness: "codex", model: "gpt-6-luna", placement: "headless" },
@@ -15,7 +15,7 @@ export default defineWorkflow({
     const { outcome } = await agent.run<Type.Static<typeof ANSWER>>({
       prompt: "What is 17 multiplied by 23? Work it out yourself; do not run any code.",
       schema: ANSWER,
-      timeoutMs: 3 * 60_000,
+      timeout: "3m",
     });
     return outcome.answered ? outcome.value : { unanswered: outcome.reason };
   },

package/src/keep-alive.ts

@@ -1,7 +1,11 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-import type { EventAgentOpenSpec } from "@agentswf/contract/workflow";
+import { type AgentOpenSpec, positiveDurationMilliseconds } from "@agentswf/contract/workflow";
 
-export type KeepAlive = NonNullable<EventAgentOpenSpec["keepAlive"]>;
+/** `keepAlive` as the engine keeps it: its window in milliseconds. */
+export type KeepAlive = {
+  windowMs?: number;
+  onTimeout?: NonNullable<AgentOpenSpec["keepAlive"]>["onTimeout"];
+};
 
 /** Claude's prompt cache lives an hour for the main conversation on a subscription. */
 export const DEFAULT_WINDOW_MS = 60 * 60_000;
@@ -20,21 +24,32 @@ export function asTimeoutHandler<T>(fn: () => T): T {
   return inHandler.run(true, fn);
 }
 
-/** `keepAlive` as an open gave it, checked: what a typed caller can't get wrong, a plain one can. */
-export function checkedKeepAlive(key: string, given: unknown): KeepAlive {
+/**
+ * `keepAlive` as an open gave it, checked: what a typed caller can't get wrong, a plain one can.
+ * Its deprecated `timeoutMs` is reported, and refused beside `window`.
+ */
+export function checkedKeepAlive(key: string, given: unknown, deprecated: () => void): KeepAlive {
   if (typeof given !== "object" || given === null)
-    throw new Error(`agent ${key}: keepAlive is { timeoutMs?, onTimeout? }`);
-  const { timeoutMs, onTimeout } = given as Record<string, unknown>;
-  if (
-    timeoutMs !== undefined &&
-    (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs <= 0)
-  )
-    throw new Error(`agent ${key}: keepAlive's timeoutMs is a positive number of milliseconds`);
+    throw new Error(`agent ${key}: keepAlive is { window?, onTimeout? }`);
+  const { window, timeoutMs, onTimeout } = given as Record<string, unknown>;
+  let windowMs: number | undefined;
+  if (window != null) {
+    if (timeoutMs != null)
+      throw new Error(
+        `agent ${key}: keepAlive's window is given alone: timeoutMs is its deprecated form`,
+      );
+    windowMs = positiveDurationMilliseconds(window, `agent ${key}: keepAlive's window`);
+  } else if (timeoutMs != null) {
+    if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs <= 0)
+      throw new Error(`agent ${key}: keepAlive's timeoutMs is a positive number of milliseconds`);
+    deprecated();
+    windowMs = timeoutMs;
+  }
   if (onTimeout !== undefined && typeof onTimeout !== "function")
     throw new Error(`agent ${key}: keepAlive's onTimeout is a function`);
   // A copy: a later change to the caller's object would skip this check.
   return {
-    ...(timeoutMs === undefined ? {} : { timeoutMs }),
+    ...(windowMs === undefined ? {} : { windowMs }),
     ...(onTimeout === undefined ? {} : { onTimeout: onTimeout as KeepAlive["onTimeout"] }),
-  } as KeepAlive;
+  };
 }

package/src/logs-command.ts

@@ -1,7 +1,7 @@
 import { homedir } from "node:os";
 import type { LogEventJson, LogsJson, RouteEnds, RunLogLine } from "@agentswf/contract/records";
 import type { JsonObject } from "@agentswf/contract/workflow";
-import { duration } from "./duration";
+import { formatDuration, parseWait } from "./duration";
 import { messageOf } from "./errors";
 import help from "./help/logs.txt" with { type: "text" };
 import {
@@ -85,7 +85,7 @@ export async function logsCommand(
     const parsed = parsePlace(argv, shellCwd);
     place = parsed.place;
     json = parsed.json;
-    options = parseLogs(parsed.rest);
+    options = parseLogs(parsed.rest, (line) => out.stderr(line));
     if (options.follow && json) throw new Error("--follow is for reading; --json takes --wait");
   } catch (error) {
     out.stderr(`awf: ${messageOf(error)}\n\n${logsUsage}`);
@@ -122,7 +122,7 @@ export async function logsCommand(
   }
 }
 
-function parseLogs(rest: readonly string[]): LogsOptions {
+function parseLogs(rest: readonly string[], deprecated: (line: string) => void): LogsOptions {
   const options: LogsOptions = {
     limit: DEFAULT_LIMIT,
     waitSeconds: 0,
@@ -147,11 +147,7 @@ function parseLogs(rest: readonly string[]): LogsOptions {
         throw new Error("--limit needs a whole number");
       options.limit = limit;
     } else if (arg === "--wait") {
-      const seconds = Number(value());
-      if (!Number.isFinite(seconds) || seconds < 0 || seconds > MAX_WAIT_SECONDS) {
-        throw new Error(`--wait needs seconds from 0 to ${MAX_WAIT_SECONDS}`);
-      }
-      options.waitSeconds = seconds;
+      options.waitSeconds = parseWait(value(), MAX_WAIT_SECONDS, deprecated);
       waitGiven = true;
     } else if (arg === "--follow") options.follow = true;
     else if (arg === "--full") options.full = true;
@@ -511,7 +507,7 @@ function trailer(
     return `run interrupted${go ? ` · continue: ${go}` : ""}`;
   }
   const { ended, started } = span(status, Date.now());
-  const took = ended === undefined ? "" : ` in ${duration(ended - started)}`;
+  const took = ended === undefined ? "" : ` in ${formatDuration(ended - started)}`;
   return `run ended: ${status.state}${took} · result: ${shellLine(command(place, "awf", "runs", status.ref))}`;
 }
 
@@ -569,7 +565,7 @@ function describeLine(line: RunLogLine, places: Places): string {
     case "compact": {
       const took =
         line.deliveredAt && line.settledAt
-          ? `  ${duration(Date.parse(line.settledAt) - Date.parse(line.deliveredAt))}`
+          ? `  ${formatDuration(Date.parse(line.settledAt) - Date.parse(line.deliveredAt))}`
           : "";
       return `${operation(line.kind)} ended  ${line.outcome}${took}`;
     }
@@ -591,7 +587,9 @@ function describeLine(line: RunLogLine, places: Places): string {
       return `decision ${line.decision} ${line.outcome}${line.error ? `  ${said(line.error)}` : ""}`;
     case "route-opened":
       return `route ${routeEnds(line)} opened  "${said(line.purpose)}"  ${line.maxMessages} messages${
-        line.timeoutMs === undefined ? "" : `, a question closes after ${duration(line.timeoutMs)}`
+        line.timeoutMs === undefined
+          ? ""
+          : `, a question closes after ${formatDuration(line.timeoutMs)}`
       }`;
     case "route-closed":
       return `route ${routeEnds(line)} closed  ${line.reason}`;
@@ -640,7 +638,9 @@ function describeLine(line: RunLogLine, places: Places): string {
         line.tool,
         places.calls.get(line.call)?.input,
         // Most calls take under a second; a duration says something only past one.
-        line.durationMs < 1000 ? line.outcome : `${line.outcome}  ${duration(line.durationMs)}`,
+        line.durationMs < 1000
+          ? line.outcome
+          : `${line.outcome}  ${formatDuration(line.durationMs)}`,
         answered,
       );
     }

package/src/mailbox.ts

@@ -11,7 +11,6 @@ import {
   AWF_ID_PREFIX,
   type JsonValue,
   type OperationRecord,
-  type ReceiveOptions,
   type TurnOutcome,
   type WorkflowEvent,
 } from "@agentswf/contract/workflow";
@@ -627,12 +626,11 @@ export class RunMailbox {
    * nothing.
    */
   async receive(
-    options: ReceiveOptions | undefined,
+    label: string | undefined,
     stage?: string,
     /** Rejects the wait: the run ended, or the scope it waits in was cancelled. */
     signal?: AbortSignal,
   ): Promise<WorkflowEvent<string, JsonValue>[]> {
-    const { label, take } = checked(options);
     if (stage !== undefined) {
       const batch = await this.batchOf(stage);
       if (batch) return batch;
@@ -645,7 +643,7 @@ export class RunMailbox {
     return this.#wait(
       {
         ...(label === undefined ? {} : { label }),
-        take,
+        take: "all",
         ...(stage === undefined ? {} : { stage }),
       },
       signal,
@@ -972,19 +970,3 @@ async function mailboxSize(runDir: string): Promise<number> {
     () => 0,
   );
 }
-
-/** A wait's options as given, checked: what a typed caller can't get wrong, a plain one can. */
-function checked(options: ReceiveOptions | undefined): {
-  label?: string;
-  take: "all" | "oldest";
-} {
-  if (options !== undefined && (typeof options !== "object" || options === null))
-    throw new Error("receive takes { label?, take? }");
-  const { label, take = "all" } = options ?? {};
-  if (label !== undefined && typeof label !== "string")
-    throw new Error("receive's label is a string");
-  if (take !== "all" && take !== "oldest") throw new Error('receive\'s take is "all" or "oldest"');
-  if ("until" in (options ?? {}))
-    throw new Error("receive has no until: a timer, wf.timer(name, when), wakes it");
-  return { ...(label === undefined ? {} : { label }), take };
-}

package/src/messaging/limits.ts

@@ -12,14 +12,14 @@ export const MESSAGE_LIMITS: MessageLimits = {
 
 /**
  * Where an asker may wait for an answer, by harness and placement: on where M2 passed
- * (`docs/findings/messaging-m2.md`), off elsewhere. A pane that is `confirmed` waits only where it
+ * (`docs/findings/messaging-m2.md`), off elsewhere. A TUI that is `confirmed` waits only where it
  * confirms what it was sent, as `wfa waiting` needs. The fake harness always may. cursor is off:
  * its turns ran past their deadline in M2.
  */
-export const AWAIT_REPLY: Readonly<Record<string, { headless?: true; pane?: true | "confirmed" }>> =
+export const AWAIT_REPLY: Readonly<Record<string, { headless?: true; tui?: true | "confirmed" }>> =
   {
-    fake: { headless: true, pane: true },
-    claude: { headless: true, pane: "confirmed" },
+    fake: { headless: true, tui: true },
+    claude: { headless: true, tui: "confirmed" },
     codex: { headless: true },
     pi: { headless: true },
   };

package/src/messaging/messaging.ts

@@ -9,7 +9,7 @@ import type {
 import type { ParticipantCode, PeerView, ReplyCode, SendCode } from "@agentswf/contract/wire";
 import type { AgentKey, JsonObject } from "@agentswf/contract/workflow";
 import type { AuthoredMessage } from "@agentswf/harness/adapter";
-import { duration } from "../duration";
+import { formatDuration } from "../duration";
 import { MESSAGE_LIMITS } from "./limits";
 import {
   directions,
@@ -180,7 +180,7 @@ type Obligation = {
   /** It has a `--timeout` of its own, which only that fails it at. */
   readonly timed: boolean;
   /**
-   * When it closes unanswered, on an outside participant: the route's `timeoutMs` or the asker's
+   * When it closes unanswered: the route's `timeoutMs` or the asker's
    * shorter `--timeout`, and which of the two.
    */
   readonly closes?: { at: number; by: "route" | "own"; ms: number };
@@ -279,15 +279,13 @@ export class Messaging {
       }
     }
     const timeoutMs = options.timeoutMs;
-    if (timeoutMs !== undefined) {
-      if (typeof timeoutMs !== "number" || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1)
-        throw new Error("a route's timeoutMs is a positive whole number of milliseconds");
-      // Only where an agent can ask an outside participant: nothing else needs it yet.
-      if (!pairs.some(([, to]) => this.#outside.has(to)))
-        throw new Error(
-          "timeoutMs is only for a route an agent asks an outside participant over: between them, or to it",
-        );
-    }
+    if (
+      timeoutMs !== undefined &&
+      (typeof timeoutMs !== "number" || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1)
+    )
+      throw new Error(
+        `a route's timeoutMs is a positive whole number of milliseconds: not ${timeoutMs}`,
+      );
     const open = pairs.map(([from, to]) => this.#open(from, to));
     if (open.some(Boolean)) {
       if (
@@ -361,7 +359,7 @@ export class Messaging {
     });
   }
 
-  /** Writes `text` to a participant routed to the code, without a turn: an inbox item for it. */
+  /** Writes `text` to a participant, without a turn: an inbox item for it. */
   async post(key: AgentKey, text: string): Promise<string> {
     if (this.#closed) throw new Error("the attempt has ended; nothing more is posted");
     if (!this.#outside.has(key)) throw new Error(`${key} is not connected`);
@@ -506,7 +504,7 @@ export class Messaging {
       return holderRefusal("no-route", `the workflow allows no route from ${from} to ${agent}.`);
     if (view.state === "stopped")
       return holderRefusal(
-        "stopped",
+        "peer-stopped",
         `${agent} has stopped${view.reason ? ` (${JSON.stringify(view.reason)})` : ""}.`,
       );
     const route = initiating.find((each) => each.open);
@@ -942,18 +940,20 @@ export class Messaging {
     return { kind: "ok", operation, owed: latest, bytes };
   }
 
-  /** `awaiting`, `unsupported` and `cycle`, checked for any question. */
+  /** `already-awaiting`, `unsupported` and `cycle`, checked for any question. */
   #checkAsk(
     from: AgentKey,
     peer: AgentKey,
     operation: Operation,
     /** The question a reply answers, which counts as answered here. */
     answering?: Obligation,
-  ): { kind: "refused"; code: "awaiting" | "unsupported" | "cycle"; error: string } | undefined {
+  ):
+    | { kind: "refused"; code: "already-awaiting" | "unsupported" | "cycle"; error: string }
+    | undefined {
     const wfa = this.#host.launcher(from);
     if (operation.awaits?.state === "open") {
       return refuse(
-        "awaiting",
+        "already-awaiting",
         `you already await ${operation.awaits.owedBy}. End your turn, or send without --await-reply.`,
       );
     }
@@ -1045,7 +1045,7 @@ export class Messaging {
   #ask(message: Message, operation: Operation, timeoutMs?: number): { until?: number } {
     message.route.count += 1;
     const now = this.#host.now();
-    const routeMs = this.#outside.has(message.to) ? message.route.timeoutMs : undefined;
+    const routeMs = message.route.timeoutMs;
     // The route's limit, or the asker's own when shorter: the shorter wins.
     const limit =
       routeMs !== undefined && (timeoutMs === undefined || routeMs <= timeoutMs)
@@ -1069,7 +1069,7 @@ export class Messaging {
       owedBy: message.to,
       ...(until === undefined ? {} : { until }),
       timed: limitAt < (outside ? Infinity : (operation.deadline ?? Infinity)),
-      ...(limit && outside ? { closes: { ...limit, at: limitAt } } : {}),
+      ...(limit ? { closes: { ...limit, at: limitAt } } : {}),
       state: "open",
     };
     message.asks = obligation;
@@ -1085,7 +1085,7 @@ export class Messaging {
             obligation,
             "timed-out",
             obligation.closes?.by === "route"
-              ? `the question closed unanswered after ${duration(obligation.closes.ms)}`
+              ? `the question closed unanswered after ${formatDuration(obligation.closes.ms)}`
               : `your --timeout passed at ${clock(closesAt, this.#host.now())}`,
           );
         }
@@ -1375,7 +1375,7 @@ export class Messaging {
         return {
           peer,
           can: this.#can(route, agent),
-          state: "outside",
+          kind: "participant",
           queued: 0,
           purpose: route.purpose,
         };
@@ -1388,8 +1388,13 @@ export class Messaging {
       return {
         peer,
         can: this.#can(route, agent),
+        kind: "agent",
         state:
-          view?.state === "stopped" ? "stopped" : awaiting ? "awaiting" : (view?.state ?? "idle"),
+          view?.state === "stopped"
+            ? "stopped"
+            : awaiting
+              ? "awaiting-reply"
+              : (view?.state ?? "idle"),
         ...(awaiting && view?.state !== "stopped" ? { awaits: awaiting } : {}),
         ...(view?.state === "stopped" && view.reason ? { reason: view.reason } : {}),
         queued,

package/src/messaging/routes.ts

@@ -21,7 +21,7 @@ export type Route = {
   readonly asked?: number;
   /** As the workflow gave it, for telling an identical grant from a conflicting one. */
   readonly requested?: number;
-  /** On a route an agent asks an outside participant over: how long a question on it waits. */
+  /** How long a question on the route waits, to an agent or an outside participant. */
   readonly timeoutMs?: number;
   readonly scope: Scope;
   /** Messages counted against it, answers reserved for included. */

package/src/messaging/text.ts

@@ -228,11 +228,13 @@ export function peersTable(
   const rows = peers.map((peer) => [
     peer.peer,
     peer.can,
-    peer.state === "awaiting"
-      ? `awaiting ${peer.awaits === viewer ? "you" : peer.awaits}`
-      : peer.state === "stopped" && peer.reason
-        ? `stopped (${peer.reason})`
-        : peer.state,
+    peer.kind === "participant"
+      ? "participant"
+      : peer.state === "awaiting-reply"
+        ? `awaiting-reply from ${peer.awaits === viewer ? "you" : peer.awaits}`
+        : peer.state === "stopped" && peer.reason
+          ? `stopped (${peer.reason})`
+          : peer.state,
     peer.queued > 0 ? String(peer.queued) : "",
     quoted(peer.purpose),
   ]);