catherd-cli 1.0.0 → 1.1.1

package/src/entry/tui/fixtures.ts

@@ -8,9 +8,18 @@ import {
 } from "../../domain/profile.ts";
 import { validateProfile } from "../../domain/profile-rules.ts";
 import { catalogQuery, loadCatalog } from "../../services/catalog-service.ts";
+import type { RunRecord } from "../../domain/record.ts";
 import type { DoctorReport } from "../../services/doctor.ts";
 import type { RunSummary } from "../../services/summary.ts";
-import { CHANGED_ON_DISK, type Effects, type RunDetail, type RunRow, rowOf } from "./effects.ts";
+import {
+  CHANGED_ON_DISK,
+  type Effects,
+  type RoleDetail,
+  type RoleRow,
+  rowOf,
+  type SessionRow,
+  type SessionRun,
+} from "./effects.ts";
 import { withStaged } from "./profile-tree.ts";
 
 /**
@@ -70,6 +79,8 @@ export const FIXTURE_REPORT: DoctorReport = {
 const summary = (o: Partial<RunSummary> & Pick<RunSummary, "id" | "title">): RunSummary => ({
   repo: "/home/me/app",
   createdAt: "2026-09-26T11:48:00.000Z",
+  session: null,
+  continuedIn: null,
   stateTail: [],
   live: [],
   totals: {
@@ -85,93 +96,294 @@ const summary = (o: Partial<RunSummary> & Pick<RunSummary, "id" | "title">): Run
   harness: [],
   budget: null,
   milestones: [],
+  verifier: null,
+  questions: [],
   warnings: [],
   ...o,
 });
 
-const FIXTURE_RUNS: RunDetail[] = [
-  {
-    summary: summary({
-      id: "20260926-114800-jobs-screen",
-      title: "Jobs screen",
-      stateTail: ["M1 in review", "Next: fix round for M1.L2"],
-      live: [
-        {
-          name: "worker-M1.L2",
-          rung: "codex:gpt-6-sol#medium",
-          state: "running",
-          secs: 252,
-          dispatchId: "d2",
-        },
-        { name: "reviewer-M1", rung: "codex:gpt-6-sol#high", state: "starting", secs: 4, dispatchId: "d3" },
-      ],
-      totals: {
-        runs: 3,
-        ok: 3,
-        notOk: [],
-        tokens: { input: 812_000, cached: 640_000, output: 41_000 },
-        costUsd: 0,
-        wallMinutes: 12,
-      },
-      jev: { decisions: 2, fallbacks: 0 },
-      budget: { fraction: 0.52, minutes: { spent: 31, cap: 60 } },
-      milestones: ["M0 | scaffold the jobs screen | 3f2a9c1 | 9 | bun test test/jobs"],
-    }),
-    climbs: [
+const JOBS = "20260926-114800-jobs-screen";
+const AUTH = "20260925-090000-auth-refactor";
+const PLAN4 = "20260924-080000-auth-plan-4";
+
+const FIXTURE_RUNS: RunSummary[] = [
+  summary({
+    id: JOBS,
+    title: "Jobs screen",
+    session: { sessionId: "s-jobs", hostSessionId: null, name: "jobs screen", live: true },
+    stateTail: ["M1 in review", "Next: fix round for M1.L2"],
+    live: [
       {
-        lane: "M1.L2",
-        from: "codex:gpt-6-luna#high",
-        to: "codex:gpt-6-sol#medium",
-        reason: "refused",
-        env: false,
+        name: "worker-M1.L2",
+        rung: "codex:gpt-6-sol#medium",
+        state: "running",
+        secs: 252,
+        dispatchId: "d2",
       },
+      { name: "reviewer-M1", rung: "codex:gpt-6-sol#high", state: "starting", secs: 4, dispatchId: "d3" },
     ],
-    decisions: [
-      {
-        lane: "M1.L1",
-        role: "worker",
-        source: "lane",
-        kind: "repo_code",
-        difficulty: "copy",
-        rung: "codex:gpt-6-luna#high",
-      },
+    totals: {
+      runs: 3,
+      ok: 3,
+      notOk: [],
+      tokens: { input: 812_000, cached: 640_000, output: 41_000 },
+      costUsd: 0,
+      wallMinutes: 12,
+    },
+    jev: { decisions: 2, fallbacks: 0 },
+    budget: { fraction: 0.52, minutes: { spent: 31, cap: 60 } },
+    milestones: ["M0 | scaffold the jobs screen | 3f2a9c1 | 9 | bun test test/jobs"],
+  }),
+  summary({
+    id: AUTH,
+    title: "Auth refactor",
+    repo: "/home/me/api",
+    createdAt: "2026-09-25T09:00:00.000Z",
+    session: { sessionId: "s-auth", hostSessionId: null, name: "auth build", live: false },
+    continuedIn: "kit follow-up",
+    stateTail: ["Next: done"],
+    totals: {
+      runs: 9,
+      ok: 8,
+      notOk: ["worker-M2.L1 (limit)"],
+      tokens: { input: 3_100_000, cached: 2_400_000, output: 160_000 },
+      costUsd: 1.84,
+      wallMinutes: 96,
+    },
+    milestones: ["M1 | tokens | a1 | 30 | ok", "M2 | sessions | b2 | 41 | ok", "M3 | cleanup | c3 | 25 | ok"],
+  }),
+];
+
+/** A role of the fixtures; `since` minutes before the fixed clock (2026-09-26 12:00 UTC) for a live one. */
+const role = (o: Partial<RoleRow> & Pick<RoleRow, "run" | "dispatchId" | "name" | "rung">): RoleRow => ({
+  role: o.name.split("-")[0] ?? "worker",
+  status: "ok",
+  live: false,
+  since: "2026-09-26T11:48:10.000Z",
+  secs: null,
+  lastEvent: null,
+  replyStatus: "complete",
+  ...o,
+});
+
+const auth = (continued: SessionRun["continued"]): SessionRun => ({
+  id: AUTH,
+  title: "Auth refactor",
+  repo: "/home/me/api",
+  createdAt: "2026-09-25T09:00:00.000Z",
+  continued,
+  continuedIn: continued === "elsewhere" ? "kit follow-up" : null,
+  budget: null,
+  milestones: [
+    { name: "M1", landed: true, what: "tokens" },
+    { name: "M2", landed: true, what: "sessions" },
+    { name: "M3", landed: true, what: "cleanup" },
+  ],
+  roles: [
+    role({ run: AUTH, dispatchId: "a3", name: "reviewer-M3", rung: "codex:gpt-6-sol#high", secs: 188 }),
+    role({ run: AUTH, dispatchId: "a2", name: "worker-M3.L1", rung: "codex:gpt-6-luna#high", secs: 402 }),
+    role({
+      run: AUTH,
+      dispatchId: "a1",
+      name: "worker-M2.L1",
+      rung: "codex:gpt-6-sol#medium",
+      status: "limit",
+      secs: 95,
+      replyStatus: null,
+    }),
+  ],
+});
+
+/** The Runs tab's sessions: a live one with three live roles, one whose run another session continued, and it. */
+export const FIXTURE_SESSIONS: { row: SessionRow; runs: SessionRun[] }[] = [
+  {
+    row: {
+      key: "s-jobs",
+      name: "jobs screen",
+      live: true,
+      runs: 1,
+      liveRoles: 3,
+      landed: 1,
+      lastActivity: "2026-09-26T11:59:40.000Z",
+    },
+    runs: [
       {
-        lane: "M1.L2",
-        role: "worker",
-        source: "lane",
-        kind: "repo_code",
-        difficulty: "build",
-        rung: "codex:gpt-6-luna#high",
+        id: JOBS,
+        title: "Jobs screen",
+        repo: "/home/me/app",
+        createdAt: "2026-09-26T11:48:00.000Z",
+        continued: null,
+        continuedIn: null,
+        budget: 0.52,
+        milestones: [
+          { name: "M0", landed: true, what: "scaffold the jobs screen" },
+          { name: "M1", landed: false, what: "" },
+        ],
+        roles: [
+          role({
+            run: JOBS,
+            dispatchId: "d2",
+            name: "worker-M1.L2",
+            rung: "codex:gpt-6-sol#medium",
+            status: "running",
+            live: true,
+            since: "2026-09-26T11:55:48.000Z",
+            lastEvent: "$ bun test test/jobs --bail",
+            replyStatus: null,
+          }),
+          role({
+            run: JOBS,
+            dispatchId: "d4",
+            name: "worker-M1.L3",
+            rung: "codex:gpt-6-luna#high",
+            status: "running",
+            live: true,
+            since: "2026-09-26T11:57:00.000Z",
+            lastEvent: "edit src/jobs/list.tsx",
+            replyStatus: null,
+          }),
+          role({
+            run: JOBS,
+            dispatchId: "d3",
+            name: "reviewer-M1",
+            rung: "codex:gpt-6-sol#high",
+            status: "starting",
+            live: true,
+            since: "2026-09-26T11:59:56.000Z",
+            replyStatus: null,
+          }),
+          role({
+            run: JOBS,
+            dispatchId: "d1",
+            name: "worker-M1.L1",
+            rung: "codex:gpt-6-luna#high",
+            secs: 312,
+          }),
+        ],
       },
     ],
   },
   {
-    summary: summary({
-      id: "20260925-090000-auth-refactor",
-      title: "Auth refactor",
-      repo: "/home/me/api",
-      createdAt: "2026-09-25T09:00:00.000Z",
-      stateTail: ["Next: done"],
-      totals: {
-        runs: 9,
-        ok: 8,
-        notOk: ["worker-M2.L1 (limit)"],
-        tokens: { input: 3_100_000, cached: 2_400_000, output: 160_000 },
-        costUsd: 1.84,
-        wallMinutes: 96,
+    row: {
+      key: "s-kit",
+      name: "kit follow-up",
+      live: false,
+      runs: 1,
+      liveRoles: 0,
+      landed: 3,
+      lastActivity: "2026-09-25T11:20:00.000Z",
+    },
+    runs: [auth("here")],
+  },
+  {
+    row: {
+      key: "s-auth",
+      name: "auth build",
+      live: false,
+      runs: 2,
+      liveRoles: 0,
+      landed: 5,
+      lastActivity: "2026-09-25T10:36:00.000Z",
+    },
+    runs: [
+      auth("elsewhere"),
+      {
+        id: PLAN4,
+        title: "Auth plan 4",
+        repo: "/home/me/api",
+        createdAt: "2026-09-24T08:00:00.000Z",
+        continued: null,
+        continuedIn: null,
+        budget: null,
+        milestones: [
+          { name: "M1", landed: true, what: "schema" },
+          { name: "M2", landed: true, what: "handlers" },
+        ],
+        roles: [
+          role({
+            run: PLAN4,
+            dispatchId: "p2",
+            name: "reviewer-M2",
+            rung: "codex:gpt-6-sol#high",
+            secs: 140,
+          }),
+          role({
+            run: PLAN4,
+            dispatchId: "p1",
+            name: "worker-M2.L1",
+            rung: "codex:gpt-6-sol#medium",
+            secs: 610,
+          }),
+        ],
       },
-      milestones: [
-        "M1 | tokens | a1 | 30 | ok",
-        "M2 | sessions | b2 | 41 | ok",
-        "M3 | cleanup | c3 | 25 | ok",
-      ],
-    }),
-    climbs: [],
-    decisions: [],
+    ],
   },
 ];
 
-const fixtureRow = (d: RunDetail): RunRow => rowOf(d.summary);
+/** The role screen's text: the brief, the reply and the record behind worker-M1.L1 of the jobs screen. */
+const FIXTURE_ROLE: Omit<RoleDetail, "run" | "runTitle" | "dispatchId" | "name" | "role" | "rung" | "state"> =
+  {
+    brief:
+      "Read /home/me/.local/share/catherd/runs/jobs-screen/lanes/M1.L1.md\nFast check: bun test test/jobs/list",
+    reply:
+      "Done: the list renders every job with its state.\nsrc/jobs/list.tsx:12 — the list\nsrc/jobs/list.test.tsx:4 — its test\nSTATUS: complete — list in place, fast check green",
+    record: null,
+  };
+
+/** The digest `land` writes for M0 of the jobs screen (spec 1.1 §10): what a landed milestone's screen shows. */
+export const FIXTURE_DIGEST = [
+  "# M0 — scaffold the jobs screen",
+  "",
+  "Commit 3f2a9c1 · 9 min · landed 2026-09-26T11:57:00.000Z",
+  "A-lines: A1 the jobs screen lists every job with its state",
+  "",
+  "Lanes:",
+  "- M0.L1 · codex:gpt-6-luna#high",
+  "- M0.L2 · codex:gpt-6-luna#medium → codex:gpt-6-sol#medium · climbs: fast check red twice",
+  "",
+  "Reviewer: reviewer-M0 · 1 finding(s): 0 BLOCKER, 0 BUG, 1 NIT",
+  "Verifier: PASS (verifier-M0)",
+  "Evidence: bun test test/jobs",
+  "Tokens: 1204k in (960k cached) · 58k out · Claude subagents 31k (reported)",
+  "",
+].join("\n");
+
+/** The record a finished fixture role would have: what the role screen shows under RECORD. */
+function fixtureRecord(r: SessionRun, x: RoleRow): RunRecord {
+  const start = Date.parse(x.since);
+  return {
+    schema: 1,
+    runId: r.id,
+    dispatchId: x.dispatchId,
+    name: x.name,
+    role: x.role,
+    lane: x.name.includes("-M") && x.name.includes(".") ? x.name.slice(x.name.indexOf("-") + 1) : null,
+    backend: x.rung.slice(0, x.rung.indexOf(":")),
+    rung: x.rung,
+    attempt: 1,
+    failoverFrom: null,
+    thread: "01a0d0d4-d0a6-71a1-983c-82a9169200b4",
+    status: x.status as RunRecord["status"],
+    startedAt: x.since,
+    endedAt: new Date(start + (x.secs ?? 0) * 1000).toISOString(),
+    secs: x.secs ?? 0,
+    exitCode: 0,
+    signal: null,
+    cliVersion: "0.157.0",
+    tokens: { input: 812_000, cached: 640_000, output: 41_000 },
+    costUsd: null,
+    changedOwned: ["src/jobs/list.tsx", "src/jobs/list.test.tsx"],
+    violations: [],
+    replyStatus: x.replyStatus as RunRecord["replyStatus"],
+    replyWhy: x.replyStatus ? "list in place, fast check green" : null,
+    threadHeavy: false,
+    access: "workspace-write",
+    isolated: false,
+    images: [],
+    error: null,
+    replyPath: `roles/${x.name}/${x.dispatchId}/reply.md`,
+  };
+}
 
 const BACKENDS = ["claude", "codex", "claude-code", "opencode"];
 
@@ -179,15 +391,27 @@ const BACKENDS = ["claude", "codex", "claude-code", "opencode"];
  * Effects over the fixtures; profile writes stay in memory and are recorded in `writes`. `repo` is the
  * directory the TUI stands in and `bindings` the repo bindings, as `liveEffects(repo)` reads them.
  */
-export function fixtureEffects(
-  o: {
-    runs?: RunDetail[];
-    report?: DoctorReport;
-    repo?: string;
-    bindings?: Record<string, string>;
-  } = {},
-): Effects & { writes: string[] } {
+export interface FixtureOptions {
+  runs?: RunSummary[];
+  sessions?: { row: SessionRow; runs: SessionRun[] }[];
+  report?: DoctorReport;
+  repo?: string;
+  bindings?: Record<string, string>;
+  /** false: the run folders cannot be watched here, as on a platform without fs.watch */
+  watchable?: boolean;
+}
+
+export function fixtureEffects(o: FixtureOptions = {}): Effects & {
+  writes: string[];
+  /** what a change to a watched run file does: every open watch hears of it */
+  touch(): void;
+  /** the run folders watched now */
+  watched: string[][];
+} {
   const runs = o.runs ?? FIXTURE_RUNS;
+  const sessions = o.sessions ?? FIXTURE_SESSIONS;
+  const listeners = new Set<() => void>();
+  const watched: string[][] = [];
   const docs = new Map<string, ProfileDoc>([["default", defaultProfileDoc()]]);
   let active = "default";
   const bindings = new Map(Object.entries(o.bindings ?? {}));
@@ -213,13 +437,56 @@ export function fixtureEffects(
   };
   return {
     writes,
+    watched,
+    touch: () => {
+      for (const l of listeners) l();
+    },
     version: "1.0.0",
     doctor: async () => o.report ?? FIXTURE_REPORT,
-    runs: () => ({ rows: runs.map(fixtureRow), warnings: [] }),
-    run(id) {
-      const d = runs.find((r) => r.summary.id === id);
-      if (!d) throw new Error(`no run "${id}"`);
-      return d;
+    runs: () => ({ rows: runs.map(rowOf), warnings: [] }),
+    sessions: () => ({ rows: sessions.map((x) => x.row), warnings: [] }),
+    session(key) {
+      const x = sessions.find((y) => y.row.key === key);
+      if (!x) throw new Error(`no session "${key}"`);
+      return { session: x.row, runs: x.runs, dirs: x.runs.map((r) => `/runs/${r.id}`) };
+    },
+    role(run, dispatchId) {
+      for (const x of sessions)
+        for (const r of x.runs) {
+          const role = r.id === run ? r.roles.find((y) => y.dispatchId === dispatchId) : undefined;
+          if (!role) continue;
+          return {
+            run,
+            runTitle: r.title,
+            dispatchId,
+            name: role.name,
+            role: role.role,
+            rung: role.rung,
+            state: role.live ? role.status : "finished",
+            brief: FIXTURE_ROLE.brief,
+            reply: role.live ? "" : FIXTURE_ROLE.reply,
+            record: role.live ? null : fixtureRecord(r, role),
+          };
+        }
+      throw new Error(`no dispatch ${dispatchId} in run ${run}`);
+    },
+    milestone(run, name) {
+      for (const x of sessions)
+        for (const r of x.runs) {
+          const m = r.id === run ? r.milestones.find((y) => y.name === name) : undefined;
+          if (!m) continue;
+          return { run, runTitle: r.title, ...m, digest: m.landed ? FIXTURE_DIGEST : null };
+        }
+      throw new Error(`no milestone "${name}" in run ${run}`);
+    },
+    watch(dirs, onChange) {
+      if (o.watchable === false) return null;
+      watched.push(dirs);
+      listeners.add(onChange);
+      return () => {
+        listeners.delete(onChange);
+        watched.splice(watched.indexOf(dirs), 1);
+      };
     },
     async cancel(run, name) {
       writes.push(`cancel ${run} ${name}`);

package/src/entry/tui/profile-edits.ts

@@ -113,12 +113,12 @@ export function failoverOptions(
       if (!(r.enabled || usable(r.rung)) || r.rung.startsWith("claude:")) continue;
       const q = quotaOf(parseRung(r.rung));
       if (q === quota) continue;
-      const inferred = inferredScores(c, rungInfo(c, r.rung)).inferred;
+      const via = inferredScores(c, rungInfo(c, r.rung)).via;
       out.push({
         value: r.rung,
         title: shortRung(r.rung),
         group: m.billing,
-        detail: inferred ? "inferred" : "",
+        detail: via ? `scores borrowed from ${via}` : "",
         current: r.rung === cur,
       });
     }

package/src/entry/tui/profile-tree.ts

@@ -350,7 +350,8 @@ export function buildRows(i: TreeInput): Row[] {
     let mark = "";
     if (to) {
       try {
-        mark = inferredScores(i.catalog, rungInfo(i.catalog, to)).inferred ? " (inferred)" : "";
+        const via = inferredScores(i.catalog, rungInfo(i.catalog, to)).via;
+        mark = via ? ` (scores borrowed from ${via})` : "";
       } catch {
         mark = "";
       }

package/src/entry/tui/providers/data.tsx

@@ -1,7 +1,7 @@
 import { createContext, type ReactNode, useContext, useEffect, useMemo, useRef, useState } from "react";
 import { errorMessage, isCatherdError } from "../../../domain/errors.ts";
 import type { DoctorReport } from "../../../services/doctor.ts";
-import type { Effects, RunRow } from "../effects.ts";
+import type { Effects, RunRow, SessionRow } from "../effects.ts";
 import { useApp } from "./app.tsx";
 
 export interface Polled<T> {
@@ -16,12 +16,14 @@ export interface Polled<T> {
 
 /**
  * Reads `read` now and every `everyMs` while not paused, off the render path (spec §9.4: runs data is
- * polled off the render path): a read runs in a timer callback, never while React renders.
+ * polled off the render path): a read runs in a timer callback, never while React renders. It reads at once
+ * when it mounts, when `key` changes, on `refresh`, when it resumes and when it is turned back on; a new
+ * cadence or a pause only reschedules. `off`: no read at all (the data is not shown).
  */
 export function usePoll<T>(
   read: () => T,
   everyMs: number,
-  o: { paused?: boolean; key?: string } = {},
+  o: { paused?: boolean; key?: string; off?: boolean } = {},
 ): Polled<T> {
   const { clock } = useApp();
   const [state, setState] = useState<{
@@ -33,7 +35,24 @@ export function usePoll<T>(
   const readRef = useRef(read);
   readRef.current = read;
   const [nonce, setNonce] = useState(0);
+  // what the last effect run read for: a read at once is due only when this moves on
+  const last = useRef<{ clock: unknown; key: string | undefined; nonce: number; paused: boolean } | null>(
+    null,
+  );
+  const paused = o.paused ?? false;
   useEffect(() => {
+    if (o.off) {
+      last.current = null;
+      return;
+    }
+    const was = last.current;
+    last.current = { clock, key: o.key, nonce, paused };
+    const now =
+      was === null ||
+      was.clock !== clock ||
+      was.key !== o.key ||
+      was.nonce !== nonce ||
+      (was.paused && !paused);
     const run = () => {
       try {
         setState({ value: readRef.current(), error: null, fix: null, at: clock.now() });
@@ -46,13 +65,13 @@ export function usePoll<T>(
         }));
       }
     };
-    const first = clock.setTimeout(run, 0);
-    const every = o.paused ? null : clock.setInterval(run, everyMs);
+    const first = now ? clock.setTimeout(run, 0) : null;
+    const every = paused ? null : clock.setInterval(run, everyMs);
     return () => {
-      clock.clearTimeout(first);
+      if (first !== null) clock.clearTimeout(first);
       if (every !== null) clock.clearInterval(every);
     };
-  }, [clock, everyMs, o.paused, o.key, nonce]);
+  }, [clock, everyMs, paused, o.key, o.off, nonce]);
   return { ...state, refresh: () => setNonce((n) => n + 1) };
 }
 
@@ -71,6 +90,8 @@ export interface Data {
   checkError: string | null;
   recheck(): void;
   runs: Polled<{ rows: RunRow[]; warnings: string[] }>;
+  /** spec §4: the Runs tab's sessions, read on the runs' cadence while their list is shown */
+  sessions: Polled<{ rows: SessionRow[]; warnings: string[] }>;
   /** the profile names and the active one; read on the runs' cadence and after every profile write */
   profiles: Polled<ReturnType<Effects["profiles"]>>;
 }
@@ -115,6 +136,11 @@ export function DataProvider(props: { children: ReactNode }) {
     };
   }, [app.effects, app.clock, nonce]);
   const runs = usePoll(() => app.effects.runs(), RUNS_EVERY_MS, { paused: app.state.paused });
+  // spec §9.4: reading the sessions scans every run, so only while their list is on screen
+  const sessions = usePoll(() => app.effects.sessions(), RUNS_EVERY_MS, {
+    paused: app.state.paused,
+    off: app.state.tab !== "runs" || app.state.session !== null,
+  });
   // cheap (a directory listing and two small reads), and another terminal may change them at any time
   const profiles = usePoll(() => app.effects.profiles(), RUNS_EVERY_MS);
   const value = useMemo(
@@ -125,9 +151,10 @@ export function DataProvider(props: { children: ReactNode }) {
       checkError,
       recheck: () => setNonce((n) => n + 1),
       runs,
+      sessions,
       profiles,
     }),
-    [report, checking, checkedAt, checkError, runs, profiles],
+    [report, checking, checkedAt, checkError, runs, sessions, profiles],
   );
   return <DataContext.Provider value={value}>{props.children}</DataContext.Provider>;
 }

package/src/entry/tui/run.tsx

@@ -10,6 +10,16 @@ import { liveEffects } from "./effects.ts";
 import { fixtureEffects } from "./fixtures.ts";
 import { createAppKeymap } from "./providers/keymap.tsx";
 import { Providers } from "./providers/root.tsx";
+
+/**
+ * OpenTUI's SystemClock counts from process start (performance.now), but the pages compare its time with the
+ * wall-clock timestamps catherd writes (admittedAt, createdAt, lastActivity), so it must be epoch milliseconds.
+ */
+export class WallClock extends SystemClock {
+  override now(): number {
+    return Date.now();
+  }
+}
 import { initialState, type Tab } from "./state.ts";
 import { detectUi, type ThemeMode } from "./theme.ts";
 import { App } from "./views/app.tsx";
@@ -72,7 +82,7 @@ export async function openTui(o: TuiOptions): Promise<number> {
         keybinds={keybinds}
         keymap={createAppKeymap(renderer)}
         effects={effects}
-        clock={new SystemClock()}
+        clock={new WallClock()}
         initial={initialState(o.tab ?? "status")}
         copy={(text) => renderer.copyToClipboardOSC52(text)}
         onExit={(code, kept) => {