@osolmaz/pi-workflows 0.12.1 → 0.13.0

package/src/viewer/cli.ts

@@ -3,10 +3,10 @@ import fs, { realpathSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { SqliteControllerStore } from "../controllers/sqlite.js";
-import { projectControllerStoreBaseDir } from "../controllers/store.js";
 import { syncHerdrPlugin } from "../herdr/setup.js";
 import { sanitizeText } from "../render/ansi.js";
-import { listRunBundles, readRunBundle, workflowRunsBaseDir } from "../workflows/store.js";
+import { StateDatabase } from "../state/database.js";
+import { WorkflowRunStore, workflowStateDatabasePath } from "../workflows/store.js";
 import {
   formatDuration,
   renderRunDetailLines,
@@ -19,28 +19,17 @@ import { runViewer } from "./tui.js";
 const USAGE = `pi-workflows — workflow runs and controller resources
 
 Usage:
-  pi-workflows view [runId] [--dir <runsDir>] [--once]
-  pi-workflows runs [--dir <runsDir>]
-  pi-workflows controllers [--controller-dir <dir>]
-  pi-workflows controller <controller> <key> [--controller-dir <dir>]
+  pi-workflows view [runId] [--once]
+  pi-workflows runs
+  pi-workflows controllers
+  pi-workflows controller <controller> <key>
+  pi-workflows state status|verify
+  pi-workflows state backup <destination>
   pi-workflows host [--project <dir>] [-- <extra pi args>]
   pi-workflows herdr sync [--json]
   pi-workflows herdr setup [--json]
 
-Commands:
-  view          Open the live workflow TUI. With --once, print a snapshot.
-  runs          List recent workflow runs.
-  controllers   List durable controller resources.
-  controller    Show one resource, its effects, child workflows, and events.
-  host          Run the always-on workflow host in the foreground.
-  herdr         Synchronize the bundled Herdr plugin. setup is an alias for sync.
-
-Options:
-  --dir <runsDir>          Runs directory (default: ~/.pi/agent/workflows/runs)
-  --controller-dir <dir>  Controller directory (default: project-scoped local store)
-  --once                   Render once without the interactive TUI
-  --project <dir>          Project directory for the host (default: cwd)
-  --json                   Print a versioned JSON result for herdr sync
+All commands use ~/.pi/agent/workflows/state.sqlite.
 `;
 
 export type CliArgs = {
@@ -49,8 +38,8 @@ export type CliArgs = {
   controllerName?: string;
   resourceKey?: string;
   herdrAction?: string;
-  dir: string;
-  controllerDir: string;
+  stateAction?: "status" | "verify" | "backup";
+  backupDestination?: string;
   once: boolean;
   json: boolean;
   project?: string | undefined;
@@ -60,123 +49,114 @@ export type CliArgs = {
 export function parseCliArgs(argv: string[]): CliArgs {
   const args = [...argv];
   const command = args[0] && !args[0].startsWith("-") ? (args.shift() as string) : "view";
-  let dir = workflowRunsBaseDir();
-  let controllerDir = projectControllerStoreBaseDir(process.cwd());
   let once = false;
   let json = false;
-  const positionals: string[] = [];
   let project: string | undefined;
+  const positionals: string[] = [];
   const piArgs: string[] = [];
 
   while (args.length > 0) {
     const arg = args.shift() as string;
-    if (arg === "--dir") {
-      dir = requiredValue(args, "--dir");
-    } else if (arg === "--controller-dir") {
-      controllerDir = requiredValue(args, "--controller-dir");
-    } else if (arg === "--project") {
-      project = requiredValue(args, "--project");
-    } else if (arg === "--once") {
-      once = true;
-    } else if (arg === "--json") {
-      json = true;
-    } else if (arg === "--help" || arg === "-h") {
-      return { command: "help", dir, controllerDir, once, json };
-    } else if (arg === "--") {
-      piArgs.push(...args.splice(0));
-    } else if (arg.startsWith("-")) {
-      throw new Error(`Unknown argument: ${arg}`);
-    } else {
-      positionals.push(arg);
-    }
-  }
-
-  if (command !== "herdr" && json) {
-    throw new Error("--json is available only for herdr sync");
-  }
-
-  if (command === "host") {
-    return { command, dir, controllerDir, once, json, project, piArgs };
+    if (arg === "--project") project = requiredValue(args, "--project");
+    else if (arg === "--once") once = true;
+    else if (arg === "--json") json = true;
+    else if (arg === "--help" || arg === "-h") return { command: "help", once, json };
+    else if (arg === "--") piArgs.push(...args.splice(0));
+    else if (arg.startsWith("-")) throw new Error(`Unknown argument: ${arg}`);
+    else positionals.push(arg);
   }
 
+  if (command !== "herdr" && json) throw new Error("--json is available only for herdr sync");
+  if (command === "host") return { command, once, json, project, piArgs };
   if (command === "controller") {
-    if (positionals.length !== 2) {
-      throw new Error("controller requires <controller> and <key>");
-    }
+    if (positionals.length !== 2) throw new Error("controller requires <controller> and <key>");
     return {
       command,
       controllerName: positionals[0] as string,
       resourceKey: positionals[1] as string,
-      dir,
-      controllerDir,
       once,
       json,
     };
   }
+  if (command === "state") {
+    const action = positionals[0];
+    if (action !== "status" && action !== "verify" && action !== "backup") {
+      throw new Error("state requires status, verify, or backup");
+    }
+    if (action === "backup") {
+      if (positionals.length !== 2) throw new Error("state backup requires <destination>");
+      return {
+        command,
+        stateAction: action,
+        backupDestination: positionals[1] as string,
+        once,
+        json,
+      };
+    }
+    if (positionals.length !== 1) throw new Error(`state ${action} accepts no other arguments`);
+    return { command, stateAction: action, once, json };
+  }
   if (command === "herdr") {
-    if (positionals.length !== 1 || (positionals[0] !== "sync" && positionals[0] !== "setup")) {
+    if (positionals.length !== 1 || !["sync", "setup"].includes(positionals[0] as string)) {
       throw new Error("herdr requires the sync action");
     }
-    return { command, herdrAction: positionals[0], dir, controllerDir, once, json };
-  }
-  if (positionals.length > 1) {
-    throw new Error(`Unexpected argument: ${positionals[1]}`);
+    return { command, herdrAction: positionals[0] as string, once, json };
   }
+  if (positionals.length > 1) throw new Error(`Unexpected argument: ${positionals[1]}`);
   return {
     command,
-    ...(positionals[0] !== undefined ? { runId: positionals[0] } : {}),
-    dir,
-    controllerDir,
+    ...(positionals[0] === undefined ? {} : { runId: positionals[0] }),
     once,
     json,
   };
 }
 
-async function printRuns(dir: string): Promise<void> {
-  const bundles = await listRunBundles(dir);
-  if (bundles.length === 0) {
-    process.stdout.write(`No workflow runs found in ${dir}\n`);
-    return;
-  }
-  for (const bundle of bundles) {
-    const state = bundle.state;
-    const title = state.runTitle ? ` — ${sanitizeText(state.runTitle)}` : "";
-    process.stdout.write(
-      `${statusLabel(state.status)}  ${sanitizeText(state.workflowName)}${title}  ${state.runId}  ${formatDuration(
-        runElapsedMs(state),
-      )}\n`,
-    );
+function printRuns(databasePath: string): void {
+  const store = new WorkflowRunStore(databasePath, { readOnly: true });
+  try {
+    const runs = store.listRuns();
+    if (runs.length === 0) {
+      process.stdout.write("No workflow runs found.\n");
+      return;
+    }
+    for (const run of runs) {
+      const state = run.state;
+      const title = state.runTitle ? ` — ${sanitizeText(state.runTitle)}` : "";
+      process.stdout.write(
+        `${statusLabel(state.status)}  ${sanitizeText(state.workflowName)}${title}  ${state.runId}  ${formatDuration(runElapsedMs(state))}\n`,
+      );
+    }
+  } finally {
+    store.close();
   }
 }
 
-async function printOnce(dir: string, runId: string | undefined): Promise<void> {
-  const bundles = await listRunBundles(dir);
-  const size = { width: process.stdout.columns ?? 100, height: 1_000 };
-  if (runId === undefined) {
-    process.stdout.write(`${renderRunListLines(bundles, 0, size).join("\n")}\n`);
-    return;
-  }
-  const match = bundles.find((bundle) => bundle.state.runId === runId);
-  if (!match) {
-    throw new Error(`Run not found: ${runId}`);
-  }
-  const bundle = await readRunBundle(match.runDir, { includeTrace: true });
-  if (!bundle) {
-    throw new Error(`Run bundle unreadable: ${match.runDir}`);
+function printOnce(databasePath: string, runId: string | undefined): void {
+  const store = new WorkflowRunStore(databasePath, { readOnly: true });
+  try {
+    const size = { width: process.stdout.columns ?? 100, height: 1_000 };
+    if (runId === undefined) {
+      process.stdout.write(`${renderRunListLines(store.listRuns(), 0, size).join("\n")}\n`);
+      return;
+    }
+    const run = store.readRun(runId, { includeTrace: true });
+    if (run === null) throw new Error(`Run not found: ${runId}`);
+    process.stdout.write(`${renderRunDetailLines(run, size).join("\n")}\n`);
+  } finally {
+    store.close();
   }
-  process.stdout.write(`${renderRunDetailLines(bundle, size).join("\n")}\n`);
 }
 
-function printControllers(controllerDir: string): void {
-  const store = openControllerStore(controllerDir);
+function printControllers(databasePath: string): void {
+  const store = openControllerStore(databasePath);
   if (store === undefined) {
-    process.stdout.write(`No controller resources found in ${controllerDir}\n`);
+    process.stdout.write("No controller resources found.\n");
     return;
   }
   try {
     const resources = store.listResources();
     if (resources.length === 0) {
-      process.stdout.write(`No controller resources found in ${controllerDir}\n`);
+      process.stdout.write("No controller resources found.\n");
       return;
     }
     for (const resource of resources) {
@@ -196,29 +176,31 @@ function printControllers(controllerDir: string): void {
   }
 }
 
-function printController(controllerDir: string, controller: string, key: string): void {
-  const store = openControllerStore(controllerDir);
-  if (store === undefined) {
-    throw new Error(`Controller store not found in ${controllerDir}`);
-  }
+function printController(databasePath: string, controller: string, key: string): void {
+  const store = openControllerStore(databasePath);
+  if (store === undefined) throw new Error("Controller state database not found");
   try {
     const resource = store.getResource({ controller, key });
-    if (resource === undefined) {
+    if (resource === undefined)
       throw new Error(`Controller resource not found: ${controller}/${key}`);
-    }
-    const value = {
-      resource,
-      effects: store.listEffects(resource.metadata.uid),
-      workflows: store.listWorkflows(resource.metadata.uid),
-      events: store.listEvents({ controller, key, limit: 50 }),
-    };
-    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          resource,
+          effects: store.listEffects(resource.metadata.uid),
+          workflows: store.listWorkflows(resource.metadata.uid),
+          events: store.listEvents({ controller, key, limit: 50 }),
+        },
+        null,
+        2,
+      )}\n`,
+    );
   } finally {
     store.close();
   }
 }
 
-export async function main(argv: string[] = process.argv.slice(2)): Promise<number> {
+export async function main(argv = process.argv.slice(2)): Promise<number> {
   let args: CliArgs;
   try {
     args = parseCliArgs(argv);
@@ -226,42 +208,38 @@ export async function main(argv: string[] = process.argv.slice(2)): Promise<numb
     process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n\n${USAGE}`);
     return 2;
   }
+  if (args.command === "help") {
+    process.stdout.write(USAGE);
+    return 0;
+  }
 
+  const databasePath = workflowStateDatabasePath();
   try {
-    if (args.command === "help") {
-      process.stdout.write(USAGE);
-      return 0;
-    }
     if (args.command === "runs") {
-      await printRuns(args.dir);
+      printRuns(databasePath);
       return 0;
     }
     if (args.command === "controllers") {
-      printControllers(args.controllerDir);
+      printControllers(databasePath);
       return 0;
     }
     if (args.command === "controller") {
-      printController(
-        args.controllerDir,
-        args.controllerName as string,
-        args.resourceKey as string,
-      );
+      printController(databasePath, args.controllerName as string, args.resourceKey as string);
       return 0;
     }
-    if (args.command === "host") {
-      return await runHost(args.project ?? process.cwd(), args.piArgs);
+    if (args.command === "state") {
+      await runStateCommand(databasePath, args);
+      return 0;
     }
+    if (args.command === "host") return await runHost(args.project ?? process.cwd(), args.piArgs);
     if (args.command === "herdr") {
       const result = syncHerdrPlugin(packageRoot());
       process.stdout.write(args.json ? `${JSON.stringify(result)}\n` : `${result.message}\n`);
       return 0;
     }
     if (args.command === "view") {
-      if (args.once || !process.stdout.isTTY) {
-        await printOnce(args.dir, args.runId);
-        return 0;
-      }
-      await runViewer({ runsDir: args.dir, runId: args.runId });
+      if (args.once || !process.stdout.isTTY) printOnce(databasePath, args.runId);
+      else await runViewer({ databasePath, runId: args.runId });
       return 0;
     }
     process.stderr.write(`Unknown command: ${args.command}\n\n${USAGE}`);
@@ -272,6 +250,42 @@ export async function main(argv: string[] = process.argv.slice(2)): Promise<numb
   }
 }
 
+async function runStateCommand(databasePath: string, args: CliArgs): Promise<void> {
+  if (args.stateAction === "backup") {
+    const state = new StateDatabase({ filePath: databasePath });
+    try {
+      await state.backup(path.resolve(args.backupDestination as string));
+      process.stdout.write(`Backup verified: ${path.resolve(args.backupDestination as string)}\n`);
+    } finally {
+      state.close();
+    }
+    return;
+  }
+  const state = new StateDatabase({ filePath: databasePath, mode: "read-only" });
+  try {
+    state.integrityCheck();
+    if (args.stateAction === "verify") {
+      process.stdout.write("SQLite state is valid.\n");
+      return;
+    }
+    const counts = state.connection
+      .prepare(
+        `SELECT
+           (SELECT count(*) FROM runs) AS runs,
+           (SELECT count(*) FROM controller_resources) AS controllers,
+           (SELECT count(*) FROM human_decisions) AS decisions,
+           (SELECT count(*) FROM effects WHERE status IN ('pending', 'applying', 'ambiguous')) AS unsettledEffects,
+           (SELECT count(*) FROM leases WHERE owner_id IS NOT NULL) AS activeLeases`,
+      )
+      .get();
+    process.stdout.write(
+      `Database: ${databasePath}\nSize: ${fs.statSync(databasePath).size} bytes\n${JSON.stringify(counts)}\n`,
+    );
+  } finally {
+    state.close();
+  }
+}
+
 async function runHost(project: string, piArgs: string[] | undefined): Promise<number> {
   const { WorkflowHost } = await import("../host/runner.js");
   const host = new WorkflowHost({
@@ -281,21 +295,16 @@ async function runHost(project: string, piArgs: string[] | undefined): Promise<n
   });
   await host.start();
   await new Promise<void>((resolve) => {
-    const shutdown = () => {
-      void host.stop().then(() => resolve());
-    };
+    const shutdown = () => void host.stop().then(resolve);
     process.once("SIGTERM", shutdown);
     process.once("SIGINT", shutdown);
   });
   return 0;
 }
 
-function openControllerStore(controllerDir: string): SqliteControllerStore | undefined {
-  const file = path.join(controllerDir, "controller.sqlite");
-  if (!fs.existsSync(file)) {
-    return undefined;
-  }
-  return new SqliteControllerStore(file, { readOnly: true });
+function openControllerStore(databasePath: string): SqliteControllerStore | undefined {
+  if (!fs.existsSync(databasePath)) return undefined;
+  return new SqliteControllerStore(databasePath, { readOnly: true });
 }
 
 function packageRoot(): string {
@@ -304,14 +313,12 @@ function packageRoot(): string {
 
 function requiredValue(args: string[], option: string): string {
   const value = args.shift();
-  if (!value) {
-    throw new Error(`${option} requires a path`);
-  }
+  if (!value) throw new Error(`${option} requires a path`);
   return value;
 }
 
 const entryPath = process.argv[1];
-const resolvedEntry = entryPath !== undefined ? realpathSyncSafe(entryPath) : undefined;
+const resolvedEntry = entryPath === undefined ? undefined : realpathSyncSafe(entryPath);
 if (resolvedEntry !== undefined && import.meta.url === pathToFileURL(resolvedEntry).href) {
   main().then((code) => {
     process.exitCode = code;

package/src/viewer/render.ts

@@ -1,7 +1,6 @@
 import { ansi, fitWidth, sanitizeText } from "../render/ansi.js";
 import { formatDuration, runElapsedMs } from "../render/format.js";
 import { renderGraphLines } from "../render/graph-render.js";
-import { decodeValueWith } from "../workflows/artifacts.js";
 import {
   decisionDocumentSegments,
   decisionPresentationFingerprint,
@@ -12,7 +11,7 @@ import {
   progressRecordsFromTrace,
   progressTracksFromRecords,
 } from "../workflows/progress.js";
-import type { LoadedRunBundle } from "../workflows/store.js";
+import type { LoadedWorkflowRun } from "../workflows/store.js";
 import type {
   HumanDecisionRequest,
   WorkflowRunStatus,
@@ -21,22 +20,6 @@ import type {
 
 export { formatDuration, runElapsedMs };
 
-/**
- * Replace `$artifact` references with a compact placeholder for display. The
- * terminal viewer shows summaries; full artifact contents are for replay
- * tooling.
- */
-function withArtifactPlaceholders(value: unknown): unknown {
-  return decodeValueWith(value, (ref) => `«artifact ${formatBytes(ref.bytes)} ${ref.path}»`);
-}
-
-function formatBytes(bytes: number): string {
-  if (bytes < 1024) {
-    return `${bytes}B`;
-  }
-  return `${(bytes / 1024).toFixed(1)}KB`;
-}
-
 export type ViewportSize = {
   width: number;
   height: number;
@@ -59,7 +42,7 @@ function previewValue(rawValue: unknown, maxLength: number): string {
   if (rawValue === undefined) {
     return "";
   }
-  const value = withArtifactPlaceholders(rawValue);
+  const value = rawValue;
   const text = typeof value === "string" ? value : JSON.stringify(value);
   // Model-controlled values must not carry escape sequences into the terminal.
   const singleLine = sanitizeText(text ?? "")
@@ -70,7 +53,7 @@ function previewValue(rawValue: unknown, maxLength: number): string {
 
 /** One line per run for the run picker. */
 export function renderRunListLines(
-  bundles: LoadedRunBundle[],
+  bundles: LoadedWorkflowRun[],
   selectedIndex: number,
   size: ViewportSize,
   now: Date = new Date(),
@@ -126,7 +109,12 @@ function stepLine(
 }
 
 /** Fallback node status list for bundles without a definition snapshot. */
-function nodeStatusLine(bundle: LoadedRunBundle, nodeId: string, width: number, now: Date): string {
+function nodeStatusLine(
+  bundle: LoadedWorkflowRun,
+  nodeId: string,
+  width: number,
+  now: Date,
+): string {
   const state = bundle.state;
   const nodeType = bundle.snapshot?.nodes[nodeId]?.nodeType ?? "?";
   const result = state.results[nodeId];
@@ -187,7 +175,7 @@ function inspectorLines(step: WorkflowStepRecord, width: number): string[] {
     );
     return lines;
   }
-  const body = step.error !== undefined ? step.error : withArtifactPlaceholders(step.output);
+  const body = step.error !== undefined ? step.error : step.output;
   const rendered =
     typeof body === "string" && step.error !== undefined ? body : JSON.stringify(body, null, 2);
   for (const raw of (rendered ?? "null").split("\n")) {
@@ -221,7 +209,7 @@ function humanDecisionRequest(value: unknown): HumanDecisionRequest | null {
  * scrubs the replay position (defaults to the latest step, i.e. live).
  */
 export function renderRunDetailLines(
-  bundle: LoadedRunBundle,
+  bundle: LoadedWorkflowRun,
   size: ViewportSize,
   now: Date = new Date(),
   scroll = 0,
@@ -320,7 +308,7 @@ export function renderRunDetailLines(
 
 /** Highest useful `scroll` value for the detail view of `bundle`. */
 export function maxDetailScroll(
-  bundle: LoadedRunBundle,
+  bundle: LoadedWorkflowRun,
   size: ViewportSize,
   selectedStepIndex: number | null = null,
 ): number {

package/src/viewer/session-reducer.ts

@@ -296,7 +296,7 @@ export function reduceSessionEvents(
 
 /**
  * In-memory seek index. Checkpoints are viewer-only cache state and are never
- * persisted into a run bundle.
+ * persisted into a SQLite run state.
  */
 export class SessionReplayIndex {
   private readonly entries: WorkflowSessionEntryRecord[];

package/src/viewer/tui.ts

@@ -1,21 +1,20 @@
-import { listRunBundles, readRunBundle } from "../workflows/store.js";
-import type { LoadedRunBundle } from "../workflows/store.js";
+import { WorkflowRunStore, type LoadedWorkflowRun } from "../workflows/store.js";
 import {
   maxDetailScroll,
   renderRunDetailLines,
   renderRunListLines,
   type ViewportSize,
 } from "./render.js";
-import { watchRunsDir } from "./watch.js";
+import { watchStateDatabase } from "./watch.js";
 
 const ALT_SCREEN_ON = "\u001b[?1049h\u001b[?25l";
 const ALT_SCREEN_OFF = "\u001b[?25h\u001b[?1049l";
 const CLEAR = "\u001b[2J\u001b[H";
 
-type ViewerMode = { view: "list" } | { view: "detail"; runDir: string };
+type ViewerMode = { view: "list" } | { view: "detail"; runId: string };
 
 export type ViewerOptions = {
-  runsDir: string;
+  databasePath: string;
   runId?: string | undefined;
   /** Redraw interval for elapsed timers while a run is active. */
   tickMs?: number;
@@ -29,12 +28,13 @@ function viewportSize(): ViewportSize {
 }
 
 /**
- * Interactive live viewer. Watches the runs directory and re-renders as run
- * bundles change on disk. Returns when the user quits.
+ * Interactive live viewer. Watches the SQLite database and re-renders after
+ * committed run changes. Returns when the user quits.
  */
 export async function runViewer(options: ViewerOptions): Promise<void> {
+  const store = new WorkflowRunStore(options.databasePath, { readOnly: true });
   let mode: ViewerMode = { view: "list" };
-  let bundles: LoadedRunBundle[] = [];
+  let bundles: LoadedWorkflowRun[] = [];
   let selectedIndex = 0;
   let detailScroll = 0;
   /** Replay position; null follows the latest step live. */
@@ -42,29 +42,29 @@ export async function runViewer(options: ViewerOptions): Promise<void> {
   let detailStepCount = 0;
 
   if (options.runId) {
-    bundles = await listRunBundles(options.runsDir);
+    bundles = store.listRuns();
     const match = bundles.find((bundle) => bundle.state.runId === options.runId);
     if (!match) {
       throw new Error(`Run not found: ${options.runId}`);
     }
-    mode = { view: "detail", runDir: match.runDir };
+    mode = { view: "detail", runId: match.runId };
   }
 
   const draw = async () => {
-    bundles = await listRunBundles(options.runsDir);
+    bundles = store.listRuns();
     selectedIndex = Math.min(selectedIndex, Math.max(0, bundles.length - 1));
     const size = viewportSize();
     const lines =
       mode.view === "list"
         ? renderRunListLines(bundles, selectedIndex, size)
-        : await renderDetail(mode.runDir, size);
+        : await renderDetail(mode.runId, size);
     process.stdout.write(CLEAR + lines.join("\n"));
   };
 
-  const renderDetail = async (runDir: string, size: ViewportSize): Promise<string[]> => {
-    const bundle = await readRunBundle(runDir, { includeTrace: true });
+  const renderDetail = async (runId: string, size: ViewportSize): Promise<string[]> => {
+    const bundle = store.readRun(runId, { includeTrace: true });
     if (!bundle) {
-      return ["Run bundle disappeared. Press q to go back."];
+      return ["SQLite run state disappeared. Press q to go back."];
     }
     detailStepCount = bundle.state.steps.length;
     if (selectedStep !== null && selectedStep >= detailStepCount - 1) {
@@ -76,7 +76,7 @@ export async function runViewer(options: ViewerOptions): Promise<void> {
   };
 
   process.stdout.write(ALT_SCREEN_ON);
-  const stopWatching = watchRunsDir(options.runsDir, () => {
+  const stopWatching = watchStateDatabase(options.databasePath, () => {
     void draw();
   });
   const ticker = setInterval(() => {
@@ -136,7 +136,7 @@ export async function runViewer(options: ViewerOptions): Promise<void> {
         } else if (key === "\r" || key === "\n") {
           const selected = bundles[selectedIndex];
           if (selected) {
-            mode = { view: "detail", runDir: selected.runDir };
+            mode = { view: "detail", runId: selected.runId };
             detailScroll = 0;
             selectedStep = null;
             void draw();
@@ -150,6 +150,7 @@ export async function runViewer(options: ViewerOptions): Promise<void> {
   } finally {
     clearInterval(ticker);
     stopWatching();
+    store.close();
     if (rawModeSupported) {
       process.stdin.setRawMode(false);
     }