@agentswf/engine 0.1.0-beta.4 → 0.1.0

package/src/herdr-workspace-marks.ts

@@ -1,10 +1,11 @@
 import { randomBytes } from "node:crypto";
-import { mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { mkdir, readdir, readFile, rm } from "node:fs/promises";
 import { join } from "node:path";
+import { isCode, writeJson } from "./files";
 import { machinePaths } from "./machine";
 import { type ProcessProbe, processStart, sameProcess } from "./runs";
 
-export const WORKSPACE_MARK_VERSION = 2;
+const WORKSPACE_MARK_VERSION = 2;
 
 /**
  * A run's claim on its workspace in a shared Herdr session: the run's process, and when that
@@ -73,7 +74,7 @@ export async function markWorkspace(
   };
   try {
     await mkdir(dir, { recursive: true });
-    await writeWhole(file, mark);
+    await writeJson(file, mark);
   } catch {
     return unmarked;
   }
@@ -85,7 +86,7 @@ export async function markWorkspace(
   const write = (next: WorkspaceMark) => {
     if (released) return writing;
     current = next;
-    writing = writing.then(() => writeWhole(file, current).catch(() => undefined));
+    writing = writing.then(() => writeJson(file, current).catch(() => undefined));
     return writing;
   };
   return {
@@ -110,17 +111,6 @@ export async function markWorkspace(
   };
 }
 
-/** Renamed into place, so a reader never sees half a mark and skips a live run. */
-async function writeWhole(file: string, mark: WorkspaceMark): Promise<void> {
-  const temporary = `${file}.${randomBytes(4).toString("hex")}.tmp`;
-  try {
-    await writeFile(temporary, JSON.stringify(mark));
-    await rename(temporary, file);
-  } finally {
-    await rm(temporary, { force: true }).catch(() => undefined);
-  }
-}
-
 export async function readMarks(
   home: string,
   session: string,
@@ -163,7 +153,7 @@ export async function readAllMarks(
 
 /** Rewrites a mark read from `file`, as one sweep leaves it. */
 export function rewriteMark(file: string, mark: WorkspaceMark): Promise<void> {
-  return writeWhole(file, mark).catch(() => undefined);
+  return writeJson(file, mark).catch(() => undefined);
 }
 
 export function removeMark(file: string): Promise<void> {
@@ -189,6 +179,6 @@ function processExists(pid: number): boolean {
     process.kill(pid, 0);
     return true;
   } catch (error) {
-    return (error as NodeJS.ErrnoException).code !== "ESRCH";
+    return !isCode(error, "ESRCH");
   }
 }

package/src/holder-command.ts

@@ -1,55 +1,50 @@
-import { homedir } from "node:os";
-import type { ParticipantResultJson } from "@agentswf/contract/records";
-import { type ParticipantCode, WIRE_VERSION } from "@agentswf/contract/wire";
+import type { ParticipantResultJson, RefusalCode } from "@agentswf/contract/records";
+import { type HolderWireAnswer, type ParticipantCode, WIRE_VERSION } from "@agentswf/contract/wire";
+import { type Out, parsePlace, type ReadPlace } from "./command-line";
 import { liveCoordinatorSocket } from "./coordinator-socket";
-import { deliver, eventIdProblem } from "./emit";
-import { printEmit } from "./emit-command";
 import { messageOf } from "./errors";
 import { isCode } from "./files";
 import help from "./help/reply.txt" with { type: "text" };
 import { ItemFold } from "./inbox-command";
 import { coordinatorDir } from "./machine";
-import { failed, type Out, parsePlace, type ReadPlace } from "./run-commands";
+import { asksJson, printRefusal, refusalLine } from "./refusals";
+import { failed } from "./run-commands";
 import { findRunByRef, RunNotFound, type RunStatus } from "./run-state";
-import { readAttempts, readEvents, readNumberedEvents } from "./runs";
+import { RunUnreachable } from "./run-unreachable";
+import { readAttempts, readNumberedEvents } from "./runs";
 import { exchange } from "./socket-exchange";
 
+/** `awf reply --json`'s and `awf send --json`'s `"v"`, which their refusals carry too. */
+export const HOLDER_V = 3 satisfies ParticipantResultJson["v"];
+
 export const replyUsage = help.trimEnd();
 
 type Options = {
   command: "reply" | "send";
   ref: string;
-  author?: string;
   to?: string;
   text?: string;
-} & (
-  | { agent: string; as?: string; id?: undefined }
-  /**
-   * `--event-id`: the message's own id, which a participant routed to the code takes as its event's. It
-   * goes to no agent.
-   */
-  | { id: string; as: string; agent?: undefined }
-);
+  agent: string;
+  as?: string;
+};
 
-export type HolderIo = Out & {
+type HolderIo = Out & {
   /** Stdin, when no text is given as an argument. */
   stdin(): Promise<string>;
   /** Then there is nothing piped in to read: refused rather than waited on. */
   stdinIsTerminal?: boolean;
-  environment?: Readonly<Record<string, string | undefined>>;
-  home?: string;
+  environment: Readonly<Record<string, string | undefined>>;
+  home: string;
 };
 
+/** A refusal of `reply` or `send`: its document with `--json`, its sentence on stderr, exit 1. */
+type Refuse = (code: ParticipantCode | RefusalCode, error: string, choices?: string[]) => number;
+
 export async function holderCommand(
   argv: readonly string[],
   shellCwd: string,
   io: HolderIo,
 ): Promise<number> {
-  // Help only as the first word after the command: a message's text may say anything.
-  if (argv[1] === "-h" || argv[1] === "--help") {
-    io.stdout(replyUsage);
-    return 0;
-  }
   let place: ReadPlace;
   let json: boolean;
   let options: Options;
@@ -59,34 +54,34 @@ export async function holderCommand(
     json = parsed.json;
     options = parseHolder(argv[0] as "reply" | "send", parsed.rest);
   } catch (error) {
-    io.stderr(`awf: ${messageOf(error)}\n\n${replyUsage}`);
+    printRefusal(io, { json: asksJson(argv), v: HOLDER_V }, error, "usage", replyUsage);
     return 2;
   }
-  const say = (result: ParticipantResultJson, line: string): number => {
-    if (json) io.stdout(JSON.stringify(result));
-    else if (result.code === "delivered") io.stdout(line);
-    else
-      io.stderr(
-        `awf: ${options.command} refused (${result.code}): ${result.error}${result.choices ? ` Choose: ${result.choices.join(", ")}` : ""}`,
-      );
-    return result.code === "delivered" ? 0 : 1;
+  const delivered = (id: string, line: string): number => {
+    io.stdout(json ? JSON.stringify({ v: HOLDER_V, id } satisfies ParticipantResultJson) : line);
+    return 0;
+  };
+  const refused: Refuse = (code, error, choices) => {
+    if (json) io.stdout(refusalLine(HOLDER_V, code, error, choices));
+    io.stderr(
+      `awf: ${options.command} refused (${code}): ${error}${choices ? ` Choose: ${choices.join(", ")}` : ""}`,
+    );
+    return 1;
   };
-  const refused = (code: ParticipantCode, error: string) => say({ v: 1, code, error }, "");
   const usage = (problem: string) => {
-    io.stderr(`awf: ${problem}\n\n${replyUsage}`);
+    printRefusal(io, { json, v: HOLDER_V }, problem, "usage", replyUsage);
     return 2;
   };
   if (options.text !== undefined && options.text.trim() === "")
     return usage("nothing to say: the text is blank");
   if (options.text === undefined && io.stdinIsTerminal)
     return usage("nothing to say: give the text as an argument, or pipe it in");
-  if (options.id !== undefined) return toTheCode(options, place, json, io, { refused, usage });
   try {
     let status: RunStatus;
     try {
-      status = await findRunByRef(options.ref, place, io.home ?? homedir());
+      status = await findRunByRef(options.ref, place, io.home);
     } catch (error) {
-      if (error instanceof RunNotFound) return refused("not-found", error.message);
+      if (error instanceof RunNotFound) return refused(error.code, error.message);
       throw error;
     }
     if (status.state !== "running")
@@ -99,7 +94,7 @@ export async function holderCommand(
         "no-participant",
         `${status.ref} has no participant${options.as ? ` ${options.as}` : ""} to reach yet; try again once it connects one`,
       );
-    const dir = coordinatorDir(io.home ?? homedir(), io.environment ?? process.env);
+    const dir = coordinatorDir(io.home, io.environment);
     // Live with no socket: its attempt has not connected one yet, or is opening it.
     const socket = await liveCoordinatorSocket(dir, status);
     if (!socket) return unreachable();
@@ -118,23 +113,25 @@ export async function holderCommand(
       // A socket an attempt left when it was killed: this attempt has not opened its own yet.
       if (["ECONNREFUSED", "ENOENT", "ENOTSOCK"].some((code) => isCode(error, code)))
         return unreachable();
-      throw error;
+      // Open and silent, or gone mid-answer: the run doesn't answer.
+      throw new RunUnreachable(`${status.ref} did not answer: ${messageOf(error)}`);
     }
     if (!answer)
-      throw new Error(
-        `${status.ref} did not answer the request; it may run another version of awf`,
+      throw new RunUnreachable(
+        `${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, "");
-    if (options.command === "reply") return say(result, `answered ${result.id}`);
+    const result = JSON.parse(answer) as HolderWireAnswer;
+    if (result.code !== "delivered") return refused(result.code, result.error, result.choices);
+    if (options.command === "reply") return delivered(result.id, `answered ${result.id}`);
     // Held for an agent awaiting this participant's answer: it comes with that answer.
-    const awaited = await awaitedBy(status, options.agent, options.as);
-    return say(
-      result,
+    // Only the line's wording: the message is delivered, whatever reading this finds.
+    const awaited = await awaitedBy(status, options.agent, options.as).catch(() => undefined);
+    return delivered(
+      result.id,
       `delivered as ${result.id}${awaited ? `; ${options.agent} still awaits the reply to ${awaited}` : ""}`,
     );
   } catch (error) {
-    return failed(error, place, io, messageOf(error));
+    return failed(error, place, io, messageOf(error), { json, v: HOLDER_V });
   }
 }
 
@@ -142,8 +139,6 @@ function parseHolder(command: "reply" | "send", rest: readonly string[]): Option
   const words: string[] = [];
   let to: string | undefined;
   let as: string | undefined;
-  let id: string | undefined;
-  let author: string | undefined;
   for (let index = 0; index < rest.length; index += 1) {
     const arg = rest[index]!;
     const value = () => {
@@ -154,44 +149,30 @@ function parseHolder(command: "reply" | "send", rest: readonly string[]): Option
     };
     if (arg === "--to" && command === "reply") to = value();
     else if (arg === "--as") as = value();
-    else if (arg === "--event-id" && command === "send") id = value();
-    else if (arg === "--author" && command === "send") author = value();
+    else if ((arg === "--event-id" || arg === "--author") && command === "send")
+      throw new Error(
+        `send ${arg} was removed: a message on a participant to the run's code is awf emit {run} {participant}:reply '{"text":…,"author":…}' --event-id {id}, with {participant}:reply declared in the workflow's events`,
+      );
     else if (arg === "--") {
       words.push(...rest.slice(index + 1));
       break;
     } else if (arg.startsWith("--")) throw new Error(`unknown option: ${arg}`);
     else words.push(arg);
   }
-  // With --event-id, the participant's reply goes to the run's code: there is no agent to name.
-  let target: { agent: string; as?: string } | { id: string; as: string };
-  let ref: string | undefined;
-  let text: string | undefined;
-  let extra: string[];
-  if (id !== undefined) {
-    [ref, text, ...extra] = words;
-    if (!ref) throw new Error("send needs a run, <workflow>/<id> or <id>");
-    if (!as) throw new Error("--event-id sends as a participant routed to the code: --as names it");
-    const problem = eventIdProblem(id);
-    if (problem) throw new Error(`--event-id ${id}: ${problem}`);
-    target = { id, as };
-  } else {
-    let agent: string | undefined;
-    [ref, agent, text, ...extra] = words;
-    if (author !== undefined) throw new Error("--author goes with --event-id");
-    if (!ref || !agent)
-      throw new Error(`${command} needs a run, <workflow>/<id> or <id>, and an agent`);
-    target = { agent, ...(as === undefined ? {} : { as }) };
-  }
+  const [ref, agent, text, ...extra] = words;
+  if (!ref || !agent?.trim())
+    throw new Error(`${command} needs a run, <workflow>/<id> or <id>, and an agent`);
   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 {
     command,
     ref,
-    ...target,
+    agent,
+    ...(as === undefined ? {} : { as }),
     ...(to === undefined ? {} : { to }),
     ...(text === undefined ? {} : { text }),
-    ...(author === undefined ? {} : { author }),
   };
 }
 
@@ -219,61 +200,3 @@ async function awaitedBy(
   );
   return open.at(-1);
 }
-
-/**
- * `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).
- */
-async function toTheCode(
-  options: Extract<Options, { id: string }>,
-  place: ReadPlace,
-  json: boolean,
-  io: HolderIo,
-  say: { refused(code: ParticipantCode, error: string): number; usage(problem: string): number },
-): Promise<number> {
-  const home = io.home ?? homedir();
-  const environment = io.environment ?? process.env;
-  const { id, as } = options;
-  const { refused } = say;
-  let found: RunStatus;
-  try {
-    found = await findRunByRef(options.ref, place, home);
-  } catch (error) {
-    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",
-  );
-  if (!run.record.events || !routed)
-    return refused(
-      "no-participant",
-      `${found.ref} has no participant ${as} routed 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");
-  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);
-  } catch (error) {
-    return failed(error, place, io, messageOf(error));
-  }
-}

package/src/in-lines.ts

@@ -0,0 +1,28 @@
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+import type { EventLine } from "@agentswf/contract/records";
+import { appendLine, endTornLine, readLines } from "./jsonl";
+
+/** `in.jsonl`: the events senders gave the run, appended under the run's lock. */
+export function inFile(runDir: string): string {
+  return join(runDir, "in.jsonl");
+}
+
+/** The run's events in the order written, less a line a crash tore. */
+export async function readIn(runDir: string): Promise<EventLine[]> {
+  return readLines<EventLine>(inFile(runDir));
+}
+
+/** Appends an event; the caller holds the run's lock. */
+export async function appendIn(runDir: string, line: EventLine): Promise<void> {
+  await endTornLine(inFile(runDir));
+  await appendLine(inFile(runDir), JSON.stringify(line));
+}
+
+/** `in.jsonl`'s size, which a waiting run polls: a sender's append changes it. */
+export async function inSize(runDir: string): Promise<number> {
+  return stat(inFile(runDir)).then(
+    (stats) => stats.size,
+    () => 0,
+  );
+}

package/src/inbox-command.ts

@@ -2,30 +2,27 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import type {
   AttemptRecord,
-  InboxErrorJson,
   InboxExpiry,
   InboxItemJson,
+  RefusalCode,
   RequestEnd,
   RunLogLine,
 } from "@agentswf/contract/records";
 import type { InboxCode } from "@agentswf/contract/wire";
 import type { JsonObject } from "@agentswf/contract/workflow";
 import { maskCredentials } from "@agentswf/harness";
-import { duration } from "./duration";
+import { duration } from "./accounting/format";
+import { command, type Out, parsePlace, type ReadPlace, shellLine } from "./command-line";
+import { parseWait } from "./duration";
 import { messageOf } from "./errors";
 import { exists } from "./files";
 import help from "./help/inbox.txt" with { type: "text" };
-import { readMailbox } from "./mailbox";
-import {
-  clockTime,
-  command,
-  failed,
-  type Out,
-  parsePlace,
-  type ReadPlace,
-  shellLine,
-} from "./run-commands";
+import { asksJson, printRefusal } from "./refusals";
+import { failed, MAX_WAIT_SECONDS, POLL_MS } from "./run-commands";
+import { readRunLines } from "./run-lines";
+import { waitLabels as labelsOf } from "./run-policy/waits";
 import { findRunByRef, listRuns, RunNotFound, statusOf } from "./run-state";
+import { clockTime } from "./run-text";
 import {
   attemptsToken,
   type LogMark,
@@ -35,10 +32,10 @@ import {
   readEventsFrom,
 } from "./runs";
 
-export const inboxUsage = help.trimEnd();
+/** `awf inbox --json`'s `"v"`, which its refusals carry too. */
+export const INBOX_V = 2 satisfies InboxItemJson["v"];
 
-const MAX_WAIT_SECONDS = 300;
-const POLL_MS = 1_000;
+export const inboxUsage = help.trimEnd();
 
 /** The clock and the pause between polls, which tests drive. */
 export type InboxClock = { now(): number; sleep(ms: number): Promise<void> };
@@ -66,7 +63,7 @@ type CursorState = { f: string; r: Record<string, Position> };
 
 class Refused extends Error {
   constructor(
-    readonly code: InboxCode,
+    readonly code: InboxCode | RefusalCode,
     message: string,
   ) {
     super(message);
@@ -89,10 +86,6 @@ export async function inboxCommand(
     signal?: AbortSignal;
   } = {},
 ): Promise<number> {
-  if (argv.includes("-h") || argv.includes("--help")) {
-    out.stdout(inboxUsage);
-    return 0;
-  }
   let place: ReadPlace;
   let json: boolean;
   let options: Options;
@@ -102,12 +95,11 @@ export async function inboxCommand(
     json = parsed.json;
     options = parseInbox(parsed.rest);
   } catch (error) {
-    out.stderr(`awf: ${messageOf(error)}\n\n${inboxUsage}`);
+    printRefusal(out, { json: asksJson(argv), v: INBOX_V }, error, "usage", inboxUsage);
     return 2;
   }
-  const refuse = (code: InboxCode, message: string) => {
-    if (json) out.stdout(JSON.stringify({ v: 1, code, error: message } satisfies InboxErrorJson));
-    else out.stderr(`awf: ${message}`);
+  const refuse = (code: InboxCode | RefusalCode, message: string) => {
+    printRefusal(out, { json, v: INBOX_V }, message, code);
     return 1;
   };
   try {
@@ -115,18 +107,19 @@ export async function inboxCommand(
       ? `all|${options.workflow ?? ""}|${options.as ?? ""}`
       : `run|${options.ref}|${options.as ?? ""}`;
     let state: CursorState = { f: filter, r: {} };
-    // Reading every run here, none is missing or unconnected, so a cursor is checked first, sparing a read.
     let checked = options.after === undefined;
-    if (!checked && options.all) {
+    const takeCursor = () => {
       const given = decodeCursor(options.after!);
       if (!given || given.f !== filter)
         throw new Refused(
-          "bad-cursor",
+          "cursor",
           `cursor ${options.after} was made with another run or filter; read again without --after`,
         );
       state = given;
       checked = true;
-    }
+    };
+    // Reading every run here, none is missing or unconnected, so a cursor is checked first, sparing a read.
+    if (!checked && options.all) takeCursor();
     const deadline = clock.now() + options.waitSeconds * 1000;
     // An event run lives in its project, found through ~/.awf/projects from anywhere (Q15).
     const found =
@@ -137,14 +130,7 @@ export async function inboxCommand(
       const runs = await readInbox(options, state, watch, one);
       // After a run that is not there, or never connected one: those come first.
       if (!checked) {
-        const given = decodeCursor(options.after!);
-        if (!given || given.f !== filter)
-          throw new Refused(
-            "bad-cursor",
-            `cursor ${options.after} was made with another run or filter; read again without --after`,
-          );
-        state = given;
-        checked = true;
+        takeCursor();
         continue;
       }
       if (options.open) {
@@ -165,7 +151,7 @@ export async function inboxCommand(
           state = { f: filter, r: { ...state.r, [ref]: item.position } };
           const { position: _position, ...shown } = item;
           const published = {
-            v: 1,
+            v: 2,
             ref,
             ...shown,
             cursor: encodeCursor(state),
@@ -178,13 +164,12 @@ export async function inboxCommand(
           const words = options.all
             ? ["awf", "inbox", ...(options.workflow ? ["--workflow", options.workflow] : [])]
             : ["awf", "inbox", options.ref!];
-          const again = command(
-            place,
-            ...words,
+          const again = [
+            ...command(place, ...words),
             ...(options.as ? ["--as", options.as] : []),
             "--after",
             encodeCursor(state),
-          );
+          ];
           out.stdout([...lines, `next: ${shellLine(again)}`].join("\n"));
         }
         return 0;
@@ -193,8 +178,8 @@ export async function inboxCommand(
     }
   } catch (error) {
     if (error instanceof Refused) return refuse(error.code, error.message);
-    if (error instanceof RunNotFound) return refuse("not-found", error.message);
-    return failed(error, place, out, messageOf(error));
+    if (error instanceof RunNotFound) return refuse(error.code, error.message);
+    return failed(error, place, out, messageOf(error), { json, v: INBOX_V });
   }
 }
 
@@ -212,12 +197,8 @@ 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);
+    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}`);
   }
@@ -271,7 +252,7 @@ type Watched = {
   /** The attempt files when `attempts` was read; undefined before the first read. */
   token?: string;
   attempts: AttemptRecord[];
-  /** Each attempt's last wait label, from the mailbox, read with `attempts`. */
+  /** Each attempt's last wait label, from `run.jsonl`, read with `attempts`. */
   labels: ReadonlyMap<number, string>;
   fold: ItemFold;
   mark: LogMark;
@@ -631,7 +612,7 @@ function openQuestions(runs: readonly RunItems[]): InboxItemJson[] {
   });
   return merged(open).map(({ ref, item }) => {
     const { position: _position, ...shown } = item;
-    return { v: 1, ref, ...shown } as InboxItemJson;
+    return { v: INBOX_V, ref, ...shown } as InboxItemJson;
   });
 }
 
@@ -705,11 +686,13 @@ function decodeCursor(text: string): CursorState | undefined {
   }
 }
 
-/** Each attempt's last wait label: what a parked attempt is waiting for. */
+/**
+ * Each attempt's last wait label: what a parked attempt is waiting for. A `run.jsonl` that can't be
+ * read gives none: the conversation is the log's.
+ */
 async function waitLabels(runDir: string): Promise<Map<number, string>> {
-  const labels = new Map<number, string>();
-  for (const record of await readMailbox(runDir))
-    if (record.kind === "wait" && record.label !== undefined)
-      labels.set(record.attempt, record.label);
-  return labels;
+  return readRunLines(runDir).then(
+    ({ lines }) => labelsOf(lines),
+    () => new Map(),
+  );
 }

package/src/index.ts

@@ -1,4 +1,4 @@
-// A finished run is re-priced from its `output.json` with another table.
+// A finished run is priced again from its operations' `spend.json`, or `out.json`'s `usage`, with another table.
 export { describeAccounting } from "./accounting/format";
 export { type ModelRate, type PriceTable, PUBLISHED_PRICES } from "./accounting/prices";
 export { summarizeRun } from "./accounting/summary";