catherd-cli 1.0.0 → 1.1.0

package/src/entry/mcp/protocol-tools.ts

@@ -0,0 +1,57 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ID_PATTERN } from "../../domain/ids.ts";
+import { gateCheck, gatePass } from "../../services/gate-service.ts";
+import { answer, park } from "../../services/questions.ts";
+import type { Deps } from "../../services/ports.ts";
+import { handle } from "./result.ts";
+
+// Spec 1.1 §7 and §8: the tools the enforced protocol adds.
+export function registerProtocolTools(server: McpServer, deps: Deps): void {
+  const gate = {
+    run: z.string(),
+    item: z.string().min(1),
+    command: z.string().min(1),
+    paths: z.array(z.string().min(1)).min(1),
+  };
+
+  server.registerTool(
+    "gate_check",
+    {
+      description:
+        "The verifier, before running a gate item: { carried: true, passedAt, commit } when this repo already has a pass of the same command on the same content of paths (repo-relative; . for the whole repo: HEAD plus uncommitted not-ignored changes; a git-ignored input such as .env or a build output is hashed only when named as a path), so it reports the item as carried over from that commit instead of running it; else { carried: false }, and it runs the item. Either way the call is recorded as the verifier's current step, which status and peek show. Pass milestone (the M the verifier checks) so the milestone's digest lists only its own carried items.",
+      inputSchema: { ...gate, milestone: z.string().regex(ID_PATTERN).optional() },
+    },
+    (a) => handle(() => gateCheck(deps, a)),
+  );
+
+  server.registerTool(
+    "gate_pass",
+    {
+      description:
+        "The verifier, after a gate item passed: records the command, the content hash of paths and the commit, with the evidence (a log path or the decisive line), so a later gate_check on unchanged content carries it over.",
+      inputSchema: { ...gate, evidence: z.string().min(1) },
+    },
+    (a) => handle(() => gatePass(deps, a)),
+  );
+
+  server.registerTool(
+    "park",
+    {
+      description:
+        "An owner question only the user can answer: parks the milestone (land refuses it until answered) and puts it in front of state.md's next step, instead of stopping the run. Returns the parked milestones and hints: push the full question to the user with PushNotification, and go on with the milestones and runs that do not depend on it.",
+      inputSchema: { run: z.string(), milestone: z.string().regex(ID_PATTERN), question: z.string().min(1) },
+    },
+    (a) => handle(() => park(deps, a)),
+  );
+
+  server.registerTool(
+    "answer",
+    {
+      description:
+        "The owner answered a parked milestone's question in this session: records the answer and unparks the milestone. status, peek and run_start list the questions still open.",
+      inputSchema: { run: z.string(), milestone: z.string().regex(ID_PATTERN), answer: z.string().min(1) },
+    },
+    (a) => handle(() => answer(deps, a)),
+  );
+}

package/src/entry/mcp/run-tools.ts

@@ -22,7 +22,7 @@ export function registerRunTools(server: McpServer, deps: Deps): void {
     "run_start",
     {
       description:
-        "Start a catherd run for a git repository: creates its run folder (outside the repo) and state.md. Returns the run id and the folder, and hints when state.md could not be written yet.",
+        "Start a catherd run for a git repository: creates its run folder (outside the repo) and state.md. Returns the run id, the folder, protocol (the next step of the milestone loop and its six-line checklist), and hints when state.md could not be written yet.",
       inputSchema: {
         repo: z.string().min(1),
         title: z.string().min(1),
@@ -68,7 +68,8 @@ export function registerRunTools(server: McpServer, deps: Deps): void {
   server.registerTool(
     "result",
     {
-      description: "A role's latest dispatch: its state, its record once finished, and its capped reply.",
+      description:
+        "A role's latest dispatch: its state, its record once finished, its capped reply, and hints (climb, violation, failed, limit and failover lines). Reading a finished record marks it read: catherd's messages announce records, and this is how you read one.",
       inputSchema: { run: z.string(), name: z.string().regex(ID_PATTERN) },
     },
     (a) => handle(() => result(deps, a)),
@@ -88,7 +89,7 @@ export function registerRunTools(server: McpServer, deps: Deps): void {
     "record_agent_run",
     {
       description:
-        "After every native Claude subagent (Agent tool) of a run, record what the Agent result reported: total_tokens and duration_ms. The budget counts it. Pass lane (e.g. M1.L1) when the subagent worked a lane, so its time counts toward that lane's kind in the catalog timings.",
+        "After every native Claude subagent (Agent tool) of a run, record what the Agent result reported: total_tokens and duration_ms. The budget counts it. Pass lane (e.g. M1.L1) when the subagent worked a lane, so its time counts toward that lane's kind in the catalog timings. status says how the subagent's work ended: for a verifier it is the verdict, so pass status: \"failed\" when its verdict is FAIL; only a PASS is recorded ok.",
       inputSchema: {
         run: z.string(),
         name: z.string().regex(ID_PATTERN),

package/src/entry/mcp/server.ts

@@ -3,11 +3,13 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { errorMessage } from "../../domain/errors.ts";
 import { log } from "../../infra/log.ts";
+import { startNotifier } from "../../services/notifier.ts";
 import type { Deps } from "../../services/ports.ts";
 import { reconcileAll } from "../../services/reconcile.ts";
 import { defaultDeps } from "../deps.ts";
 import { registerDispatchTools } from "./dispatch-tools.ts";
 import { registerLaneTools } from "./lane-tools.ts";
+import { registerProtocolTools } from "./protocol-tools.ts";
 import { sdkToolError, toolOf } from "./result.ts";
 import { registerRunTools } from "./run-tools.ts";
 import { registerSetupTools } from "./setup-tools.ts";
@@ -52,12 +54,24 @@ export function buildServer(deps: Deps = defaultDeps()): McpServer {
   registerLaneTools(server, deps);
   registerDispatchTools(server, deps);
   registerSetupTools(server, deps);
+  registerProtocolTools(server, deps);
   return server;
 }
 
-/** Spec §4.7: connect first, so the client never waits on a scan; then reconcile every run. */
+/**
+ * Spec §4.7: connect first, so the client never waits on a scan; then reconcile every run. Spec §3.4: the notifier
+ * starts before reconcile, so what reconcile settles is announced, and scans for the rest once it is done.
+ */
 export async function startMcpServer(): Promise<void> {
   const deps = defaultDeps();
+  // which of the session's variables this server got (never their values): the live check of spec §3.9
+  log("info", "session", {
+    sessionId: Boolean(deps.session?.sessionId),
+    hostSessionId: Boolean(deps.session?.hostSessionId),
+    socket: Boolean(deps.session?.socketPath),
+    token: Boolean(deps.session?.token),
+  });
+  const notifier = startNotifier(deps);
   await buildServer(deps).connect(new StdioServerTransport());
   try {
     const r = await reconcileAll(deps);
@@ -69,4 +83,6 @@ export async function startMcpServer(): Promise<void> {
   } catch (e) {
     console.error(`catherd: reconcile failed: ${errorMessage(e)}`);
   }
+  // whatever finished unread while no server ran, or finished under another server (spec §3.4)
+  void notifier.scan();
 }

package/src/entry/mcp/setup-tools.ts

@@ -73,7 +73,7 @@ export function registerSetupTools(server: McpServer, deps: Deps): void {
     "profile_set",
     {
       description:
-        "Apply a patch to a profile (without a name: the profile this repo runs on, as in profile_get; a new name starts from the default profile): objective, jev.use, billing, roles (enabled, access, rungs, defaultRung), harness isolation per backend, failover, budget, timeouts, preflight.confirm, lock.heavy and notify. Lists replace, maps merge, and null removes a key. An unknown key is refused. It validates first and writes nothing when invalid; otherwise it saves, rewrites the agent files and relinks them. Returns the errors and warnings, the diff, and newSessionNeededFor: the agents that apply from the next Claude Code session.",
+        "Apply a patch to a profile (without a name: the profile this repo runs on, as in profile_get; a new name starts from the default profile): objective, jev.use, billing, roles (enabled, access, network, rungs, defaultRung), harness isolation per backend, failover, budget, timeouts, preflight.confirm, lock.heavy and notify. Lists replace, maps merge, and null removes a key. An unknown key is refused. It validates first and writes nothing when invalid; otherwise it saves, rewrites the agent files and relinks them. Returns the errors and warnings, the diff, and newSessionNeededFor: the agents that apply from the next Claude Code session.",
       inputSchema: { name: PROFILE, repo: REPO, patch: ProfilePatchSchema },
     },
     (a) => handle(async () => deps.profiles.set(a.name, a.patch, await toplevel(a.repo))),

package/src/entry/profile-command.ts

@@ -40,7 +40,7 @@ export interface StandIn {
   via: string | null;
 }
 
-/** Spec §7.2: each stand-in, marked inferred when its scores are catherd's guess. */
+/** Spec §7.2: each stand-in; `via` names the rung whose scores it borrows (spec 1.1 §11). */
 export function standIns(p: Profile, c: Catalog): StandIn[] {
   return Object.entries(p.failover).map(([from, to]) => {
     try {
@@ -83,7 +83,7 @@ export function formatProfile(
     }
     const ladder = rc.rungs.map((r) => (r === rc.defaultRung ? `${r} (default)` : r)).join(" → ");
     lines.push(
-      `  ${role.padEnd(width)}  ${`${rc.access}, ${o.enforcement[role]}`.padEnd(27)}  ${ladder || "no rungs"}`,
+      `  ${role.padEnd(width)}  ${`${rc.access}${rc.network === false ? " (no network)" : ""}, ${o.enforcement[role]}`.padEnd(27)}  ${ladder || "no rungs"}`,
     );
   }
   // only what catherd can run today: a backend without an adapter has nothing to bill or isolate
@@ -94,9 +94,7 @@ export function formatProfile(
   lines.push(`harness ${harness.map(([k, h]) => `${k} ${h.isolated ? "isolated" : "native"}`).join(" · ")}`);
   lines.push(o.standIns.length ? "failover" : "failover none");
   for (const s of o.standIns)
-    lines.push(
-      `  ${s.from} → ${s.to}${s.inferred ? ` (inferred${s.via ? `: treated like ${s.via}` : ""})` : ""}`,
-    );
+    lines.push(`  ${s.from} → ${s.to}${s.via ? ` (scores borrowed from ${s.via})` : ""}`);
   const budget = Object.entries(p.budget).map(([k, v]) => (k === "usd" ? `$${v}` : `${v} ${k}`));
   lines.push(`budget ${budget.join(" · ") || "no cap"}`);
   lines.push(`timeouts idle ${p.timeouts.idleMin} min · wall ${p.timeouts.wallMin} min`);

package/src/entry/runs-command.ts

@@ -7,7 +7,8 @@ import { redact } from "../infra/log.ts";
 import { cancel } from "../services/dispatch-service.ts";
 import { registerSavedSecrets } from "../services/jev-service.ts";
 import { runDebug } from "../services/run-debug.ts";
-import { findRun, listRuns, readRecords } from "../services/run-store.ts";
+import { findRun, listRuns, readRecords, type Run } from "../services/run-store.ts";
+import { groupRuns, type RunSession, type SessionGroup } from "../services/session-view.ts";
 import { type RunSummary, status, summarizeRun } from "../services/summary.ts";
 import { JSON_ARG, mark, printJson } from "./cli-kit.ts";
 import { defaultDeps } from "./deps.ts";
@@ -15,6 +16,15 @@ import { defaultDeps } from "./deps.ts";
 const json = JSON_ARG;
 const n = (x: number) => x.toLocaleString("en-US");
 
+/** A session's heading in `runs list` and `status` (spec §4): `● live  <name>` or `· idle  <name>`. */
+export function sessionHeading(s: RunSession | null): string {
+  return s ? `session ${s.live ? "● live" : "· idle"}  ${s.name}` : "earlier runs";
+}
+
+/** How a run moved between sessions, after its line: `(continued here)`, `(continued in <name>)`. */
+const movedNote = (g: SessionGroup["runs"][number]): string =>
+  g.continued === "here" ? "  (continued here)" : g.continuedIn ? `  (continued in ${g.continuedIn})` : "";
+
 /** One run at a glance: what is live, what finished, spend against the budget, landed milestones. */
 export function formatRun(s: RunSummary, now: number = Date.now()): string[] {
   const t = s.totals;
@@ -22,6 +32,7 @@ export function formatRun(s: RunSummary, now: number = Date.now()): string[] {
     `run ${s.id}  ${s.title}`,
     `  repo ${s.repo} · started ${s.createdAt} · ${Math.round((now - Date.parse(s.createdAt)) / 60_000)} min`,
   ];
+  for (const q of s.questions) lines.push(`  ${mark("warn")} parked ${q.milestone}: ${q.question}`);
   for (const l of s.live) lines.push(`  live ${l.name}  ${l.rung}  ${l.state} ${l.secs}s`);
   lines.push(
     `  done ${t.runs} role run(s), ${t.ok} ok${t.notOk.length ? `; not ok: ${t.notOk.join(", ")}` : ""}`,
@@ -37,6 +48,10 @@ export function formatRun(s: RunSummary, now: number = Date.now()): string[] {
   if (s.budget) lines.push(`  budget ${formatBudget(s.budget)}`);
   if (s.jev.decisions) lines.push(`  jev ${s.jev.decisions} decision(s), ${s.jev.fallbacks} fallback(s)`);
   for (const m of s.milestones) lines.push(`  landed ${m}`);
+  if (s.verifier)
+    lines.push(
+      `  verifier step ${s.verifier.item}${s.verifier.carried ? " (carried over)" : ""} at ${s.verifier.at.slice(11, 16)}`,
+    );
   for (const l of s.stateTail) lines.push(`  | ${l}`);
   for (const w of s.warnings) lines.push(`  ${mark("warn")} ${w}`);
   return lines;
@@ -48,7 +63,27 @@ function printStatus(runId: string | undefined, asJson: boolean): void {
   const r = redact(status(defaultDeps(), runId));
   if (asJson) return printJson(r);
   if (r.runs.length === 0) console.log("no runs yet");
-  for (const s of r.runs) for (const l of formatRun(s)) console.log(l);
+  // grouped by session, as the runs page is (spec §4); a run shows once, under the session that started it
+  const byId = new Map(r.runs.map((s) => [s.id, s]));
+  const runs = r.runs.flatMap((s) => {
+    try {
+      return [findRun(s.id)];
+    } catch {
+      return [];
+    }
+  });
+  for (const g of groupRuns(runs)) {
+    const own = g.runs.filter((x) => x.continued !== "here");
+    if (own.length === 0) continue;
+    console.log(sessionHeading(g.session));
+    for (const x of own) {
+      const s = byId.get(x.run.id);
+      if (!s) continue;
+      const [head, ...rest] = formatRun(s);
+      console.log(`${head}${movedNote(x)}`);
+      for (const l of rest) console.log(l);
+    }
+  }
   for (const w of r.warnings) console.log(`${mark("warn")} ${w}`);
 }
 
@@ -124,25 +159,33 @@ const list = defineCommand({
         fix: "pass a path inside the repo, or leave out --repo",
       });
     const { runs, corrupt } = listRuns();
-    const rows = runs
-      .filter((r) => !args.repo || r.meta.repo === top)
-      .map((r) => {
-        const s = summarizeRun(defaultDeps(), r);
-        return {
-          id: r.id,
-          title: r.meta.title,
-          repo: r.meta.repo,
-          createdAt: r.meta.createdAt,
-          live: s.live.length,
-          roleRuns: s.totals.runs,
-        };
-      });
-    if (args.json) return printJson({ runs: rows, corrupt });
-    if (rows.length === 0) console.log("no runs yet");
-    for (const r of rows)
-      console.log(
-        `${r.id}  ${r.live ? `${r.live} live` : "idle"}  ${r.roleRuns} role run(s)  ${r.title}  ${r.repo}`,
-      );
+    const shown = runs.filter((r) => !args.repo || r.meta.repo === top);
+    const deps = defaultDeps();
+    const row = (r: Run) => {
+      const s = summarizeRun(deps, r);
+      return {
+        id: r.id,
+        title: r.meta.title,
+        repo: r.meta.repo,
+        createdAt: r.meta.createdAt,
+        live: s.live.length,
+        roleRuns: s.totals.runs,
+        session: s.session,
+        continuedIn: s.continuedIn,
+      };
+    };
+    const groups = groupRuns(shown);
+    if (args.json) return printJson({ runs: shown.map(row), corrupt });
+    if (shown.length === 0) console.log("no runs yet");
+    for (const g of groups) {
+      console.log(sessionHeading(g.session));
+      for (const x of g.runs) {
+        const r = row(x.run);
+        console.log(
+          `  ${r.id}  ${r.live ? `${r.live} live` : "idle"}  ${r.roleRuns} role run(s)  ${r.title}  ${r.repo}${movedNote(x)}`,
+        );
+      }
+    }
     for (const c of corrupt) console.log(`${mark("warn")} skipped run ${c.id}: ${c.reason}`);
   },
 });

package/src/entry/tui/commands.ts

@@ -314,7 +314,7 @@ export const COMMANDS = [
   },
   {
     id: "runs.open",
-    title: "Open the run",
+    title: "Open the session, milestone or role",
     group: "Runs",
     scope: "row.runs",
     keys: ["return"],

package/src/entry/tui/effects.ts

@@ -1,4 +1,4 @@
-import { statSync } from "node:fs";
+import { realpathSync, statSync, watch } from "node:fs";
 import { adapterFor } from "../../adapters/registry.ts";
 import "../../adapters/all.ts";
 import { agentFiles } from "../../domain/agents.ts";
@@ -6,7 +6,6 @@ import type { Catalog } from "../../domain/catalog.ts";
 import { HARNESS_KEYS, type Profile, type ProfileDoc, type ProfilePatch } from "../../domain/profile.ts";
 import { type Validation, validateProfile } from "../../domain/profile-rules.ts";
 import type { Access } from "../../domain/record.ts";
-import type { RouteSource } from "../../domain/route.ts";
 import { VERSION } from "../../infra/version.ts";
 import {
   type CatalogModel,
@@ -37,13 +36,32 @@ import {
   readProjects,
   runnableBackends,
 } from "../../services/profile-store.ts";
-import { findRun, listRuns, readRoutes, type Run, runPaths } from "../../services/run-store.ts";
+import { listRuns, type Run, runPaths } from "../../services/run-store.ts";
+import {
+  type MilestoneDetail,
+  milestoneDetail,
+  type RoleDetail,
+  roleDetail,
+  type SessionDetail,
+  sessionDetail,
+  type SessionRow,
+  sessionRows,
+} from "../../services/runs-page.ts";
 import { type RunSummary, summarizeRun } from "../../services/summary.ts";
 import { defaultDeps } from "../deps.ts";
 import { mcpHandshake } from "../mcp/handshake.ts";
 
 /** A save refused because the profile changed on disk since its preview read it carries this path. */
 export { CHANGED_ON_DISK } from "../../services/profile-service.ts";
+export type {
+  Milestone,
+  MilestoneDetail,
+  RoleDetail,
+  RoleRow,
+  SessionDetail,
+  SessionRow,
+  SessionRun,
+} from "../../services/runs-page.ts";
 
 /** One line of the run list. */
 export interface RunRow {
@@ -56,31 +74,8 @@ export interface RunRow {
   landed: number;
   /** the budget's spent fraction, null without a cap */
   budget: number | null;
-}
-
-interface Climb {
-  lane: string;
-  from: string;
-  to: string;
-  reason: string;
-  /** the environment's fault (a limit, a missing service), not the rung's */
-  env: boolean;
-}
-
-interface Decision {
-  lane: string;
-  role: string;
-  source: RouteSource;
-  kind: string | null;
-  difficulty: string | null;
-  rung: string;
-}
-
-/** Spec §9.1's run view: live lanes, climbs, Jev decisions, budget, landed milestones. */
-export interface RunDetail {
-  summary: RunSummary;
-  climbs: Climb[];
-  decisions: Decision[];
+  /** the session that started it (the Runs tab opens it); null for a run from before 1.1 */
+  session: string | null;
 }
 
 /**
@@ -91,7 +86,19 @@ export interface Effects {
   version: string;
   doctor(): Promise<DoctorReport>;
   runs(): { rows: RunRow[]; warnings: string[] };
-  run(id: string): RunDetail;
+  /** spec §4: the Runs tab's top level, the sessions */
+  sessions(): { rows: SessionRow[]; warnings: string[] };
+  /** a session's screen; `key` null is "earlier runs" */
+  session(key: string | null): SessionDetail;
+  /** a role's screen */
+  role(run: string, dispatchId: string): RoleDetail;
+  /** spec 1.1 §10: a milestone's screen, its digest */
+  milestone(run: string, name: string): MilestoneDetail;
+  /**
+   * calls `onChange` when a file under one of `dirs` changes (spec §4: the open screen redraws when a run file
+   * changes); null when they cannot be watched here, and the screen polls every second instead
+   */
+  watch(dirs: string[], onChange: () => void): (() => void) | null;
   /** stops a live role; resolves to the line the toast shows */
   cancel(run: string, name: string): Promise<string>;
   profiles(): {
@@ -193,33 +200,67 @@ export function rowOf(s: RunSummary): RunRow {
     roleRuns: s.totals.runs,
     landed: s.milestones.length,
     budget: s.budget?.fraction ?? null,
+    session: s.session?.sessionId ?? null,
   };
 }
 
-/** The climbs and route decisions in a run's routes.jsonl. */
-function routesOf(run: Run): { climbs: Climb[]; decisions: Decision[] } {
-  const rows = readRoutes(run);
-  return {
-    climbs: rows
-      .filter((r) => r.source === "climb" && r.from !== null)
-      .map((r) => ({
-        lane: r.lane,
-        from: r.from as string,
-        to: r.rung,
-        reason: r.reason ?? "",
-        env: r.env === true,
-      })),
-    decisions: rows
-      .filter((r) => r.source === "route")
-      .map((r) => ({
-        lane: r.lane,
-        role: r.role,
-        source: r.decidedBy,
-        kind: r.kind,
-        difficulty: r.difficulty,
-        rung: r.rung,
-      })),
+/** How long a burst of file events is gathered into one redraw. */
+const WATCH_SETTLE_MS = 100;
+
+/** What `watchDirs` watches and times with; tests pass fakes. */
+export interface WatchPorts {
+  watch(dir: string, fire: () => void): { on(event: "error", f: () => void): unknown; close(): void };
+  setTimeout(f: () => void, ms: number): unknown;
+  clearTimeout(h: unknown): void;
+  /** the folder's real path: macOS reports FSEvents under it (/var is /private/var) */
+  realpath(dir: string): string;
+}
+
+const LIVE_WATCH: WatchPorts = {
+  watch: (dir, fire) => watch(dir, { recursive: true }, fire),
+  setTimeout: (f, ms) => setTimeout(f, ms),
+  clearTimeout: (h) => clearTimeout(h as ReturnType<typeof setTimeout>),
+  realpath: (dir) => realpathSync(dir),
+};
+
+/**
+ * `fs.watch` on each run folder's real path, recursive; null when any of them cannot be watched. After the
+ * returned stop, `onChange` is never called, even for an event already queued.
+ */
+export function watchDirs(
+  dirs: string[],
+  onChange: () => void,
+  ports: Partial<WatchPorts> = {},
+): (() => void) | null {
+  const io = { ...LIVE_WATCH, ...ports };
+  const watchers: { close(): void }[] = [];
+  let timer: unknown = null;
+  let stopped = false;
+  const fire = () => {
+    if (stopped || timer !== null) return;
+    timer = io.setTimeout(() => {
+      timer = null;
+      if (!stopped) onChange();
+    }, WATCH_SETTLE_MS);
   };
+  const stop = () => {
+    stopped = true;
+    if (timer !== null) io.clearTimeout(timer);
+    timer = null;
+    for (const w of watchers) w.close();
+  };
+  try {
+    for (const d of dirs) {
+      const w = io.watch(io.realpath(d), fire);
+      // a watcher that breaks later (the folder removed) just stops; the screen's slow poll still reads
+      w.on("error", () => w.close());
+      watchers.push(w);
+    }
+  } catch {
+    stop();
+    return null;
+  }
+  return stop;
 }
 
 /**
@@ -238,10 +279,11 @@ export function liveEffects(repo: string | null = null): Effects {
       const { runs, corrupt } = listRuns();
       return { rows: rows(runs), warnings: corrupt.map((c) => `skipped run ${c.id}: ${c.reason}`) };
     },
-    run(id) {
-      const run = findRun(id);
-      return { summary: summarizeRun(deps, run), ...routesOf(run) };
-    },
+    sessions: () => sessionRows(deps),
+    session: (key) => sessionDetail(deps, key),
+    role: (run, dispatchId) => roleDetail(deps, run, dispatchId),
+    milestone: (run, name) => milestoneDetail(run, name),
+    watch: watchDirs,
     async cancel(run, name) {
       const r = await cancel(deps, run, name);
       return `${r.record.name} ${r.record.status}`;