@agentswf/engine 0.1.0-beta.5 → 0.1.0

package/src/run-text.ts

@@ -0,0 +1,54 @@
+// How the commands that read runs show what a run wrote, what it cost, and when.
+import { maskCredentials } from "@agentswf/harness";
+import { usd } from "./accounting/format";
+
+/** A field whose name says it holds a credential, whatever its value looks like. */
+const SECRET_NAME =
+  /password|passwd|passphrase|passcode|secret|token|credential|cookie|bearer|authorization|(?:api|access|private|session|ssh|signing|encryption)[_-]?key|^(?:pwd|pass|pin|auth)$/i;
+
+/**
+ * Every string in `value` masked, and everything under a credential's name hidden: a run's text,
+ * errors and fields are its workflow's, its agents' and its tools'. Past `limit`, a string is cut.
+ */
+export function masked(value: unknown, limit = Number.POSITIVE_INFINITY, hidden = false): unknown {
+  if (typeof value === "string") {
+    if (hidden) return "***";
+    const shown = maskCredentials(value);
+    return shown.length > limit ? `${shown.slice(0, limit - 1)}…` : shown;
+  }
+  if (hidden && value !== null && typeof value !== "object") return "***";
+  if (Array.isArray(value)) return value.map((each) => masked(each, limit, hidden));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, each]) => [
+        key,
+        masked(each, limit, hidden || SECRET_NAME.test(key)),
+      ]),
+    );
+  }
+  return value;
+}
+
+/**
+ * Text a run wrote, as one masked line of about `limit` characters, so it can never pass for a
+ * line of its own or fill a page. `@{handle} --full` prints it whole.
+ */
+export function said(text: string, limit = 120): string {
+  const line = maskCredentials(text).replace(/\s*[\r\n]+\s*/g, " ⏎ ");
+  return line.length > limit ? `${line.slice(0, limit - 1)}…` : line;
+}
+
+/**
+ * As `usd` says it, and nothing for none; `?` after it when some cost is unknown, which makes it a
+ * floor.
+ */
+export function money(estimate: number | undefined, unknown = 0): string[] {
+  if (!estimate) return [];
+  return [`${usd(estimate)}${unknown > 0 ? "?" : ""}`];
+}
+
+export function clockTime(at: number | string): string {
+  const date = new Date(at);
+  const two = (n: number) => String(n).padStart(2, "0");
+  return `${two(date.getHours())}:${two(date.getMinutes())}:${two(date.getSeconds())}`;
+}

package/src/run-unreachable.ts

@@ -0,0 +1,18 @@
+/** A run's files that can't be read, or a run that doesn't answer: refused `unreachable`. */
+export class RunUnreachable extends Error {
+  readonly code = "unreachable";
+  constructor(message: string) {
+    super(message);
+    this.name = "RunUnreachable";
+  }
+}
+
+/**
+ * An error the system gave, `ENOENT`, `EACCES` and the like, or one awf wrapped around it as its
+ * cause: a run's file that couldn't be read or written.
+ */
+export function isSystemError(error: unknown): boolean {
+  const { code, cause } = (error ?? {}) as { code?: unknown; cause?: unknown };
+  if (typeof code === "string" && /^E[A-Z]+$/.test(code)) return true;
+  return cause !== undefined && cause !== error && isSystemError(cause);
+}

package/src/run-usage.ts

@@ -19,9 +19,9 @@ import { abortableSleep, deadlineWithin, runUntilStopped, waitForDeadline } from
  */
 const FINISHING_GRACE_MILLISECONDS = 10_000;
 /** Reading spend waits for files a released turn is still writing; it gives up after this. */
-const ACCOUNTING_GRACE_MILLISECONDS = 20_000;
+export const ACCOUNTING_GRACE_MILLISECONDS = 20_000;
 /** Beyond that, the host's bound on a billing status command, and this much more. */
-const STATUS_SLACK_MILLISECONDS = 2_000;
+export const STATUS_SLACK_MILLISECONDS = 2_000;
 
 /** One logical agent, as the run knows it. */
 export type AccountedAgent = {
@@ -45,11 +45,12 @@ export type AccountedAgent = {
 type OperationEntry = {
   /**
    * Records what is known when the operation settles; spend and billing wait for the run's end.
-   * `finishing` is an answered turn the host left finishing, whose charges are added when it ends.
+   * `finishing` is an answered turn the host left finishing, whose reported costs are added when
+   * it ends.
    */
   settle(
     times: { deliveredAt?: number; settledAt: number },
-    charges: readonly number[],
+    reportedCosts: readonly number[],
     finishing?: Promise<HarnessTurnOutcome>,
   ): OperationRecord;
 };
@@ -62,6 +63,8 @@ export type OperationTags = Pick<OperationRecord, "stage" | "label" | "cause">;
 
 /** One agent's part of the run's ledger. */
 export type AgentLedger = {
+  /** Where it runs now: its sandbox's folder once it has one. */
+  cwd(): string;
   /** `execution` is read as the operation settles: the agent's settings it ran at. */
   reserve(
     operationId: string,
@@ -125,21 +128,22 @@ export function createRunLedger({
     agent(agent) {
       agents.push(agent);
       return {
+        cwd: () => agent.cwd,
         reserve(operationId, execution, tags = {}) {
           const operation: Operation = { agent, costs: [] };
           operations.push(operation);
           return {
-            settle(times, charges, finishing) {
+            settle(times, reportedCosts, finishing) {
               operation.usage = {
                 ...recordOf(agent, operationId, execution(), tags, times.deliveredAt),
                 settledAt: new Date(times.settledAt).toISOString(),
               };
-              operation.costs = [...charges];
+              operation.costs = [...reportedCosts];
               if (finishing) {
                 late.add(
                   finishing.then(
-                    ({ chargesUsd }) => {
-                      operation.costs.push(...chargesUsd);
+                    ({ reportedCostsUsd }) => {
+                      operation.costs.push(...reportedCostsUsd);
                     },
                     () => undefined,
                   ),
@@ -175,7 +179,7 @@ export function createRunLedger({
       try {
         return await runUntilStopped(
           async () => {
-            // Closing the host ended every turn left finishing; what each charged lands here.
+            // Closing the host ended every turn left finishing; what each reported lands here.
             await waitForDeadline(lateEnded(), { unixMilliseconds: deadline }).catch(
               () => undefined,
             );
@@ -254,12 +258,14 @@ async function settleUsage(
   return operations.map((operation) => {
     const { billing, shares } = settledAgents.get(operation.agent)!;
     const { costs } = operation;
-    const charged = billing === "metered" && costs.length > 0 ? sum(costs) : undefined;
+    const reportedCost = billing === "metered" && costs.length > 0 ? sum(costs) : undefined;
     return {
       ...withSessions(operation),
       billing,
       ...(shares ? { spend: spendOf(shares.get(operation.usage.operationId) ?? []) } : {}),
-      ...(charged === undefined ? {} : { charged: { amount: charged, currency: "USD" } }),
+      ...(reportedCost === undefined
+        ? {}
+        : { reportedCost: { amount: reportedCost, currency: "USD" } }),
     };
   });
 }

package/src/run-view.ts

@@ -1,24 +1,30 @@
-import { join } from "node:path";
 import type {
   Activity,
   AgentStateJson,
-  AttemptRecord,
+  ClaimedAttempt,
   OperationLivenessRecord,
   RunLogLine,
   StageStateJson,
 } from "@agentswf/contract/records";
-import type { AgentKey, HarnessKind } from "@agentswf/contract/workflow";
+import type { AgentKey, HarnessKind, JsonValue } from "@agentswf/contract/workflow";
+import { messageOf } from "./errors";
 import { readLines } from "./jsonl";
+import { liveFile } from "./ops";
 import { currentStage, estimateOf } from "./run-commands";
+import { readRunLines } from "./run-lines";
 import { type Cursor, type FileCache, readRun, timeOf } from "./run-read";
 import type { RunStatus } from "./run-state";
 
-/** A stage of the attempt shown: running, reused or given from an earlier one, or how it ended. */
+/**
+ * A stage of the attempt shown: running, reused or given from an earlier one, or how it ended. Its
+ * outcome and value are its own `stage` line's, a reused one's the line it reused.
+ */
 export type StageView = {
   stage: string;
   state: StageStateJson;
   startedAt?: number;
   endedAt?: number;
+  value?: JsonValue;
 };
 
 /**
@@ -43,19 +49,23 @@ export type AgentView = {
   sessions: { harness: HarnessKind; id: string; files: string[] }[];
 };
 
-export type DecisionView = { decision: number; key: string; askedAt: number; outcome?: string };
+type DecisionView = { decision: number; key: string; askedAt: number; outcome?: string };
 
 export type RunView = {
   status: RunStatus;
   /** The attempt shown: the last. */
-  attempt?: AttemptRecord;
+  attempt?: ClaimedAttempt;
   stages: StageView[];
+  /** Why the stages show no values: `run.jsonl` didn't read. */
+  unread?: string;
   /** The stage running now, or the one the attempt ended in. */
   stage?: string;
   agents: AgentView[];
   decisions: DecisionView[];
   /** Over the attempts that kept one, at list prices: never what was billed. */
   estimate?: number;
+  /** How many agent operations' usage isn't known: `estimate` is a floor. */
+  unknownCost: number;
   lastEventAt?: number;
   lines: { number: number; line: RunLogLine }[];
   cursor: Cursor;
@@ -74,7 +84,7 @@ export async function viewRun(status: RunStatus): Promise<RunView> {
     .map(({ line }) => line)
     .filter((line) => attempt === undefined || line.attempt === attempt.attempt);
 
-  const stages: StageView[] = [];
+  const stages: (StageView & { started?: string })[] = [];
   const decisions: DecisionView[] = [];
   const agents = new Map<AgentKey, AgentView>();
   const open = new Map<string, AgentKey>();
@@ -93,13 +103,17 @@ export async function viewRun(status: RunStatus): Promise<RunView> {
     const at = Date.parse(timeOf(line));
     switch (line.kind) {
       case "stage-started":
-        stages.push({ stage: line.stage, state: "running", startedAt: at });
+        stages.push({ stage: line.stage, state: "running", startedAt: at, started: line.at });
         break;
       case "stage-ended": {
-        const started = stages.find((each) => each.stage === line.stage);
+        // An event run enters a failed stage again in the same attempt: the end is the open one's.
+        const started = stages.findLast(
+          (each) => each.stage === line.stage && each.state === "running",
+        );
         const state = line.source ?? line.outcome;
-        if (started) Object.assign(started, { state, endedAt: at });
-        else stages.push({ stage: line.stage, state, startedAt: at, endedAt: at });
+        if (started && line.source === undefined) Object.assign(started, { state, endedAt: at });
+        else
+          stages.push({ stage: line.stage, state, startedAt: at, endedAt: at, started: line.at });
         break;
       }
       case "agent-opened":
@@ -136,6 +150,7 @@ export async function viewRun(status: RunStatus): Promise<RunView> {
       }
     }
   }
+  const unread = await withLines(stages, run.dir, attempt?.attempt);
   const stage = currentStage(status, read.log.lines);
   // A run whose process is gone left what it was doing undone.
   if (status.state === "interrupted") {
@@ -175,28 +190,72 @@ export async function viewRun(status: RunStatus): Promise<RunView> {
       files: (files.get(session.n)?.files ?? []).map((file) => file.path),
     });
   }
-  const estimate = estimateOf(attempts);
+  const { estimate, unknown } = await estimateOf(status);
   const lastLine = read.log.lines.at(-1)?.line;
   return {
     status,
     ...(attempt ? { attempt } : {}),
-    stages,
+    stages: stages.map(({ started: _started, ...each }) => each),
+    ...(unread === undefined ? {} : { unread }),
     ...(stage === undefined ? {} : { stage }),
     agents: [...agents.values()],
     decisions,
     ...(estimate === undefined ? {} : { estimate }),
+    unknownCost: unknown,
     ...(lastLine ? { lastEventAt: Date.parse(timeOf(lastLine)) } : {}),
     lines: read.log.lines,
     cursor: read.cursor,
   };
 }
 
+/**
+ * Each stage's outcome and value from `run.jsonl`. One that ran or was given takes its own line, of
+ * attempt `attempt` with its name and `started`, ties by the order entered; a reused one takes the
+ * line it reused, its stage's settled one. A stage running, or one the plan stopped, has no line,
+ * and keeps what the log says.
+ */
+async function withLines(
+  stages: (StageView & { started?: string })[],
+  runDir: string,
+  attempt: number | undefined,
+): Promise<string | undefined> {
+  let view: Awaited<ReturnType<typeof readRunLines>>["view"];
+  try {
+    ({ view } = await readRunLines(runDir));
+  } catch (error) {
+    // A run whose lines can't be read still shows its story from the log, and says what it lacks.
+    return `run.jsonl could not be read, so stages show no values: ${messageOf(error)}`;
+  }
+  if (attempt === undefined) return undefined;
+  const taken = new Set<unknown>();
+  for (const entry of stages) {
+    const stage = view.stages[entry.stage];
+    if (!stage) continue;
+    if (entry.state === "reused") {
+      // The attempt shown is the latest, and a stage it reused it can't run again: no later
+      // success than the one it reused.
+      if (stage.settled?.value !== undefined) entry.value = stage.settled.value;
+      continue;
+    }
+    const line = stage.history.find(
+      (each) => each.attempt === attempt && each.started === entry.started && !taken.has(each),
+    );
+    if (!line) continue;
+    taken.add(line);
+    if (entry.state !== "provided") entry.state = line.outcome;
+    // The log is best effort: an end it lost is the line's.
+    entry.endedAt ??= Date.parse(line.at);
+    if (line.value !== undefined) entry.value = line.value;
+  }
+  return undefined;
+}
+
 /** The latest phase a call's liveness file holds, which is diagnostics, best effort. */
 async function latestPhase(
   runDir: string,
   operationId: string,
 ): Promise<OperationLivenessRecord | undefined> {
-  const file = join(runDir, "calls", operationId, "liveness.jsonl");
+  const file = liveFile(runDir, operationId);
   return (await readLines<OperationLivenessRecord>(file).catch(() => [])).at(-1);
 }
 

package/src/runs-command.ts

@@ -1,28 +1,21 @@
 import { homedir } from "node:os";
 import type { RunJson, RunsJson } from "@agentswf/contract/records";
-import { formatDuration } from "./duration";
+import type { JsonValue } from "@agentswf/contract/workflow";
+import { duration } from "./accounting/format";
+import { command, type Out, parsePlace, type ReadPlace, shellLine } from "./command-line";
 import { messageOf } from "./errors";
 import help from "./help/runs.txt" with { type: "text" };
-import {
-  clockTime,
-  command,
-  continueOf,
-  estimateOf,
-  failed,
-  masked,
-  money,
-  nextLogs,
-  type Out,
-  parsePlace,
-  type ReadPlace,
-  said,
-  shellLine,
-  span,
-  stateWord,
-} from "./run-commands";
+import { asksJson, printRefusal } from "./refusals";
+import { continueOf, estimateOf, failed, nextLogs, span, stateWord } from "./run-commands";
 import { encodeCursor } from "./run-read";
-import { findRunByRef, listRuns, type RunStatus, runStatus } from "./run-state";
+import { findRunByRef, listRunEntries, type RunStatus, runStatus } from "./run-state";
+import { clockTime, masked, money, said } from "./run-text";
 import { type AgentView, describeActivity, type RunView, viewRun } from "./run-view";
+import { isClaimed, RunUnreadable } from "./runs";
+
+/** `awf runs --json`'s `"v"`, the list's, and `awf runs {run} --json`'s. */
+export const RUNS_V = 1 satisfies RunsJson["v"];
+export const RUNS_ONE_V = 2 satisfies RunJson["v"];
 
 export const runsUsage = help.trimEnd();
 
@@ -35,10 +28,6 @@ export async function runsCommand(
   now: number = Date.now(),
   home: string = homedir(),
 ): Promise<number> {
-  if (argv.includes("-h") || argv.includes("--help")) {
-    out.stdout(runsUsage);
-    return 0;
-  }
   let parsed: ReturnType<typeof parsePlace>;
   let limit: number | undefined;
   let ref: string | undefined;
@@ -57,7 +46,7 @@ export async function runsCommand(
     if (ref !== undefined && limit !== undefined)
       throw new Error("--limit lists runs; it takes no run");
   } catch (error) {
-    out.stderr(`awf: ${messageOf(error)}\n\n${runsUsage}`);
+    printRefusal(out, { json: asksJson(argv), v: runsVersion(argv) }, error, "usage", runsUsage);
     return 2;
   }
   const { place, json } = parsed;
@@ -69,34 +58,52 @@ export async function runsCommand(
     );
     return 0;
   } catch (error) {
-    return failed(error, place, out, messageOf(error));
+    return failed(error, place, out, messageOf(error), { json, v: runsVersion(argv) });
   }
 }
 
+/**
+ * `awf runs {run} --json`'s `"v"` is 2, the list's 1: by whether a word names a run, read before
+ * any parse, so a usage error after it or before it carries the same.
+ */
+function runsVersion(argv: readonly string[]): typeof RUNS_V | typeof RUNS_ONE_V {
+  for (let index = 0; index < argv.length; index++) {
+    const word = argv[index]!;
+    if (word === "--cwd" || word === "--run-root" || word === "--limit") index++;
+    else if (!word.startsWith("-")) return RUNS_ONE_V;
+  }
+  return RUNS_V;
+}
+
 /** A run listed, or why it could not be read: one bad run does not hide the others. */
-type Listed = { status: RunStatus } | { ref: string; unreadable: string };
+type Listed =
+  | { status: RunStatus; estimate?: number; unknown: number }
+  | { ref: string; unreadable: string };
 
 async function list(place: ReadPlace, limit: number, json: boolean, out: Out, now: number) {
-  const runs = await listRuns(place.runRoot);
+  const runs = await listRunEntries(place.runRoot);
   const shown = runs.slice(0, limit);
   const listed: Listed[] = await Promise.all(
     shown.map((run) =>
-      runStatus(run, undefined, now).then(
-        (status) => ({ status }),
-        (error: unknown) => ({
-          ref: `${run.record.workflow}/${run.record.id}`,
-          unreadable: said(messageOf(error), 400),
-        }),
-      ),
+      run instanceof RunUnreadable
+        ? { ref: run.ref, unreadable: run.why }
+        : runStatus(run, undefined, now).then(
+            async (status) => {
+              return { status, ...(await estimateOf(status)) };
+            },
+            (error: unknown) => ({
+              ref: `${run.record.workflow}/${run.record.id}`,
+              unreadable: said(messageOf(error), 400),
+            }),
+          ),
     ),
   );
   const older = runs.length - shown.length;
   if (json) {
     const runsJson: RunsJson["runs"] = listed.map((each) => {
       if (!("status" in each)) return each;
-      const { status } = each;
+      const { status, estimate } = each;
       const { started, ended } = span(status, now);
-      const estimate = estimateOf(status.attempts);
       return {
         ref: status.ref,
         state: status.state,
@@ -108,7 +115,7 @@ async function list(place: ReadPlace, limit: number, json: boolean, out: Out, no
       };
     });
     const document: RunsJson = {
-      v: 1,
+      v: RUNS_V,
       runs: runsJson,
       ...(older > 0 ? { more: { older: true } } : {}),
     };
@@ -125,16 +132,15 @@ async function list(place: ReadPlace, limit: number, json: boolean, out: Out, no
   const stateWidth = Math.max(13, ...states.map((each) => each.length + 2));
   const lines = listed.map((each, index) => {
     if (!("status" in each)) return `${each.ref.padEnd(width)}unreadable: ${each.unreadable}`;
-    const { status } = each;
+    const { status, estimate, unknown } = each;
     const { started, ms } = span(status, now);
-    const estimate = estimateOf(status.attempts);
     const waiting = waitingText(status);
     return [
       status.ref.padEnd(width),
       states[index]!.padEnd(stateWidth),
       dayTime(started).padEnd(13),
-      formatDuration(ms).padEnd(8),
-      money(estimate)
+      duration(ms).padEnd(9),
+      money(estimate, unknown)
         .join("")
         .concat(waiting ? "  " : ""),
       waiting,
@@ -150,7 +156,7 @@ async function list(place: ReadPlace, limit: number, json: boolean, out: Out, no
 /** A run at its wait: its label, and until when; a returned one, the events it never took. */
 function waitingText(status: RunStatus): string {
   const { waiting } = status;
-  const never = status.attempts.at(-1)?.unacknowledged;
+  const never = status.unacknowledged;
   if (!waiting) return never ? `${never} event${never === 1 ? "" : "s"} never taken` : "";
   const until = waiting.until ? `until ${dayTime(Date.parse(waiting.until))}` : "";
   return [waiting.label, until].filter(Boolean).join(" · ") || "waiting";
@@ -186,7 +192,7 @@ function agentLine(agent: AgentView, indent: string, now: number, width: number)
             `from ${said(live.peer, 60)}${live.until ? ` (until ${clockTime(live.until).slice(0, 5)})` : ""}`,
           ]
         : []),
-    ...(agent.since && inTurn(agent) ? [formatDuration(now - agent.since)] : []),
+    ...(agent.since && inTurn(agent) ? [duration(now - agent.since)] : []),
     ...(agent.last
       ? [`last: ${describeActivity(agent.last.activity)} (${clockTime(agent.last.at)})`]
       : []),
@@ -230,7 +236,7 @@ function describe(view: RunView, place: ReadPlace, now: number): string {
     [
       status.ref,
       stateWord(status, view.lastEventAt),
-      ...(attempt && status.attempts.length > 1
+      ...(attempt && status.files.length > 1
         ? [
             `attempt ${attempt.attempt}${attempt.flags.fromStage ? ` (from stage ${attempt.flags.fromStage})` : ""}`,
           ]
@@ -238,25 +244,30 @@ function describe(view: RunView, place: ReadPlace, now: number): string {
       ...(view.stage ? [`stage ${view.stage}`] : []),
       status.state === "interrupted" && view.lastEventAt
         ? `last event ${clockTime(view.lastEventAt)}`
-        : formatDuration(span(status, now).ms),
-      ...money(view.estimate),
+        : duration(span(status, now).ms),
+      ...money(view.estimate, view.unknownCost),
     ].join("  "),
   ];
-  for (const earlier of status.attempts.slice(0, -1)) {
+  // Every other attempt file, a launch that never claimed its number included.
+  for (const earlier of status.files) {
+    if (earlier.attempt === attempt?.attempt) continue;
     const took = earlier.ended
-      ? `  ${formatDuration(Date.parse(earlier.ended) - Date.parse(earlier.started))}`
+      ? `  ${duration(Date.parse(earlier.ended) - Date.parse(earlier.started))}`
       : "";
-    const how = `${earlier.outcome ?? "interrupted"}${earlier.stage ? ` in ${earlier.stage}` : ""}`;
+    const stage = isClaimed(earlier) ? earlier.stage : undefined;
+    const how = isClaimed(earlier)
+      ? `${earlier.outcome ?? "interrupted"}${stage ? ` in ${stage}` : ""}`
+      : "failed to launch";
     lines.push(`  attempt ${earlier.attempt}  ${how}${took}`);
   }
-  const indent = status.attempts.length > 1 ? "  " : "";
+  const indent = status.files.length > 1 ? "  " : "";
   if (indent && attempt) lines.push(`  attempt ${attempt.attempt}`);
   const shown = new Set<string>();
   for (const stage of view.stages) {
     const took =
       stage.state === "reused" || stage.state === "provided" || stage.startedAt === undefined
         ? ""
-        : formatDuration((stage.endedAt ?? now) - stage.startedAt);
+        : duration((stage.endedAt ?? now) - stage.startedAt);
     lines.push(
       `${indent}  stage ${stage.stage.padEnd(8)} ${stage.state.padEnd(10)} ${took}`.trimEnd(),
     );
@@ -264,6 +275,7 @@ function describe(view: RunView, place: ReadPlace, now: number): string {
     for (const agent of own) shown.add(agent.key);
     lines.push(...agentLines(own, indent, now));
   }
+  if (view.unread) lines.push(`${indent}  awf: ${view.unread}`);
   lines.push(
     ...agentLines(
       view.agents.filter((each) => !shown.has(each.key)),
@@ -289,7 +301,7 @@ function trailer(view: RunView, place: ReadPlace): string[] {
   if (status.state === "interrupted") return go ? [`continue: ${go}`] : [];
   const lines: string[] = [];
   if (view.attempt?.reason) lines.push(`reason: ${said(view.attempt.reason, 400)}`);
-  lines.push(`records: ${status.run.dir} (report.md, output.json)`);
+  lines.push(`records: ${status.run.dir} (run.jsonl, log.jsonl, ops/, out.json, report.md)`);
   if (status.state === "failed") {
     const stuck = view.agents.find((each) => each.state === "failed" || each.state === "timed-out");
     const look = command(place, "awf", "logs", status.ref);
@@ -311,7 +323,7 @@ function runJson(view: RunView, place: ReadPlace, now: number): RunJson {
       ? undefined
       : continueOf(status, view.lines, place);
   return {
-    v: 2,
+    v: RUNS_ONE_V,
     run: {
       ref: status.ref,
       state: status.state,
@@ -322,20 +334,26 @@ function runJson(view: RunView, place: ReadPlace, now: number): RunJson {
       ...(status.waiting ? { waiting: status.waiting } : {}),
       dir: status.run.dir,
     },
-    attempts: status.attempts.map(({ attempt, started, ended, outcome, stage, reason }) => ({
-      attempt,
-      started,
-      ...(ended ? { ended } : {}),
-      state:
-        outcome ?? (attempt === status.attempts.at(-1)?.attempt ? status.state : "interrupted"),
-      ...(stage ? { stage } : {}),
-      ...(reason ? { reason: masked(reason, 1_000) as string } : {}),
-    })),
-    stages: view.stages.map(({ stage, state, startedAt, endedAt }) => ({
+    // Every attempt file, a launch that never claimed its number included, `failed` with its reason.
+    attempts: status.files.map((each) => {
+      const { attempt, started, ended, outcome, reason } = each;
+      const stage = isClaimed(each) ? each.stage : undefined;
+      return {
+        attempt,
+        started,
+        ...(ended ? { ended } : {}),
+        state:
+          outcome ?? (attempt === status.attempts.at(-1)?.attempt ? status.state : "interrupted"),
+        ...(stage ? { stage } : {}),
+        ...(reason ? { reason: masked(reason, 1_000) as string } : {}),
+      };
+    }),
+    stages: view.stages.map(({ stage, state, startedAt, endedAt, value }) => ({
       stage,
       state,
       ...(startedAt ? { started: new Date(startedAt).toISOString() } : {}),
       ...(endedAt ? { ended: new Date(endedAt).toISOString() } : {}),
+      ...(value === undefined ? {} : { value: masked(value) as JsonValue }),
     })),
     agents: view.agents.map((agent) => ({
       key: agent.key,