catherd-cli 1.0.0 → 1.1.0

package/src/services/runs-page.ts

@@ -0,0 +1,254 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { budgetStatus } from "../domain/budget.ts";
+import { ID_PATTERN } from "../domain/ids.ts";
+import type { RunRecord } from "../domain/record.ts";
+import { dispatchPaths } from "../infra/dispatch-dir.ts";
+import { nonBlankLines } from "../infra/store.ts";
+import { spendOf } from "./budget.ts";
+import { dispatchState, listDispatches, liveDispatches } from "./dispatches.ts";
+import { lastActivity } from "./finalize.ts";
+import type { Deps } from "./ports.ts";
+import { findRun, listRuns, readRecords, type Run, runPaths } from "./run-store.ts";
+import { groupRuns, type SessionGroup } from "./session-view.ts";
+
+/**
+ * Spec §4: what the Runs tab shows. The top level is the sessions; a session's screen holds its runs, each with its
+ * milestones and every role (live ones first); a role's screen holds its brief, reply and record.
+ */
+
+export interface SessionRow {
+  /** the session id; null for "earlier runs" */
+  key: string | null;
+  name: string;
+  live: boolean;
+  runs: number;
+  liveRoles: number;
+  landed: number;
+  /** ISO time of its newest activity */
+  lastActivity: string;
+}
+
+export interface RoleRow {
+  run: string;
+  dispatchId: string;
+  name: string;
+  role: string;
+  rung: string;
+  /** running | starting while live; once finished, the record's status (`finished` until it has one) */
+  status: string;
+  live: boolean;
+  /** a live role's admission time: the page ticks its elapsed time from it */
+  since: string;
+  /** a finished role's seconds, from its record */
+  secs: number | null;
+  /** a live role's last command, file edit or message line */
+  lastEvent: string | null;
+  replyStatus: string | null;
+}
+
+export interface Milestone {
+  name: string;
+  landed: boolean;
+  /** the ledger's "what" once landed */
+  what: string;
+}
+
+export interface SessionRun {
+  id: string;
+  title: string;
+  repo: string;
+  createdAt: string;
+  continued: "here" | "elsewhere" | null;
+  continuedIn: string | null;
+  /** the budget's spent fraction, null without a cap */
+  budget: number | null;
+  milestones: Milestone[];
+  roles: RoleRow[];
+}
+
+export interface SessionDetail {
+  session: SessionRow;
+  runs: SessionRun[];
+  /** the run folders to watch for changes */
+  dirs: string[];
+}
+
+export interface RoleDetail {
+  run: string;
+  runTitle: string;
+  dispatchId: string;
+  name: string;
+  role: string;
+  rung: string;
+  /** running | starting | finished */
+  state: string;
+  brief: string;
+  reply: string;
+  record: RunRecord | null;
+}
+
+export interface MilestoneDetail {
+  run: string;
+  runTitle: string;
+  name: string;
+  landed: boolean;
+  what: string;
+  /** R/digests/<name>.md; null when land has not written one (not landed, or landed by 1.0) or it is empty */
+  digest: string | null;
+}
+
+const keyOf = (g: SessionGroup): string | null => g.session?.sessionId ?? null;
+
+/** The runs that live on in a session now (it owns them): each run's live roles and landings count once. */
+const ownRuns = (g: SessionGroup): Run[] => g.runs.filter((x) => x.current).map((x) => x.run);
+
+function rowOf(deps: Deps, g: SessionGroup): SessionRow {
+  const own = ownRuns(g);
+  return {
+    key: keyOf(g),
+    name: g.session?.name ?? "earlier runs",
+    live: g.session?.live ?? false,
+    runs: g.runs.length,
+    liveRoles: own.reduce((n, r) => n + liveDispatches(r, deps.now()).length, 0),
+    landed: own.reduce((n, r) => n + Math.max(0, nonBlankLines(runPaths(r.dir).ledger).length - 1), 0),
+    lastActivity: new Date(g.lastActivity).toISOString(),
+  };
+}
+
+/** The Runs tab's top level: every session, newest activity first, "earlier runs" last. */
+export function sessionRows(deps: Deps): { rows: SessionRow[]; warnings: string[] } {
+  const { runs, corrupt } = listRuns();
+  return {
+    rows: groupRuns(runs).map((g) => rowOf(deps, g)),
+    warnings: corrupt.map((c) => `skipped run ${c.id}: ${c.reason}`),
+  };
+}
+
+/** The ledger's landed milestones, then each milestone a lane file names that has not landed. */
+function milestonesOf(run: Run): Milestone[] {
+  const landed = nonBlankLines(runPaths(run.dir).ledger)
+    .slice(1)
+    .map((l) => l.split(" | "))
+    .map(([name, what]) => ({ name: (name ?? "").trim(), landed: true, what: (what ?? "").trim() }));
+  const lanes = existsSync(runPaths(run.dir).lanes) ? readdirSync(runPaths(run.dir).lanes) : [];
+  const open = [...new Set(lanes.map((f) => /^(M\d+)\./.exec(f)?.[1]).filter((m): m is string => !!m))]
+    .filter((m) => !landed.some((l) => l.name === m))
+    .map((name) => ({ name, landed: false, what: "" }));
+  const n = (m: string) => Number(/\d+/.exec(m)?.[0] ?? 0);
+  return [...landed, ...open.sort((a, b) => n(a.name) - n(b.name))];
+}
+
+/** Each role's latest dispatch, live ones first, then the newest finished first. */
+function rolesOf(deps: Deps, run: Run): RoleRow[] {
+  const now = deps.now();
+  const records = new Map(readRecords(run).records.map((r) => [r.dispatchId, r]));
+  const latest = new Map<string, ReturnType<typeof listDispatches>[number]>();
+  for (const d of listDispatches(run)) latest.set(d.admit.name, d);
+  const rows = [...latest.values()].map((d): RoleRow => {
+    const r = records.get(d.admit.dispatchId);
+    const state = r ? "finished" : dispatchState(d, now);
+    const live = state !== "finished";
+    return {
+      run: run.id,
+      dispatchId: d.admit.dispatchId,
+      name: d.admit.name,
+      role: d.admit.role,
+      rung: d.admit.rung,
+      status: r?.status ?? state,
+      live,
+      since: d.admit.admittedAt,
+      secs: r?.secs ?? null,
+      lastEvent: live ? lastActivity(d) : null,
+      replyStatus: r?.replyStatus ?? null,
+    };
+  });
+  return rows.sort((a, b) =>
+    a.live !== b.live ? (a.live ? -1 : 1) : b.dispatchId.localeCompare(a.dispatchId),
+  );
+}
+
+function sessionRun(deps: Deps, x: SessionGroup["runs"][number]): SessionRun {
+  const run = x.run;
+  let budget: number | null = null;
+  try {
+    const b = budgetStatus(
+      spendOf(run, readRecords(run).records, liveDispatches(run, deps.now()), deps.now()),
+      deps.profiles.forRepo(run.meta.repo).budget,
+    );
+    budget = b?.fraction ?? null;
+  } catch {
+    // an unreadable profile: no bar, the rest of the page stands
+  }
+  return {
+    id: run.id,
+    title: run.meta.title,
+    repo: run.meta.repo,
+    createdAt: run.meta.createdAt,
+    continued: x.continued,
+    continuedIn: x.continuedIn,
+    budget,
+    milestones: milestonesOf(run),
+    roles: rolesOf(deps, run),
+  };
+}
+
+/** A session's screen: its runs, newest first, each with its milestones and roles. */
+export function sessionDetail(deps: Deps, key: string | null): SessionDetail {
+  const g = groupRuns(listRuns().runs).find((x) => keyOf(x) === key);
+  if (!g) throw new Error(key === null ? "no earlier runs" : `no session "${key}" in the runs`);
+  return {
+    session: rowOf(deps, g),
+    runs: g.runs.map((x) => sessionRun(deps, x)),
+    dirs: g.runs.map((x) => x.run.dir),
+  };
+}
+
+const text = (file: string): string => {
+  try {
+    return readFileSync(file, "utf8");
+  } catch {
+    return "";
+  }
+};
+
+/** A role's screen: its brief, its reply and its record. */
+export function roleDetail(deps: Deps, runId: string, dispatchId: string): RoleDetail {
+  const run = findRun(runId);
+  const d = listDispatches(run).find((x) => x.admit.dispatchId === dispatchId);
+  if (!d) throw new Error(`no dispatch ${dispatchId} in run ${runId}`);
+  const record = readRecords(run).records.find((r) => r.dispatchId === dispatchId) ?? null;
+  const p = dispatchPaths(d.dir);
+  return {
+    run: run.id,
+    runTitle: run.meta.title,
+    dispatchId,
+    name: d.admit.name,
+    role: d.admit.role,
+    rung: d.admit.rung,
+    state: record ? "finished" : dispatchState(d, deps.now()),
+    brief: text(p.brief),
+    reply: text(p.reply),
+    record,
+  };
+}
+
+/** Spec 1.1 §10: a milestone's screen, its digest. */
+export function milestoneDetail(runId: string, name: string): MilestoneDetail {
+  const run = findRun(runId);
+  // the id rule land writes digests under (assertId): never a path out of the run folder
+  const valid = ID_PATTERN.test(name) && !name.includes("..");
+  const m = valid ? milestonesOf(run).find((x) => x.name === name) : undefined;
+  if (!m) throw new Error(`no milestone "${name}" in run ${runId}`);
+  const file = join(run.dir, "digests", `${name}.md`);
+  const text = existsSync(file) ? readFileSync(file, "utf8") : "";
+  return {
+    run: run.id,
+    runTitle: run.meta.title,
+    name,
+    landed: m.landed,
+    what: m.what,
+    // an empty file is no digest either: land writes the whole digest at once
+    digest: text.trim() ? text : null,
+  };
+}

package/src/services/session-view.ts

@@ -0,0 +1,152 @@
+import { statSync } from "node:fs";
+import { liveSessionFile, readSessionFiles, type SessionFile } from "../infra/claude-session.ts";
+import { type Run, runPaths } from "./run-store.ts";
+import { readSessionRows } from "./sessions.ts";
+
+/**
+ * Spec §4: runs grouped by the Claude Code session that drove them. A run belongs to the session that started it
+ * (`meta.startedBy`); a run listed in another session's rows of `sessions.jsonl` also appears under that session,
+ * as "continued here", and under its starting session it says "continued in <name>", naming the session that
+ * owns it now (the last row of `sessions.jsonl`; a run that came back to its starter is not "continued" at
+ * all). Only the current owner's group counts its live roles and landings. Runs from 1.0 (no
+ * `startedBy`) go under "earlier runs".
+ */
+
+/** A session as the runs page shows it: its name read live while it runs, else the last one recorded. */
+export interface RunSession {
+  sessionId: string;
+  hostSessionId: string | null;
+  name: string;
+  /** the session's process runs now */
+  live: boolean;
+}
+
+export interface GroupedRun {
+  run: Run;
+  /** "here": this session continued a run another started; "elsewhere": another session continued it */
+  continued: "here" | "elsewhere" | null;
+  /** the session that owns it now, for "elsewhere" */
+  continuedIn: string | null;
+  /** the run lives on in this session now (it is the run's current owner): its live roles count here */
+  current: boolean;
+}
+
+export interface SessionGroup {
+  /** null: "earlier runs", the 1.0 runs no session is recorded for */
+  session: RunSession | null;
+  runs: GroupedRun[];
+  /** when anything last happened in one of its runs, ms since the epoch */
+  lastActivity: number;
+}
+
+/** Newest of the run's creation and its state and record files' last writes. */
+export function runActivity(run: Run): number {
+  const p = runPaths(run.dir);
+  let t = Date.parse(run.meta.createdAt) || 0;
+  for (const f of [p.stateJson, p.runs, p.state, p.agents]) {
+    try {
+      t = Math.max(t, statSync(f).mtimeMs);
+    } catch {
+      // not written yet
+    }
+  }
+  return t;
+}
+
+/** The sessions each run has had, oldest first: its starter, then each one that took it over. */
+function trailOf(
+  run: Run,
+): { sessionId: string; hostSessionId: string | null; name: string | null; at: string }[] {
+  const rows = readSessionRows(run);
+  const s = run.meta.startedBy;
+  if (s && !rows.some((r) => r.sessionId === s.sessionId)) return [{ ...s, at: run.meta.createdAt }, ...rows];
+  return rows;
+}
+
+/** Every run grouped by session, the groups newest activity first, the runs in each newest first. */
+export function groupRuns(runs: Run[], files: SessionFile[] = readSessionFiles()): SessionGroup[] {
+  // the last name recorded for each session, in any run
+  const recorded = new Map<string, { name: string | null; host: string | null; at: string }>();
+  const trails = new Map(runs.map((r) => [r.id, trailOf(r)]));
+  for (const t of trails.values())
+    for (const row of t) {
+      const was = recorded.get(row.sessionId);
+      if (!was || row.at >= was.at)
+        recorded.set(row.sessionId, {
+          name: row.name ?? was?.name ?? null,
+          host: row.hostSessionId ?? was?.host ?? null,
+          at: row.at,
+        });
+    }
+  const sessionOf = (id: string): RunSession => {
+    const live = liveSessionFile(id, files);
+    const rec = recorded.get(id);
+    return {
+      sessionId: id,
+      hostSessionId: live?.hostSessionId ?? rec?.host ?? null,
+      name: live?.name ?? rec?.name ?? `session ${id.slice(0, 8)}`,
+      live: live !== null,
+    };
+  };
+  const groups = new Map<string | null, SessionGroup>();
+  const add = (id: string | null, g: GroupedRun, at: number) => {
+    let group = groups.get(id);
+    if (!group) {
+      group = { session: id === null ? null : sessionOf(id), runs: [], lastActivity: 0 };
+      groups.set(id, group);
+    }
+    group.runs.push(g);
+    group.lastActivity = Math.max(group.lastActivity, at);
+  };
+  for (const run of runs) {
+    const at = runActivity(run);
+    const trail = trails.get(run.id) ?? [];
+    const starter = run.meta.startedBy?.sessionId ?? null;
+    // the run lives on in its current owner: the last session that took it (a run can come back to its starter)
+    const owner = trail.at(-1)?.sessionId ?? starter;
+    const moved = owner !== starter && owner !== null;
+    // a run that lives on elsewhere counts, in a session it left, from when that session last took it
+    const tookAt = (id: string | null): number =>
+      Date.parse(trail.findLast((t) => t.sessionId === id)?.at ?? run.meta.createdAt) || 0;
+    add(
+      starter,
+      {
+        run,
+        continued: moved ? "elsewhere" : null,
+        continuedIn: moved ? sessionOf(owner).name : null,
+        current: !moved,
+      },
+      moved ? tookAt(starter) : at,
+    );
+    for (const id of new Set(trail.map((t) => t.sessionId)))
+      if (id !== starter)
+        add(
+          id,
+          { run, continued: "here", continuedIn: null, current: id === owner },
+          id === owner ? at : tookAt(id),
+        );
+  }
+  const out = [...groups.values()];
+  for (const g of out)
+    g.runs.sort(
+      (a, b) =>
+        runActivity(b.run) - runActivity(a.run) || b.run.meta.createdAt.localeCompare(a.run.meta.createdAt),
+    );
+  // "earlier runs" last, whatever its activity: 1.0 runs are history
+  return out.sort((a, b) =>
+    a.session === null ? 1 : b.session === null ? -1 : b.lastActivity - a.lastActivity,
+  );
+}
+
+/**
+ * The session a run started in, as the runs page names it now (null for a run from before 1.1), and the session
+ * that continued it, if another did.
+ */
+export function sessionFacts(
+  run: Run,
+  files: SessionFile[] = readSessionFiles(),
+): { session: RunSession | null; continuedIn: string | null } {
+  const starter = run.meta.startedBy?.sessionId ?? null;
+  const own = groupRuns([run], files).find((g) => (g.session?.sessionId ?? null) === starter);
+  return { session: own?.session ?? null, continuedIn: own?.runs[0]?.continuedIn ?? null };
+}

package/src/services/sessions.ts

@@ -0,0 +1,92 @@
+import { z } from "zod";
+import { sessionFileFor } from "../infra/claude-session.ts";
+import { withFileLock } from "../infra/filelock.ts";
+import { appendJsonl, ensureJsonlHeader, readJsonl, writeJsonAtomic } from "../infra/store.ts";
+import type { Deps } from "./ports.ts";
+import { type Run, runPaths } from "./run-store.ts";
+import { readNotes } from "./state.ts";
+
+/** Spec §4: a Claude Code session as catherd records it. */
+export interface SessionRef {
+  sessionId: string;
+  hostSessionId: string | null;
+  name: string | null;
+}
+
+/**
+ * The session this process serves (spec §3.3), read live: its registry file's id and name when it has one (the
+ * id in the environment goes stale after /clear), else the environment's. Null outside Claude Code.
+ */
+export function currentSession(deps: Deps): SessionRef | null {
+  const env = deps.session;
+  if (!env) return null;
+  const file = sessionFileFor(env);
+  const sessionId = file?.sessionId ?? env.sessionId;
+  if (!sessionId) return null;
+  return { sessionId, hostSessionId: file?.hostSessionId ?? env.hostSessionId, name: file?.name ?? null };
+}
+
+const OwnerSchema = z.object({ sessionId: z.string(), since: z.string() });
+export type Owner = z.infer<typeof OwnerSchema>;
+
+/** The run's owner session (state.json `owner`), or null for a run no session has owned (1.0, a terminal). */
+export function runOwner(run: Run): Owner | null {
+  const r = OwnerSchema.safeParse((readNotes(run) as Record<string, unknown>).owner);
+  return r.success ? r.data : null;
+}
+
+/** Whether this process serves a session and that session owns the run now. */
+export function ownsRun(deps: Deps, run: Run): boolean {
+  const me = currentSession(deps);
+  return me !== null && runOwner(run)?.sessionId === me.sessionId;
+}
+
+const SessionRowSchema = z.looseObject({
+  sessionId: z.string(),
+  hostSessionId: z.string().nullable(),
+  name: z.string().nullable(),
+  at: z.string(),
+});
+export type SessionRow = z.infer<typeof SessionRowSchema>;
+
+/** `R/sessions.jsonl`: every session that has owned the run, in the order they took it. */
+export function readSessionRows(run: Run): SessionRow[] {
+  return readJsonl<unknown>(runPaths(run.dir).sessions).rows.flatMap((row) => {
+    const r = SessionRowSchema.safeParse(row);
+    return r.success ? [r.data] : [];
+  });
+}
+
+/**
+ * Spec §3.3: `run_start`, `dispatch` and `peek` make the calling session the run's owner when it is not, and
+ * append it to `R/sessions.jsonl`: that is how a run moves when it is continued from another session. Outside
+ * Claude Code it changes nothing. Returns whether the owner changed.
+ */
+export async function claimRun(deps: Deps, run: Run): Promise<boolean> {
+  const me = currentSession(deps);
+  if (!me) return false;
+  const p = runPaths(run.dir);
+  const at = new Date(deps.now()).toISOString();
+  const row = (since: string): void => {
+    ensureJsonlHeader(p.sessions, "sessions");
+    appendJsonl(p.sessions, {
+      sessionId: me.sessionId,
+      hostSessionId: me.hostSessionId,
+      name: me.name,
+      at: since,
+    });
+  };
+  // the trail row goes in under the same lock: the trail's last row is the owner (session-view reads it so)
+  return withFileLock(p.stateJson, () => {
+    const notes = readNotes(run);
+    const owner = runOwner(run);
+    if (owner?.sessionId === me.sessionId) {
+      // a crash between the state.json write and the append left the trail without its owner: repaired here
+      if (readSessionRows(run).at(-1)?.sessionId !== me.sessionId) row(owner.since);
+      return false;
+    }
+    writeJsonAtomic(p.stateJson, { ...notes, owner: { sessionId: me.sessionId, since: at } });
+    row(at);
+    return true;
+  });
+}

package/src/services/state.ts

@@ -2,12 +2,13 @@ import { relative } from "node:path";
 import { z } from "zod";
 import { errorMessage, isCatherdError } from "../domain/errors.ts";
 import { overlaps } from "../domain/lane.ts";
-import { renderState } from "../domain/state.ts";
+import { renderState, withParked } from "../domain/state.ts";
 import { dispatchPaths } from "../infra/dispatch-dir.ts";
 import { withFileLock } from "../infra/filelock.ts";
 import { gitHead, statusSnapshot } from "../infra/git.ts";
 import { readVersioned, writeJsonAtomic, writeTextAtomic } from "../infra/store.ts";
 import { liveDispatches } from "./dispatches.ts";
+import { protocolNext } from "./protocol.ts";
 import { type Run, runPaths } from "./run-store.ts";
 
 /** state.json: the orchestrator's notes that state.md shows beside the live facts. */
@@ -16,10 +17,15 @@ const NotesSchema = z.looseObject({
   next: z.string(),
   lastCheck: z.string().nullable(),
   lastLandedAt: z.string().nullable(),
+  /** spec 1.1 §8: the milestones waiting on the owner */
+  parked: z.array(z.string()).optional(),
 });
 export type Notes = z.infer<typeof NotesSchema>;
 export type NotesPatch = Partial<Omit<Notes, "schema">>;
 
+/** Every writer's next step keeps the parked milestones in front of it (spec 1.1 §8). */
+const parkedNext = (n: Notes): Notes => ({ ...n, next: withParked(n.next, n.parked ?? []) });
+
 const FRESH: Notes = { schema: 1, next: "plan the milestones", lastCheck: null, lastLandedAt: null };
 
 export function readNotes(run: Run): Notes {
@@ -42,7 +48,7 @@ export function updateState(run: Run, change: NotesPatch | ((n: Notes) => NotesP
     // git first: a failed snapshot throws before either file is written, so they never disagree
     const [head, snap] = await Promise.all([gitHead(run.meta.repo), statusSnapshot(run.meta.repo)]);
     const notes = readNotes(run);
-    const next: Notes = { ...notes, ...(typeof change === "function" ? change(notes) : change) };
+    const next = parkedNext({ ...notes, ...(typeof change === "function" ? change(notes) : change) });
     writeJsonAtomic(p.stateJson, next);
     const live = liveDispatches(run);
     const text = renderState({
@@ -63,6 +69,7 @@ export function updateState(run: Run, change: NotesPatch | ((n: Notes) => NotesP
       })),
       lastCheck: next.lastCheck,
       next: next.next,
+      protocol: protocolNext(run, next.parked ?? []),
     });
     writeTextAtomic(p.state, text);
     return text;
@@ -92,7 +99,7 @@ export async function refreshState(
       try {
         await withFileLock(stateJson, () => {
           const notes = readNotes(run);
-          writeJsonAtomic(stateJson, { ...notes, ...apply(notes) });
+          writeJsonAtomic(stateJson, parkedNext({ ...notes, ...apply(notes) }));
         });
       } catch (e2) {
         // the lock outwaited (a slow git under another refresh): still never fail the call

package/src/services/summary.ts

@@ -5,7 +5,10 @@ import type { Tokens } from "../domain/record.ts";
 import { median } from "../domain/util.ts";
 import { nonBlankLines, readJsonl } from "../infra/store.ts";
 import { spendOf } from "./budget.ts";
+import { latestVerifierStep, type VerifierStep } from "./gate-service.ts";
+import { type OpenQuestion, openQuestions } from "./questions.ts";
 import { type DispatchState, liveDispatches } from "./dispatches.ts";
+import { type RunSession, sessionFacts } from "./session-view.ts";
 import type { Deps } from "./ports.ts";
 import {
   findRun,
@@ -19,9 +22,15 @@ import {
 
 export interface RunSummary {
   id: string;
+  /** spec 1.1 §8: the owner questions not answered yet, listed first */
+  questions: OpenQuestion[];
   title: string;
   repo: string;
   createdAt: string;
+  /** spec §4: the Claude Code session that started it (null before 1.1), named live while it runs */
+  session: RunSession | null;
+  /** the session that continued it, when another did */
+  continuedIn: string | null;
   stateTail: string[];
   live: { name: string; rung: string; state: DispatchState; secs: number; dispatchId: string }[];
   totals: { runs: number; ok: number; notOk: string[]; tokens: Tokens; costUsd: number; wallMinutes: number };
@@ -32,6 +41,8 @@ export interface RunSummary {
   harness: { backend: string; native: number; isolated: number }[];
   budget: BudgetStatus | null;
   milestones: string[];
+  /** spec 1.1 §7: the verifier's latest gate_check, so the user sees where it is */
+  verifier: VerifierStep | null;
   warnings: string[];
 }
 
@@ -52,9 +63,11 @@ export function summarizeRun(deps: Deps, run: Run): RunSummary {
   }
   return {
     id: run.id,
+    questions: openQuestions(run),
     title: run.meta.title,
     repo: run.meta.repo,
     createdAt: run.meta.createdAt,
+    ...sessionFacts(run),
     stateTail: nonBlankLines(runPaths(run.dir).state).slice(-3),
     live: live.map((d) => ({
       name: d.admit.name,
@@ -88,6 +101,7 @@ export function summarizeRun(deps: Deps, run: Run): RunSummary {
     }),
     budget,
     milestones: nonBlankLines(runPaths(run.dir).ledger).slice(1),
+    verifier: latestVerifierStep(run),
     warnings,
   };
 }