seisin 0.6.1 → 0.6.2

package/README.md

@@ -280,6 +280,7 @@ seisin explain frontend write src/api/x  # ask one question, exit 0 or 1
 seisin review --since 7d                 # what the log says about the policy, this week
 seisin wire                              # install the PreToolUse hook in this repo
 seisin ui                                # a console for deciding what is waiting
+seisin ui --runs <dir>                   # read only, over many runs a launcher archived (docs/runs.md)
 ```
 
 **Three ways in, and they say the same thing.** The **CLI** is what a person types and what
@@ -1036,9 +1037,9 @@ the same kernel or workspace, and which one you want depends on what you are pro
 
 ## Status
 
-**1090 tests on macOS, 1083 passing and 7 platform skips** (0.6.1, 2026-10-26, local); in CI the
-same day, on `ubuntu-latest` **1089, 1060 passing and 29 platform skips**, and on macOS 1090,
-1081 passing and 9 skips, Node 18/20/22/24, with the 26 core boundary tests skipping none. On 2026-10-12, 91 of the suite's tests
+**1101 tests on macOS, 1094 passing and 7 platform skips** (0.6.2, 2026-10-26, local); in CI the
+same day, on `ubuntu-latest` **1100, 1071 passing and 29 platform skips**, and on macOS 1101,
+1092 passing and 9 skips, Node 18/20/22/24, with the 26 core boundary tests skipping none. On 2026-10-12, 91 of the suite's tests
 needed `@anthropic-ai/sandbox-runtime` installed — counted by running it with the runtime
 hidden — and run real commands through the real kernel; 26 of them are the core boundary file,
 `test/sandbox.test.js`, which the CI gate fails if it *skips*, because a green run that quietly

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "seisin",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "A permission layer for AI coding agents: role-scoped folders and keys, enforced by the OS, and when it denies something it tells you whose file it was.",
   "keywords": [
     "ai-agents",
@@ -45,7 +45,7 @@
     "@anthropic-ai/sandbox-runtime": "0.0.81"
   },
   "optionalDependencies": {
-    "@carlostapiacl/tartaros": "0.1.0-alpha.14"
+    "@carlostapiacl/tartaros": "0.1.0-alpha.15"
   },
   "scripts": {
     "test": "node --test test/*.test.js",

package/src/cli.js

@@ -57,6 +57,7 @@ ${C.b}seisin${C.off} — give each agent its own folders and its own keys
   seisin init [--force]                 propose a ${CONFIG_NAME} for this repo
   seisin init --from-observations       write ${CONFIG_NAME}.observed from observed runs
   seisin ui [--port n] [--link]         open the console, live (--link reopens a running one)
+  seisin ui --runs <dir> [--link --json]  a read-only console over a directory of runs (docs/runs.md)
   seisin mcp                            an MCP server on stdio — read-only
 
 seisin <command> --help lists a command's flags, examples and exit codes.
@@ -105,7 +106,7 @@ const COMMANDS = {
   },
   // --link only reads a record; it answers without a policy here too, and
   // says so when the console it finds serves another one.
-  ui: async () => (await import("./commands/ui.js")).ui(argv.includes("--link") ? maybeConfig() : config(), argv),
+  ui: async () => (await import("./commands/ui.js")).ui(argv.includes("--link") || argv.includes("--runs") ? maybeConfig() : config(), argv),
   whose: async () => void (await import("./commands/whose.js")).whose(config(), argv),
   wire: async () => void (await import("./commands/wire.js")).wire(config()),
   review: async () => ((await import("./commands/review.js")).reviewCommand(config(), argv).friction.length ? 1 : 0),

package/src/commands/ui.js

@@ -14,6 +14,8 @@
  * failing. See uilink.js.
  */
 import { spawnSync } from "node:child_process";
+import { statSync } from "node:fs";
+import { resolve } from "node:path";
 import { serve } from "../serve.js";
 import { writeUiLink, readUiLink, clearUiLink } from "../uilink.js";
 import { C, out } from "../render.js";
@@ -23,28 +25,58 @@ function open(url) {
   spawnSync(opener, [url], { stdio: "ignore", shell: process.platform === "win32" });
 }
 
+/**
+ * `--runs <dir>`: the console over a directory of runs, read only (runs.js,
+ * docs/runs.md), on 4179 unless told otherwise, so it does not take the port a
+ * repository's own console would want.
+ */
+function runsDirOf(argv) {
+  const i = argv.indexOf("--runs");
+  if (i === -1) return null;
+  const dir = argv[i + 1];
+  if (!dir || dir.startsWith("--")) throw new Error("--runs needs a directory: seisin ui --runs <dir>");
+  let st = null;
+  try { st = statSync(dir); } catch {}
+  if (!st?.isDirectory()) throw new Error(`--runs ${dir}: not a directory`);
+  return resolve(dir);
+}
+
 export async function ui(config, argv = []) {
+  const runsDir = runsDirOf(argv);
+  const mode = runsDir ? "runs" : "policy";
   const i = argv.indexOf("--port");
-  const port = i === -1 ? 4178 : Number(argv[i + 1]);
+  const port = i === -1 ? (runsDir ? 4179 : 4178) : Number(argv[i + 1]);
+  const json = argv.includes("--json");
 
   // `seisin ui --link`: print the live link a running console left, and open
   // it, without starting anything. For when the terminal that had it is gone.
+  // With --json, the record for a program to read — `{url, port, mode}` — and
+  // nothing opened: the launcher's own panel links to it.
   if (argv.includes("--link")) {
     const found = readUiLink(port);
+    if (json) {
+      if (found && found.alive === false) clearUiLink(port);
+      const live = found && found.alive !== false;
+      out(JSON.stringify(live
+        ? { running: true, url: found.url, port, mode: found.mode, ...(found.dir && { dir: found.dir }), ...(found.policy && { policy: found.policy }) }
+        : { running: false, port }) + "\n");
+      return;
+    }
     if (found && found.alive !== false) {
       out(`\n  ${C.b}${found.url}${C.off}\n  ${C.dim}the link a seisin ui on ${port} is serving. open it here, do not paste it anywhere.${C.off}\n` +
-        servesWhich(found.policy, config?.path) + "\n");
+        servesWhich(found.policy, runsDir ? null : config?.path, found) + "\n");
       open(found.url);
       return;
     }
     if (found && found.alive === false) clearUiLink(port);
-    out(`\n  ${C.dim}no seisin ui running on ${port} — start one with: seisin ui${port === 4178 ? "" : ` --port ${port}`}${C.off}\n\n`);
+    const start = runsDir ? `seisin ui --runs ${runsDir}${port === 4179 ? "" : ` --port ${port}`}` : `seisin ui${port === 4178 ? "" : ` --port ${port}`}`;
+    out(`\n  ${C.dim}no seisin ui running on ${port} — start one with: ${start}${C.off}\n\n`);
     return;
   }
 
   let server;
   try {
-    server = await serve(config.path, port);
+    server = await serve(runsDir ? null : config.path, port, { runsDir });
   } catch (e) {
     // A console is already on this port: hand back its live link rather than
     // erroring, which is the case that sends people digging in the terminal.
@@ -54,7 +86,7 @@ export async function ui(config, argv = []) {
         out(
           `\n  ${C.b}${found.url}${C.off}\n` +
           `  ${C.dim}a seisin ui is already running on ${port}; reopening its link. ctrl-c that terminal to stop it.${C.off}\n` +
-          servesWhich(found.policy, config.path) + "\n"
+          servesWhich(found.policy, runsDir ? null : config.path, found) + "\n"
         );
         open(found.url);
         return;
@@ -70,19 +102,22 @@ export async function ui(config, argv = []) {
   const bound = server.address().port;
   const url = `http://127.0.0.1:${bound}/#t=${server.seisinToken}`;
   // Recorded before we print, so `--link` and a second `seisin ui` can find it.
-  writeUiLink(bound, url, undefined, config.path);
+  writeUiLink(bound, url, undefined, runsDir ? null : config.path, { mode, dir: runsDir });
 
   // local_binding opens every port (macOS); local_ports opens the ones it
   // names, on every platform — so only a role that names THIS port counts.
-  const reach = Object.values(config.roles)
+  const reach = Object.values(config?.roles ?? {})
     .filter((r) => (r.localBinding && process.platform === "darwin") || (r.localPorts ?? []).includes(bound))
     .map((r) => r.name);
 
   out(
     `\n  ${C.b}${url}${C.off}\n` +
-    `  ${C.dim}reading ${config.path} and the log, live. ctrl-c to stop.${C.off}\n` +
+    (runsDir
+      ? `  ${C.dim}reading the runs in ${runsDir}, live and read only: nothing is granted from here. ctrl-c to stop.${C.off}\n` +
+        `  ${C.dim}one run: add &run=<run_id> to the link.${C.off}\n`
+      : `  ${C.dim}reading ${config.path} and the log, live. ctrl-c to stop.${C.off}\n`) +
     `  ${C.dim}the link carries this run's token: open it here, do not paste it anywhere.${C.off}\n` +
-    `  ${C.dim}lost it? this terminal has it above, or run: seisin ui --link${bound === 4178 ? "" : ` --port ${bound}`}${C.off}\n` +
+    `  ${C.dim}lost it? this terminal has it above, or run: seisin ui${runsDir ? ` --runs ${runsDir}` : ""} --link${bound === (runsDir ? 4179 : 4178) ? "" : ` --port ${bound}`}${C.off}\n` +
     (reach.length
       ? `  ${C.yellow}${reach.join(", ")} can reach this port on localhost: they can load this page, ` +
         `but not the token, which only travels in the link above.${C.off}\n`
@@ -101,7 +136,8 @@ export async function ui(config, argv = []) {
  * Which policy a running console serves, and a warning when it is not the one
  * this directory would use. `here` is null when there is no policy here.
  */
-export function servesWhich(served, here) {
+export function servesWhich(served, here, found = null) {
+  if (found?.mode === "runs") return `  ${C.dim}serving the runs in ${found.dir} (read only)${C.off}\n`;
   if (!served) return `  ${C.dim}(started by an older seisin: which seisin.toml it serves is not recorded)${C.off}\n`;
   if (here && served !== here)
     return `  ${C.yellow}it serves ${served} — not ${here}, the policy for this directory.${C.off}\n` +

package/src/help.js

@@ -123,10 +123,12 @@ export const COMMAND_HELP = {
     exits: [["0", "written"], ["2", "a policy is already there, or nothing was observed"]],
   },
   ui: {
-    usage: ["seisin ui [--port <n>] [--link]"],
-    values: ["--port"],
-    flags: [["--port <n>", "port on 127.0.0.1 (default 4178)"], ["--link", "print the link of a console already running, start nothing"]],
-    examples: ["seisin ui", "seisin ui --link"],
+    usage: ["seisin ui [--port <n>] [--link]", "seisin ui --runs <dir> [--port <n>] [--link [--json]]"],
+    values: ["--port", "--runs"],
+    flags: [["--port <n>", "port on 127.0.0.1 (default 4178; 4179 with --runs)"], ["--link", "print the link of a console already running, start nothing"],
+      ["--runs <dir>", "a read-only console over a directory of runs, one folder each (docs/runs.md)"],
+      ["--json", "with --link: {running, url, port, mode} for a program to read, nothing opened"]],
+    examples: ["seisin ui", "seisin ui --link", "seisin ui --runs ~/.wapentake/seisin/runs", "seisin ui --runs ~/.wapentake/seisin/runs --link --json"],
     exits: [["0", "stopped"], ["2", "could not start"]],
   },
   mcp: {

package/src/runs.js

@@ -0,0 +1,298 @@
+/**
+ * `seisin ui --runs <dir>`: the console over many runs, each with its own policy.
+ *
+ * A launcher that lends each run a territory of its own (wapentake does) has no
+ * single seisin.toml to open: every run gets one written for it at the root of
+ * a worktree, runs there, and the worktree is gone a day or two later. What is
+ * worth keeping is copied out — the policy, the `.seisin/` beside it and a
+ * `run.json` the launcher writes — one folder per run, under one directory.
+ * This reads that directory. The contract is docs/runs.md.
+ *
+ * Read only, on purpose. The territory is the launcher's to lend: a grant
+ * written into an archived run's seisin.toml changes nothing anywhere, so the
+ * console in this mode offers none and the server refuses every write.
+ *
+ * A run that is archived does not change, so what is worked out from it is
+ * kept for as long as its files' signature stays the same — the poll every two
+ * seconds over hundreds of runs re-reads a directory listing and some stats,
+ * not every log.
+ */
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { loadConfig } from "./config.js";
+import { read, logPath } from "./log.js";
+import { requestsPath } from "./requests.js";
+
+/** The name a run's folder may have: what becomes `run=` in a link. */
+const RUN_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+
+/** The fields of run.json the console reads; anything else in it is ignored. */
+const META = ["run_id", "team", "work_item", "role", "repo", "started_at", "ended_at", "status", "launcher"];
+
+/** How many causes the global view is sent, summed over the runs shown. */
+const CAUSES_SHOWN = 50;
+
+/** How many of a run's own causes travel with it in the list. */
+const RUN_CAUSES = 5;
+
+export function isRunId(id) {
+  return typeof id === "string" && RUN_ID.test(id) && id !== "." && id !== "..";
+}
+
+function statSig(p) {
+  try { const s = statSync(p); return `${s.ino}:${s.size}:${s.mtimeMs}`; } catch { return "-"; }
+}
+
+/** The run folders under `dir`, by name; a file or a name that is not a run id is skipped. */
+export function runFolders(dir) {
+  let names;
+  try { names = readdirSync(dir, { withFileTypes: true }); }
+  catch (e) { throw Object.assign(new Error(`cannot read the runs directory ${dir}: ${e.message}`), { status: 500 }); }
+  return names.filter((d) => d.isDirectory() && isRunId(d.name)).map((d) => d.name).sort();
+}
+
+/** Where a run's policy is. */
+export function runPolicy(dir, id) {
+  return join(dir, id, "seisin.toml");
+}
+
+/**
+ * What a run's summary is made from, as stats only: the policy, run.json, the
+ * queue, the current log and the `.seisin/` directory itself, whose mtime
+ * moves when a segment is rotated in or out. No directory is listed: six
+ * hundred `readdir`s were most of a warm poll (~0.7 s).
+ */
+function signatureOf(dir, id) {
+  const root = join(dir, id);
+  const log = logPath(root);
+  return [
+    statSig(join(root, "seisin.toml")),
+    statSig(join(root, "run.json")),
+    statSig(requestsPath(root)),
+    statSig(log),
+    statSig(dirname(log)),
+  ].join("|");
+}
+
+/** run.json, the launcher's word on the run — or null when it is missing or not JSON. */
+function metaOf(dir, id) {
+  let raw;
+  try { raw = JSON.parse(readFileSync(join(dir, id, "run.json"), "utf8")); } catch { return null; }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const out = {};
+  for (const k of META) if (raw[k] !== undefined && raw[k] !== null) out[k] = typeof raw[k] === "string" ? raw[k] : String(raw[k]);
+  return out;
+}
+
+/**
+ * What one run comes to: who it was, what it was denied, what the denials
+ * cost in retries (every denial after the first of the same thing, system
+ * denials aside), and whether it was let start at all.
+ *
+ * `outcome` is seisin's word, beside the launcher's `status`:
+ *   refused — its canary failed, so nothing ran;
+ *   denied  — it ran and was denied a file or a host;
+ *   clean   — it ran and was denied neither (system denials, the OS's own
+ *             housekeeping, and the canary's expected probes do not count);
+ *   unread  — its policy could not be read.
+ */
+function summarize(dir, id) {
+  const meta = metaOf(dir, id);
+  const base = {
+    id,
+    run_id: meta?.run_id ?? id,
+    team: meta?.team ?? null,
+    work_item: meta?.work_item ?? null,
+    role: meta?.role ?? null,
+    repo: meta?.repo ?? null,
+    started_at: meta?.started_at ?? null,
+    ended_at: meta?.ended_at ?? null,
+    status: meta?.status ?? null,
+    launcher: meta?.launcher ?? null,
+    meta: meta !== null,
+  };
+  let cfg;
+  try { cfg = loadConfig(runPolicy(dir, id)); }
+  catch (e) {
+    return { ...base, outcome: "unread", error: e.code === "ENOENT" ? "no seisin.toml in this run's folder" : e.message,
+      roles: [], denied: 0, byKind: {}, expected: 0, retried: 0, causes: [], hosts: [], entries: 0, canary: null };
+  }
+  const all = read(logPath(cfg.root));
+  /**
+   * Grouped here, by what was denied, rather than through causesOf and walls:
+   * those ask the policy and the disk about every path (~130 ms a run on the
+   * pilot's logs, a minute and more over six hundred), to say whether a
+   * denial would still be one today. An archived run's policy does not change,
+   * so every repeat of a denial is a retry against a standing wall, and the
+   * per-run view, which is one run, still gets the full answer from state().
+   */
+  const byKind = {};
+  let denied = 0, expected = 0;
+  const groups = new Map();
+  for (const e of all) {
+    if (e.verdict !== "denied") continue;
+    if (e.expected === true) { expected++; continue; }
+    const k = e.kind ?? "file";
+    byKind[k] = (byKind[k] ?? 0) + 1;
+    if (k !== "system") denied++;
+    if (!e.action || !e.target) continue;
+    const key = `${e.action}\u0000${e.target}`;
+    const g = groups.get(key) ?? { about: k, action: e.action, target: e.target, times: 0, owners: e.owners ?? [] };
+    g.times++;
+    groups.set(key, g);
+  }
+  const causes = [...groups.values()].sort((a, b) => b.times - a.times);
+  const retried = causes.reduce((n, g) => n + (g.about === "system" ? 0 : g.times - 1), 0);
+  const hosts = causes.filter((g) => g.about === "network").slice(0, 10).map(({ target, times }) => ({ target, times }));
+  const canaries = all.filter((e) => e.event === "canary");
+  const canary = canaries.length ? canaries[canaries.length - 1] : null;
+  const outcome = canaries.some((e) => e.confined === false) ? "refused" : denied ? "denied" : "clean";
+  return {
+    ...base,
+    // A run.json that did not say when it started: the log's first line did.
+    started_at: base.started_at ?? all.find((e) => e.at)?.at ?? null,
+    ended_at: base.ended_at ?? [...all].reverse().find((e) => e.at)?.at ?? null,
+    outcome,
+    roles: Object.keys(cfg.roles),
+    sandbox: canary?.sandbox ?? null,
+    entries: all.length,
+    denied,
+    expected,
+    byKind,
+    retried,
+    hosts,
+    // Kept whole for the sum across runs, cut to RUN_CAUSES when sent.
+    causes,
+    canary: canary ? { confined: canary.confined !== false, reasons: canary.reasons ?? [] } : null,
+  };
+}
+
+/** Summaries kept by run id, with the signature they were made from. */
+const cache = new Map();
+
+/** Every run under `dir`, summarized, re-read only where a file moved. */
+export function scanRuns(dir) {
+  const ids = runFolders(dir);
+  const seen = new Set(ids);
+  for (const k of cache.keys()) if (k.startsWith(`${dir}\u0000`) && !seen.has(k.slice(dir.length + 1))) cache.delete(k);
+  const sigs = [];
+  const runs = ids.map((id) => {
+    const sig = signatureOf(dir, id);
+    sigs.push(`${id}=${sig}`);
+    const k = `${dir}\u0000${id}`;
+    const hit = cache.get(k);
+    if (hit && hit.sig === sig) return hit.summary;
+    const summary = summarize(dir, id);
+    cache.set(k, { sig, summary });
+    return summary;
+  });
+  return { runs, sig: sigs.join("\n") };
+}
+
+/** The filters the global view takes, from a query string. Unknown keys are ignored. */
+export const FILTERS = ["team", "role", "work_item", "status", "outcome"];
+
+export function filtersOf(query) {
+  const q = new URLSearchParams(query ?? "");
+  const out = {};
+  for (const f of FILTERS) { const v = q.get(f); if (v) out[f] = v; }
+  const text = q.get("q");
+  if (text) out.q = text.toLowerCase();
+  return out;
+}
+
+function matches(run, filters) {
+  for (const f of FILTERS) if (filters[f] !== undefined && (run[f] ?? "") !== filters[f]) return false;
+  if (filters.q) {
+    const hay = [run.id, run.run_id, run.work_item, run.repo, run.team, run.role].filter(Boolean).join(" ").toLowerCase();
+    if (!hay.includes(filters.q)) return false;
+  }
+  return true;
+}
+
+/** How many runs have each value of each filter — over every run, so a filter never hides its siblings. */
+function facetsOf(runs) {
+  const out = {};
+  for (const f of FILTERS) {
+    const m = new Map();
+    for (const r of runs) { const v = r[f]; if (v) m.set(v, (m.get(v) ?? 0) + 1); }
+    out[f] = [...m].sort((a, b) => b[1] - a[1] || String(a[0]).localeCompare(String(b[0]))).map(([value, runs]) => ({ value, runs }));
+  }
+  return out;
+}
+
+/**
+ * The same refusal across runs is one cause: summed by what was refused, with
+ * how many runs hit it and which teams and roles they were.
+ */
+function causesAcross(runs) {
+  const by = new Map();
+  for (const r of runs) {
+    for (const c of r.causes) {
+      const k = `${c.action}\u0000${c.target}`;
+      const g = by.get(k) ?? { action: c.action, target: c.target, about: c.about, owners: c.owners, times: 0, runs: 0, teams: new Set(), roles: new Set(), last: null };
+      g.times += c.times;
+      g.runs++;
+      if (r.team) g.teams.add(r.team);
+      if (r.role) g.roles.add(r.role);
+      if (!g.last || (r.started_at && r.started_at > g.last.at)) g.last = { run: r.id, at: r.started_at };
+      by.set(k, g);
+    }
+  }
+  return [...by.values()]
+    // The OS's own housekeeping last: it is in every run and nobody grants it.
+    .sort((a, b) => (a.about === "system") - (b.about === "system") || b.runs - a.runs || b.times - a.times)
+    .slice(0, CAUSES_SHOWN)
+    .map((g) => ({ ...g, teams: [...g.teams], roles: [...g.roles], last: g.last?.run ?? null }));
+}
+
+const cmp = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+
+/** The global view: the runs that pass the filters, newest first, and what they add up to. */
+const views = new Map();
+
+export function runsView(dir, filters = {}, { scanned = scanRuns(dir) } = {}) {
+  // The same runs and the same filters are the same answer: the poll asks
+  // every two seconds, and summing the causes of six hundred runs was most
+  // of what it cost once the runs themselves were remembered.
+  const key = `${dir}\u0000${JSON.stringify(filters)}\u0000${scanned.sig}`;
+  const hit = views.get(key);
+  if (hit) return hit;
+  const view = viewOf(dir, filters, scanned.runs);
+  views.set(key, view);
+  while (views.size > 8) views.delete(views.keys().next().value);
+  return view;
+}
+
+function viewOf(dir, filters, every) {
+  const shown = every.filter((r) => matches(r, filters))
+    .sort((a, b) => cmp(b.started_at ?? "", a.started_at ?? "") || cmp(b.id, a.id));
+  const totals = { runs: shown.length, denied: 0, retried: 0, expected: 0, byKind: {}, outcome: {} };
+  for (const r of shown) {
+    totals.denied += r.denied;
+    totals.retried += r.retried;
+    totals.expected += r.expected;
+    for (const [k, n] of Object.entries(r.byKind)) totals.byKind[k] = (totals.byKind[k] ?? 0) + n;
+    totals.outcome[r.outcome] = (totals.outcome[r.outcome] ?? 0) + 1;
+  }
+  return {
+    mode: "runs",
+    dir,
+    filters,
+    total: every.length,
+    facets: facetsOf(every),
+    totals,
+    causes: causesAcross(shown),
+    runs: shown.map((r) => ({ ...r, causes: r.causes.slice(0, RUN_CAUSES) })),
+    readOnly: true,
+  };
+}
+
+/** One run's summary, by id; throws 404 for a name that is not a run here. */
+export function runOf(dir, id) {
+  if (!isRunId(id)) throw Object.assign(new Error(`not a run id: ${JSON.stringify(id)}`), { status: 400 });
+  if (!runFolders(dir).includes(id)) throw Object.assign(new Error(`no run ${id} in ${dir}`), { status: 404 });
+  const { runs } = scanRuns(dir);
+  const r = runs.find((x) => x.id === id);
+  return { ...r, causes: r.causes.slice(0, RUN_CAUSES) };
+}

package/src/serve.js

@@ -23,6 +23,7 @@ import { pending, requestsPath, settle, applyGrant, refuseIfBarred, editPolicy,
 import { causesOf, describeWalls, parseSince, queue, verdicts, wallsByRole } from "./views.js";
 import { planEdit, hashOf } from "./controls.js";
 import { inspect } from "./inspect.js";
+import { scanRuns, runsView, runOf, runPolicy, filtersOf, isRunId } from "./runs.js";
 
 // Moved to views.js, which the MCP server shares; kept importable from here.
 export { causesOf } from "./views.js";
@@ -104,7 +105,7 @@ function remember(map, key, value, max = 4) {
  * page downloaded every two seconds and it drew none of them. One role's are
  * served on demand by /api/settings.
  */
-export function state(configPath, { since = null, snap = snapshot(configPath) } = {}) {
+export function state(configPath, { since = null, snap = snapshot(configPath), readOnly = false } = {}) {
   const { cfg, text, all } = snap;
 
   // The date filter narrows everything read from the log: activity, causes,
@@ -162,7 +163,9 @@ export function state(configPath, { since = null, snap = snapshot(configPath) }
     // A write keyed by a folder can be granted as its one file instead; the
     // line that choice carries is said here, once, so the page and the CLI
     // say the same thing about Claude Code.
-    requests: queue(cfg, all).map((r) => ({
+    // Read only (an archived run): a queue an older seisin left is an error to
+    // show, never a rewrite of a file that is not this console's (requests.js).
+    requests: queue(cfg, all, { readOnly }).map((r) => ({
       ...r,
       // Said by the server in the same words as the CLI, so the page never
       // works out where a request goes on its own (handoff.js).
@@ -197,14 +200,14 @@ export function state(configPath, { since = null, snap = snapshot(configPath) }
  * moved — and a tag naming it, so a poll that already has it gets a 304 and
  * no body at all.
  */
-function stateBody(configPath, since) {
+function stateBody(configPath, since, { readOnly = false } = {}) {
   // One snapshot for the tag and the body. Each used to take its own, so a
   // file that moved between the two calls got a body filed under the tag of
   // what was there before — and a 304 for it until something else moved.
   const snap = snapshot(configPath);
-  const k = `${snap.key}|${since}`;
+  const k = `${snap.key}|${since}|${readOnly}`;
   return memo.bodies.get(k) ?? remember(memo.bodies, k, {
-    body: JSON.stringify(state(configPath, { since, snap })),
+    body: JSON.stringify(state(configPath, { since, snap, readOnly })),
     etag: `"${createHash("sha256").update(k).digest("hex").slice(0, 24)}"`,
   });
 }
@@ -458,7 +461,37 @@ function declineAll(configPath, { keys, reason }) {
   return { ok: true, declined };
 }
 
-export function serve(configPath, port = 4178, { lockWaitMs = 10000 } = {}) {
+/**
+ * The console over a directory of runs (`seisin ui --runs`, runs.js), read
+ * only: the territory each run had was lent by whoever launched it, and a
+ * grant written into an archived policy changes nothing. So in this mode
+ * every route that writes answers 405, and the page draws no grant.
+ */
+function runsBody(dir, query) {
+  const filters = filtersOf(query);
+  const scanned = scanRuns(dir);
+  const k = `${JSON.stringify(filters)}|${scanned.sig}`;
+  return runsMemo.get(k) ?? remember(runsMemo, k, {
+    body: JSON.stringify(runsView(dir, filters, { scanned })),
+    etag: `"${createHash("sha256").update(k).digest("hex").slice(0, 24)}"`,
+  });
+}
+const runsMemo = new Map();
+
+/** One run as the page draws it: its own state, read only, with what run.json said. */
+function runBody(dir, id, since) {
+  const run = runOf(dir, id);
+  if (run.outcome === "unread") throw Object.assign(new Error(`run ${id}: ${run.error}`), { status: 422 });
+  const got = stateBody(runPolicy(dir, id), since, { readOnly: true });
+  // The state is already a string; the run is stitched onto it rather than
+  // parsed and serialized again on every poll.
+  return {
+    body: `${got.body.slice(0, -1)},"mode":"runs","readOnly":true,"run":${JSON.stringify(run)}}`,
+    etag: `"${createHash("sha256").update(`${got.etag}|${JSON.stringify(run)}`).digest("hex").slice(0, 24)}"`,
+  };
+}
+
+export function serve(configPath, port = 4178, { lockWaitMs = 10000, runsDir = null } = {}) {
   const page = join(HERE, "..", "ui", "index.html");
   if (!existsSync(page)) throw new Error("the console is missing from this install");
 
@@ -553,6 +586,12 @@ export function serve(configPath, port = 4178, { lockWaitMs = 10000 } = {}) {
         return answer(statusOf(e), { error: e.message });
       }
     };
+    const query = (req.url ?? "").split("?")[1] ?? "";
+    // Over runs, nothing is written: not a decision, not a control file.
+    if (runsDir && req.method !== "GET" && req.method !== "HEAD") {
+      res.writeHead(405, { allow: "GET", "content-type": "application/json" });
+      return res.end(JSON.stringify({ error: "read only: this console shows archived runs. Access is asked for where the run was launched, not here." }));
+    }
     // ~85 bytes per key: 1 MB is ten thousand requests on one screen.
     if (req.method === "POST" && pathOf(req.url) === "/api/decline-all")
       return post(1024 * 1024, (args) => declineAll(configPath, args));
@@ -571,12 +610,23 @@ export function serve(configPath, port = 4178, { lockWaitMs = 10000 } = {}) {
         res.writeHead(405, { allow: "GET" });
         return res.end();
       }
-      if (pathOf(req.url) === "/api/state") {
+      if (pathOf(req.url) === "/api/info")
+        return answer(200, runsDir ? { mode: "runs", dir: runsDir, readOnly: true } : { mode: "policy", config: configPath, readOnly: false });
+      const routes = runsDir
+        ? { "/api/runs": () => runsBody(runsDir, query),
+            "/api/run": () => {
+              const id = new URLSearchParams(query).get("run");
+              if (!isRunId(id)) throw bad("run must name one of the runs: ?run=<run_id>");
+              return runBody(runsDir, id, sinceOf(req.url));
+            } }
+        : { "/api/state": () => stateBody(configPath, sinceOf(req.url)) };
+      const route = routes[pathOf(req.url)];
+      if (route) {
         let got;
         try {
-          got = stateBody(configPath, sinceOf(req.url));
+          got = route();
         } catch (e) {
-          return answer(500, { error: e.message });
+          return answer(e.status ?? 500, { error: e.message });
         }
         // The page polls, so tell every cache in between to stay out of it;
         // the page itself sends the tag back and is told when nothing moved.
@@ -587,8 +637,16 @@ export function serve(configPath, port = 4178, { lockWaitMs = 10000 } = {}) {
       }
       if (pathOf(req.url) === "/api/settings") {
         try {
-          const role = new URLSearchParams(req.url.split("?")[1] ?? "").get("role");
-          return answer(200, { role, settings: settingsOf(configPath, role) });
+          const params = new URLSearchParams(query);
+          const role = params.get("role");
+          let policy = configPath;
+          if (runsDir) {
+            const id = params.get("run");
+            if (!isRunId(id)) throw bad("run must name one of the runs: ?run=<run_id>");
+            runOf(runsDir, id);
+            policy = runPolicy(runsDir, id);
+          }
+          return answer(200, { role, settings: settingsOf(policy, role) });
         } catch (e) {
           return answer(e.status ?? 500, { error: e.message });
         }
@@ -611,6 +669,9 @@ export function serve(configPath, port = 4178, { lockWaitMs = 10000 } = {}) {
       // For `seisin ui`, which builds the URL, and for tests. Never sent.
       Object.defineProperty(server, "seisinToken", { value: token });
       ok(server);
+      // The first read of a few hundred runs takes seconds; started now, it is
+      // mostly done by the time the page asks.
+      if (runsDir) setImmediate(() => { try { scanRuns(runsDir); } catch {} });
     });
     server.on("error", (e) =>
       fail(e.code === "EADDRINUSE"

package/src/uilink.js

@@ -35,10 +35,12 @@ function linkFile(port, base) {
  * console another repo had started — and opened a page about the wrong policy
  * with nothing on it to say so. The policy's path travels with the link now.
  */
-export function writeUiLink(port, url, base, policy = null) {
+export function writeUiLink(port, url, base, policy = null, { mode = "policy", dir = null } = {}) {
   const file = linkFile(port, base);
   const temp = `${file}.tmp-${randomBytes(12).toString("hex")}`;
-  writeFileSync(temp, JSON.stringify({ url, pid: process.pid, policy }) + "\n", { flag: "wx", mode: 0o600 });
+  // `mode` and `dir`: a console over a directory of runs (`--runs`) serves no
+  // one policy, and whoever reads this record has to be able to tell.
+  writeFileSync(temp, JSON.stringify({ url, pid: process.pid, policy, mode, dir }) + "\n", { flag: "wx", mode: 0o600 });
   try {
     // Replacing an existing record must neither inherit its mode nor follow
     // its symlink. Readers see one complete record, including after a crash.
@@ -61,7 +63,12 @@ export function readUiLink(port, base) {
   if (!e || typeof e.url !== "string") return null;
   let alive = null;
   if (Number.isInteger(e.pid) && e.pid > 0) alive = processAlive(e.pid);
-  return { url: e.url, pid: e.pid ?? null, alive, policy: typeof e.policy === "string" ? e.policy : null };
+  return {
+    url: e.url, pid: e.pid ?? null, alive,
+    policy: typeof e.policy === "string" ? e.policy : null,
+    mode: e.mode === "runs" ? "runs" : "policy",
+    dir: typeof e.dir === "string" ? e.dir : null,
+  };
 }
 
 /** Removes the record. Called on exit, and when a stale one is found. */

package/ui/index.html

@@ -447,6 +447,28 @@ button.btn:active,button.tag:active,button.add:active,button.sw:active{transform
     .preview input{width:100%}
     .places li{flex-direction:column;gap:2px}
   }
+
+/* ── a directory of runs (seisin ui --runs) ─────────────────────────────── */
+/* `hidden` has to win over the display these set, or the runs view keeps the policy's nav and cards. */
+.side a[hidden],.side .cap[hidden],.cards[hidden],.range[hidden]{display:none}
+.banner.run{border-left:3px solid var(--blue)}
+.banner.run .meta{color:var(--mid);font-size:12px;margin-top:4px}
+.runs-filters{display:flex;flex-wrap:wrap;gap:10px 16px;align-items:center}
+.runs-filters label{display:flex;gap:6px;align-items:center;font-size:12px;color:var(--mid)}
+.runs-filters select,.runs-filters input{font:inherit;font-size:12px;padding:4px 6px;border:1px solid var(--line);
+  border-radius:6px;background:var(--panel);color:var(--fg);max-width:220px}
+table.runs{width:100%;border-collapse:collapse;font-size:12px}
+table.runs th{text-align:left;font-weight:600;color:var(--dim);padding:6px 10px;border-bottom:1px solid var(--line);white-space:nowrap}
+table.runs td{padding:6px 10px;border-bottom:1px solid var(--line2);vertical-align:top}
+table.runs td.num,table.runs th.num{text-align:right;font-variant-numeric:tabular-nums}
+table.runs td code{font-family:var(--mono);font-size:11px;word-break:break-all}
+table.runs tr.sys td{color:var(--dim)}
+.oc{font-weight:600;font-size:11px;padding:1px 6px;border-radius:9px;border:1px solid var(--line)}
+.oc.clean{color:var(--green);border-color:var(--green)}
+.oc.denied{color:var(--amber);border-color:var(--amber)}
+.oc.refused,.oc.unread{color:var(--fg);background:var(--amber-bg);border-color:var(--amber)}
+.ro-ask{font-size:12px;color:var(--mid);max-width:320px}
+.ro-ask code{font-family:var(--mono)}
 </style>
 </head>
 <body>
@@ -462,7 +484,13 @@ button.btn:active,button.tag:active,button.add:active,button.sw:active{transform
       </div>
     </div>
     <div class="list">
-      <div class="cap">Policy</div>
+      <!-- Over a directory of runs (seisin ui --runs) the first item is every run, and the
+           rest is the one run that is open; with none open, only this one is shown. -->
+      <div id="nav-runs" hidden>
+        <div class="cap">Runs</div>
+        <a href="./" id="nav-all" title="Every run in the directory, read only"><i>☰</i>All runs<span class="pin" id="runs-pin"></span></a>
+      </div>
+      <div class="cap" id="nav-cap">Policy</div>
       <a class="on" href="#requests" id="nav-req" aria-current="page" title="Requests: access an agent asked for and cannot have"><i>⚖</i>Waiting on you<span class="pin" id="req-pin"></span></a>
       <a href="#denied" title="Every denial in the window: what an agent tried and the OS denied"><i>⊘</i>Denied<span class="pin" id="dn-pin"></span></a>
       <a href="#walls" title="A wall: something a role was denied twice or more and would still be denied today"><i>▦</i>Walls<span class="pin" id="wl-pin"></span></a>
@@ -490,6 +518,8 @@ button.btn:active,button.tag:active,button.add:active,button.sw:active{transform
       <code>seisin ui</code> in it.
     </div>
     <div class="banner off" id="off-banner" role="alert" hidden></div>
+    <!-- One run out of a directory of them: who it was, and that nothing here is granted. -->
+    <div class="banner run" id="run-banner" hidden></div>
 
     <div class="head">
       <div>
@@ -533,6 +563,34 @@ button.btn:active,button.tag:active,button.add:active,button.sw:active{transform
         <h2>spent retrying</h2><div class="n" id="c-retry">0</div><div class="s" id="c-retry-s">calls on known walls</div></a>
     </div>
 
+    <!-- Every run in the directory (seisin ui --runs): filtered, summed, newest first. -->
+    <section data-view="runs" hidden>
+      <div class="box">
+        <header>
+          <h2>Filter</h2>
+          <span class="note" id="rn-count"></span>
+        </header>
+        <div class="pad runs-filters" id="rn-filters">
+          <label>team <select data-f="team"></select></label>
+          <label>role <select data-f="role"></select></label>
+          <label>work item <select data-f="work_item"></select></label>
+          <label>status <select data-f="status"></select></label>
+          <label>outcome <select data-f="outcome"></select></label>
+          <label>search <input type="search" id="rn-q" spellcheck="false" autocomplete="off" placeholder="run id, work item, repo"></label>
+        </div>
+      </div>
+      <div class="cards" id="rn-kpis"></div>
+      <div class="box">
+        <header><h2>Denied across these runs</h2><span class="note">the same denial in many runs is one line · the OS's own housekeeping last</span></header>
+        <div class="scrollx"><table class="runs" id="rn-causes"></table></div>
+      </div>
+      <div class="box">
+        <header><h2>Runs</h2><span class="note">newest first · open one to see its policy, its denials and its log</span></header>
+        <div class="scrollx"><table class="runs" id="rn-list"></table></div>
+        <p class="blank quiet" id="rn-more" hidden></p>
+      </div>
+    </section>
+
     <section data-view="roles">
 
     <div class="box">
@@ -587,7 +645,7 @@ button.btn:active,button.tag:active,button.add:active,button.sw:active{transform
     <section data-view="requests" hidden>
       <div class="box" id="requests">
         <header>
-          <h2>Pending decisions</h2>
+          <h2 id="req-h">Pending decisions</h2>
           <span class="note" id="req-note">granting edits seisin.toml · here or in the terminal, never through MCP</span>
           <span class="bulk" id="bulk" hidden>
             <input id="why-all" placeholder="reason, for all of them (required)" aria-label="Reason for declining all">
@@ -656,7 +714,7 @@ button.btn:active,button.tag:active,button.add:active,button.sw:active{transform
     <div class="foot">
       <b id="foot-mode">Preview.</b> <span id="foot-text">Opened as a file, this page edits an example policy in memory and
       shows what would be generated. Nothing is saved; run <b>seisin ui</b> in a repository to see yours.</span><br>
-      The JSON matches <b>@anthropic-ai/sandbox-runtime 0.0.78</b>, whose schema the test suite exercises against the real binary.
+      The JSON is <b>@anthropic-ai/sandbox-runtime</b>'s settings schema, which the test suite exercises against the real binary.
     </div>
   </main>
 </div>
@@ -1245,7 +1303,7 @@ button.btn:active,button.tag:active,button.add:active,button.sw:active{transform
       aria: "instruction files, for every role",
       click: function(){ propose({ protect: !prot }, "ctl-sw-protect", "instructions", "pw"); }
     }));
-    if (!r) { drawPreview(); return; }
+    if (!r) { drawPreview(); if (READONLY) document.querySelectorAll("#pw button").forEach(function(b){ b.disabled = true; }); return; }
     ["ide", "instructions"].forEach(function(f){
       var mine = (r.controlFiles || []).indexOf(f) !== -1;
       var idle = f === "instructions" && !prot;
@@ -1267,6 +1325,9 @@ button.btn:active,button.tag:active,button.add:active,button.sw:active{transform
       }));
     });
     drawPreview();
+    if (READONLY) document.querySelectorAll("#pw button, #ctl button").forEach(function(b){
+      b.disabled = true; b.title = "read only: this run's policy was lent by its launcher";
+    });
   }
 
   async function callControls(body){
@@ -1687,7 +1748,8 @@ button.btn:active,button.tag:active,button.add:active,button.sw:active{transform
     }
 
     set("k-wait", waiting ? "live" : "calm", waiting,
-        waiting ? (waiting === 1 ? "decision" : "decisions") : "nothing to decide");
+        READONLY ? (waiting ? (waiting === 1 ? "request, asked for elsewhere" : "requests, asked for elsewhere") : "nothing asked for")
+          : waiting ? (waiting === 1 ? "decision" : "decisions") : "nothing to decide");
     set("k-open", off ? "alarm" : "calm", off,
         off ? (off === 1 ? "role running unconfined" : "roles running unconfined") : "every role confined");
     set("k-ref", f.total ? "live" : "calm", f.total.toLocaleString(),
@@ -1759,6 +1821,12 @@ button.btn:active,button.tag:active,button.add:active,button.sw:active{transform
     return narrowable(r) && f && f.checked ? { scope: "file", grant: r.target } : { scope: "folder", grant: r.grant };
   }
 
+  /** Read only, where a request goes instead: the launcher that lent the run its territory. */
+  function askedWhere(){
+    var who = RUNINFO && RUNINFO.launcher;
+    return who ? "Not granted here — ask for it in <b>" + esc(who) + "</b>:" : "Not granted here — ask for it where the run was launched:";
+  }
+
   function drawReqs(){
     var host = document.getElementById("reqs");
     pill("req-pin", REQS.length, REQS.length === 1 ? "request" : "requests");
@@ -1776,17 +1844,19 @@ button.btn:active,button.tag:active,button.add:active,button.sw:active{transform
       return '<div class="req' + (r.stale ? ' stale' : '') + '">' +
         '<div class="who">' +
           "<div><b>" + esc(r.role) + "</b> wants to " + esc(r.action) + ' <span class="path">' + esc(r.target) + "</span></div>" +
-          scopeOf(r) + handoffOf(r) + scopeChoice(r, i) +
+          scopeOf(r) + handoffOf(r) + (READONLY ? "" : scopeChoice(r, i)) +
           '<div class="sub"><span class="asked">' + times + "</span>" +
             (w.text ? ' · last <span title="' + escA(w.title) + '">' + esc(w.text) + "</span>" : "") + stale + "</div>" +
           '<div class="err" id="err-' + i + '" role="alert" hidden></div>' +
         "</div>" +
-        '<div class="act">' +
+        (READONLY
+          ? '<div class="act ro-ask">' + askedWhere() + ' <code>' + esc(r.grant) + "</code></div>"
+          : '<div class="act">' +
           '<input id="why-' + i + '" placeholder="reason (required)" aria-label="Reason for ' +
             escA(r.role) + '’s request" aria-describedby="err-' + i + '">' +
           '<button class="btn primary" data-n="' + i + '" data-k="' + escA(r.key) + '" data-d="granted" type="button" data-write>Grant</button>' +
           '<button class="btn" data-n="' + i + '" data-k="' + escA(r.key) + '" data-d="declined" type="button" data-write>Decline</button>' +
-        "</div>" +
+        "</div>") +
       "</div>";
     }).join("");
 
@@ -1829,7 +1899,7 @@ button.btn:active,button.tag:active,button.add:active,button.sw:active{transform
     var bulk = document.getElementById("bulk");
     var btn = document.getElementById("decline-all");
     var why = document.getElementById("why-all");
-    bulk.hidden = REQS.length < 2;
+    bulk.hidden = REQS.length < 2 || READONLY;
     btn.disabled = false;
     var rest = "Decline all (" + REQS.length + ")";
     disarm(btn, rest);
@@ -1979,15 +2049,29 @@ button.btn:active,button.tag:active,button.add:active,button.sw:active{transform
    * server, and it is moved into this tab's storage and wiped from the address
    * bar and the history entry at once.
    */
+  /**
+   * Over a directory of runs, the run that is open: `&run=<id>` in the link a
+   * launcher hands out (beside the token, in the fragment), kept in the query
+   * once the fragment is wiped, so a reload stays on it.
+   */
+  var RUN = (function(){
+    var h = /(?:^#|&)run=([A-Za-z0-9][A-Za-z0-9._-]{0,127})(?:&|$)/.exec(location.hash || "");
+    var q = new URLSearchParams(location.search).get("run");
+    var id = h ? h[1] : q;
+    return id && /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(id) ? id : null;
+  })();
   var TOKEN = (function(){
     var m = /(?:^#|&)t=([a-f0-9]+)/.exec(location.hash || "");
     try {
       if (m) { sessionStorage.setItem("seisin-token", m[1]); }
       var t = m ? m[1] : (sessionStorage.getItem("seisin-token") || "");
-      if (m) history.replaceState(null, "", location.pathname + location.search);
+      if (m) history.replaceState(null, "", location.pathname + (RUN ? "?run=" + encodeURIComponent(RUN) : location.search));
       return t;
     } catch (_) { return m ? m[1] : ""; }
   })();
+  /** "policy" — one seisin.toml, the console as it always was — or "runs", read only. */
+  var MODE = "policy";
+  var READONLY = false;
 
   /** What to tell a person when a request to this server fails. */
   function whyFailed(e, status){
@@ -2050,6 +2134,8 @@ button.btn:active,button.tag:active,button.add:active,button.sw:active{transform
   }
   function stateUrl(){
     var s = sinceIso();
+    if (MODE === "runs" && RUN)
+      return "/api/run?run=" + encodeURIComponent(RUN) + (s ? "&since=" + encodeURIComponent(s) : "");
     return "/api/state" + (s ? "?since=" + encodeURIComponent(s) : "");
   }
   function rangeLabel(){
@@ -2180,7 +2266,7 @@ button.btn:active,button.tag:active,button.add:active,button.sw:active{transform
     if (ASKING[name]) return;
     ASKING[name] = true;
     try {
-      var r = await fetch("/api/settings?role=" + encodeURIComponent(name),
+      var r = await fetch("/api/settings?role=" + encodeURIComponent(name) + (RUN ? "&run=" + encodeURIComponent(RUN) : ""),
                           { cache: "no-store", headers: { "x-seisin-token": TOKEN } });
       var out = await r.json();
       SETTINGS[name] = r.ok ? { settings: out.settings } : { error: out.error || "could not read the settings" };
@@ -2198,6 +2284,12 @@ button.btn:active,button.tag:active,button.add:active,button.sw:active{transform
     try {
       // Opened as a file there is no server to ask; the fetch only printed a CORS error.
       if (location.protocol === "file:") throw new Error("no server");
+      var info = await fetch("/api/info", { cache: "no-store", headers: { "x-seisin-token": TOKEN } });
+      if (info.ok) {
+        var mode = (await info.json()).mode;
+        if (mode === "runs") { MODE = "runs"; READONLY = true; }
+      }
+      if (MODE === "runs" && !RUN) { await bootRuns(); return; }
       got = await fetchState(true);
       // A live server that refuses this tab's token: `seisin ui` was restarted
       // and minted a new one. Falling back to the example here showed a policy
@@ -2236,6 +2328,10 @@ button.btn:active,button.tag:active,button.add:active,button.sw:active{transform
     LIVE = true;
     applyState(s);
     LIVE_LABEL = s.config.replace(/^.*\//, "") + " · live";
+    if (MODE === "runs") {
+      RUNINFO = s.run || null; LIVE_LABEL = "run " + RUN + " · read only"; drawRunBanner();
+      document.getElementById("req-note").textContent = "read only · asked for where the run was launched, not here";
+    }
     label.textContent = LIVE_LABEL;
     label.style.color = "var(--green)";
     // Live, the what-if button goes for good: "run every role unconfined" against a real repo is
@@ -2246,10 +2342,19 @@ button.btn:active,button.tag:active,button.add:active,button.sw:active{transform
     document.getElementById("kill").hidden = true;
     // And so does the card that counts what the button would do: live it could only say 0.
     document.getElementById("k-open").style.display = "none";
-    document.getElementById("toml-note").textContent = "the file on disk, as it stands";
-    document.getElementById("foot-mode").textContent = "Live.";
-    document.getElementById("foot-text").innerHTML =
-      "This page reads <b>" + esc(s.config) + "</b> and the log on disk. Two actions write, each in place and stamped " +
+    // Read only nothing waits on the person here: what the run asked for is asked for where it was launched.
+    if (READONLY) {
+      var nav = document.getElementById("nav-req");
+      nav.childNodes[1].textContent = "Asked for";
+      document.querySelector("#k-wait h2").textContent = "asked for";
+      document.getElementById("req-h").textContent = "What this run asked for";
+    }
+    document.getElementById("toml-note").textContent = READONLY ? "this run's policy, as its launcher archived it" : "the file on disk, as it stands";
+    document.getElementById("foot-mode").textContent = READONLY ? "Live, read only." : "Live.";
+    document.getElementById("foot-text").innerHTML = READONLY
+      ? "This page reads <b>" + esc(s.config) + "</b>, one archived run's policy, and its log. Nothing is written from here: " +
+        "the run's territory was lent by whoever launched it, and access is asked for there."
+      : "This page reads <b>" + esc(s.config) + "</b> and the log on disk. Two actions write, each in place and stamped " +
       "with its reason: a decision on a request, and saving a control-files change after its preview. Territories " +
       "and keys are changed in seisin.toml itself.";
     draw();
@@ -2257,6 +2362,168 @@ button.btn:active,button.tag:active,button.add:active,button.sw:active{transform
     poll();
   }
 
+  /* ── a directory of runs ──────────────────────────────────────────────────
+   * `seisin ui --runs`: every run, filtered and summed, read only. One run opens
+   * as the console always looked — its policy, its denials, its log — with no
+   * grant on it. */
+  var RUNINFO = null;
+  var RFILTER = (function(){
+    var q = new URLSearchParams(location.search), out = {};
+    ["team", "role", "work_item", "status", "outcome", "q"].forEach(function(k){ var v = q.get(k); if (v) out[k] = v; });
+    return out;
+  })();
+  var RLAST = { url: null, etag: null, v: null };
+
+  function runsUrl(){
+    var q = new URLSearchParams();
+    Object.keys(RFILTER).forEach(function(k){ if (RFILTER[k]) q.set(k, RFILTER[k]); });
+    var s = q.toString();
+    return "/api/runs" + (s ? "?" + s : "");
+  }
+  async function fetchRuns(fresh){
+    var url = runsUrl();
+    var h = { "x-seisin-token": TOKEN };
+    if (!fresh && RLAST.etag && RLAST.url === url) h["if-none-match"] = RLAST.etag;
+    var r = await fetch(url, { cache: "no-store", headers: h });
+    if (r.status === 304) return { same: true };
+    if (!r.ok) return { status: r.status };
+    var v = await r.json();
+    RLAST = { url: url, etag: r.headers.get("etag"), v: v };
+    return { v: v };
+  }
+
+  function runMeta(r){
+    var bits = [];
+    if (r.team) bits.push("team <b>" + esc(r.team) + "</b>");
+    if (r.role) bits.push("role <b>" + esc(r.role) + "</b>");
+    if (r.work_item) bits.push("<b>" + esc(r.work_item) + "</b>");
+    if (r.repo) bits.push("repo " + esc(r.repo));
+    if (r.status) bits.push("status " + esc(r.status));
+    var w = when(r.started_at || "");
+    if (w.text) bits.push('started <span title="' + escA(w.title) + '">' + esc(w.text) + "</span>");
+    return bits.join(" · ");
+  }
+  function outcomeTag(o){
+    var says = { clean: "clean", denied: "denied", refused: "canary failed", unread: "policy unreadable" };
+    return '<span class="oc ' + escA(o) + '">' + esc(says[o] || o) + "</span>";
+  }
+
+  function drawRunBanner(){
+    var b = document.getElementById("run-banner");
+    var r = RUNINFO || { id: RUN };
+    b.innerHTML = "<b>Run " + esc(r.run_id || r.id) + "</b> " + outcomeTag(r.outcome || "") +
+      ' · <a href="./">all runs</a>' +
+      '<div class="meta">' + (runMeta(r) || "no run.json: only what its policy and log say") +
+      " · read only: nothing is granted from here</div>";
+    b.hidden = false;
+    document.getElementById("nav-runs").hidden = false;
+  }
+
+  function drawRunsView(v){
+    // The filters: every value any run has, with how many runs have it.
+    document.querySelectorAll("#rn-filters select").forEach(function(sel){
+      var f = sel.dataset.f;
+      var opts = (v.facets[f] || []);
+      var cur = RFILTER[f] || "";
+      sel.innerHTML = '<option value="">all</option>' + opts.map(function(o){
+        return '<option value="' + escA(o.value) + '"' + (o.value === cur ? " selected" : "") + ">" + esc(o.value) + " (" + o.runs + ")</option>";
+      }).join("");
+      sel.disabled = !opts.length;
+    });
+    document.getElementById("rn-count").textContent = v.totals.runs === v.total
+      ? plural(v.total, "run") : plural(v.totals.runs, "run") + " of " + v.total;
+    pill("runs-pin", v.total, v.total === 1 ? "run" : "runs");
+
+    var t = v.totals, k = t.byKind || {};
+    function card(cls, title, n, sub){
+      return '<div class="card kpi ' + cls + '"><h2>' + esc(title) + '</h2><div class="n">' + esc(Number(n).toLocaleString()) +
+        '</div><div class="s">' + sub + "</div></div>";
+    }
+    document.getElementById("rn-kpis").innerHTML =
+      card("b", "runs", t.runs, (t.outcome.denied || 0) + " denied something · " + (t.outcome.clean || 0) + " clean") +
+      card(t.outcome.refused ? "a" : "g", "canary failed", t.outcome.refused || 0, "runs that never started") +
+      card(t.denied ? "a" : "g", "denied", t.denied, (k.file || 0).toLocaleString() + " files · " + (k.network || 0).toLocaleString() + " network") +
+      card(t.retried ? "a" : "g", "spent retrying", t.retried, "calls after the first denial of the same thing");
+
+    var causes = v.causes || [];
+    document.getElementById("rn-causes").innerHTML = causes.length
+      ? "<thead><tr><th>denied</th><th>what</th><th class=num>runs</th><th class=num>times</th><th>teams</th><th>roles</th></tr></thead><tbody>" +
+        causes.map(function(c){
+          return '<tr class="' + (c.about === "system" ? "sys" : "") + '"><td>' + esc(c.action) + "</td><td><code>" + esc(c.target) +
+            "</code></td><td class=num>" + c.runs + "</td><td class=num>" + c.times + "</td><td>" + esc((c.teams || []).join(", ")) +
+            "</td><td>" + esc((c.roles || []).join(", ")) + "</td></tr>";
+        }).join("") + "</tbody>"
+      : '<tbody><tr><td class="blank quiet">Nothing denied in these runs.</td></tr></tbody>';
+
+    var SHOWN = 300, runs = v.runs || [];
+    document.getElementById("rn-list").innerHTML = runs.length
+      ? "<thead><tr><th>run</th><th>started</th><th>team</th><th>role</th><th>work item</th><th>status</th><th>outcome</th>" +
+        "<th class=num>denied</th><th class=num>retried</th><th>hosts denied</th></tr></thead><tbody>" +
+        runs.slice(0, SHOWN).map(function(r){
+          var w = when(r.started_at || "");
+          return "<tr><td><a href=\"./?run=" + encodeURIComponent(r.id) + "#requests\"><code>" + esc(r.run_id || r.id) + "</code></a></td>" +
+            '<td title="' + escA(w.title || "") + '">' + esc(w.text || "") + "</td><td>" + esc(r.team || "") + "</td><td>" + esc(r.role || "") +
+            "</td><td>" + esc(r.work_item || "") + "</td><td>" + esc(r.status || "") + "</td><td>" + outcomeTag(r.outcome) +
+            "</td><td class=num>" + r.denied + "</td><td class=num>" + r.retried + "</td><td>" +
+            (r.hosts || []).slice(0, 3).map(function(h){ return "<code>" + esc(h.target) + "</code>"; }).join(" ") + "</td></tr>";
+        }).join("") + "</tbody>"
+      : '<tbody><tr><td class="blank quiet">' + (v.total ? "No run matches these filters." : "No runs in " + esc(v.dir) + " yet.") + "</td></tr></tbody>";
+    var more = document.getElementById("rn-more");
+    more.hidden = runs.length <= SHOWN;
+    more.textContent = "Showing the newest " + SHOWN + " of " + runs.length + ": narrow the filters for the rest.";
+  }
+
+  function setRunFilter(k, val){
+    if (val) RFILTER[k] = val; else delete RFILTER[k];
+    var q = new URLSearchParams();
+    Object.keys(RFILTER).forEach(function(x){ q.set(x, RFILTER[x]); });
+    history.replaceState(null, "", location.pathname + (q.toString() ? "?" + q : ""));
+    fetchRuns(true).then(function(g){ if (g.v) drawRunsView(g.v); }).catch(function(){});
+  }
+
+  async function bootRuns(){
+    var label = document.getElementById("source");
+    var got = await fetchRuns(true);
+    if (!got.v) {
+      label.textContent = got.status === 403 ? "link expired — open the new one" : "the console did not answer";
+      label.style.color = "var(--amber)";
+      return;
+    }
+    LIVE = true;
+    LIVE_LABEL = "runs · read only";
+    label.textContent = LIVE_LABEL;
+    label.style.color = "var(--green)";
+    document.getElementById("nav-runs").hidden = false;
+    document.getElementById("nav-all").classList.add("on");
+    document.getElementById("nav-cap").hidden = true;
+    document.querySelectorAll(".side .list > a[href^='#']").forEach(function(a){ a.hidden = true; });
+    // Inline, not `hidden`: the cards' own display rules outrank the attribute.
+    ["kpis", "range", "kill"].forEach(function(id){ var e = document.getElementById(id); if (e) { e.hidden = true; e.style.display = "none"; } });
+    document.getElementById("foot-mode").textContent = "Live, read only.";
+    document.getElementById("foot-text").innerHTML = "This page reads the runs in <b>" + esc(got.v.dir) +
+      "</b>, one folder each, as their launcher archived them. Nothing is written from here.";
+    document.querySelectorAll("#rn-filters select").forEach(function(sel){
+      sel.addEventListener("change", function(){ setRunFilter(sel.dataset.f, sel.value); });
+    });
+    var q = document.getElementById("rn-q");
+    q.value = RFILTER.q || "";
+    var tq = null;
+    q.addEventListener("input", function(){ clearTimeout(tq); tq = setTimeout(function(){ setRunFilter("q", q.value.trim()); }, 250); });
+    drawRunsView(got.v);
+    show("runs");
+    (function again(){
+      setTimeout(async function(){
+        try {
+          var g = await fetchRuns(false);
+          if (g.v) drawRunsView(g.v);
+          if (g.v || g.same) { FAILS = 0; if (OFFLINE) setOffline(null); }
+          else if (++FAILS >= 2) setOffline(g.status === 403 ? "expired" : "down");
+        } catch (_) { if (++FAILS >= 2) setOffline("down"); }
+        again();
+      }, 2000);
+    })();
+  }
+
   /** Every two seconds after the last answer, not every two seconds regardless. */
   function poll(){
     setTimeout(async function(){
@@ -2269,11 +2536,15 @@ button.btn:active,button.tag:active,button.add:active,button.sw:active{transform
    * it has to keep working opened straight off the disk with no server at all. */
   function views(){
     return {
+      runs:       {view:"runs",     title:"Runs",
+                   sub:"Every run in the directory, read only: what each was denied and what the denials cost. Open one for its policy and its log."},
       policy:     {view:"roles",    title:"Roles",
                    sub:"Each role's territory — the folders it may write — and the keys it may read. " +
                        (LIVE ? "Read-only here: the policy is seisin.toml." : "In this example you can edit them; nothing is saved.")},
-      requests:   {view:"requests", title:"Waiting on you",
-                   sub:"Requests: access an agent asked for and cannot have. Granting one adds a line to seisin.toml."},
+      requests:   {view:"requests", title: READONLY ? "Asked for" : "Waiting on you",
+                   sub: READONLY
+                     ? "Requests: access this run asked for and did not have. Read only: they are asked for where the run was launched."
+                     : "Requests: access an agent asked for and cannot have. Granting one adds a line to seisin.toml."},
       denied:     {view:"denied",   title:"Denied", tab:"path",
                    sub:"Everything an agent tried in the window and the OS denied, grouped by what it was about."},
       causes:     {view:"denied",   title:"Denied", tab:"name",
@@ -2320,7 +2591,7 @@ button.btn:active,button.tag:active,button.add:active,button.sw:active{transform
   }
 
   /** The landing view is what is waiting on you, not the policy table. */
-  function route(){ return (location.hash || "#requests").slice(1); }
+  function route(){ return MODE === "runs" && !RUN ? "runs" : (location.hash || "#requests").slice(1); }
   window.addEventListener("hashchange", function(){ show(route()); });
   show(route());