@monster-orange/den 0.4.15 → 0.4.17

package/src/ui/server/public/shell.js

@@ -62,8 +62,9 @@
  *   setOrgs([{ id, title, workspaces? }], currentId, onSelect?)
  *                                    two or more: the Org ▾ menu; a pick
  *                                    calls onSelect(id), fires `den:org`
- *   setWorkspaces({ label, title, items, focus, onSelect })
+ *   setWorkspaces({ label, title, items, focus, names, onSelect })
  *                                    the Workspace ▾ menu (header.js)
+ *   workspaceNames()                 every workspace's name, from it
  *   syncEnv()                        repaint Env ▾ from #env-sel
  *   registerCommand({ id, label, keywords?, kind?, run })
  *                                    a ⌘K palette row (R17, dev.20). label
@@ -77,6 +78,8 @@
  *   unregisterCommand(id), commands()
  *   openMenu(anchor, menu)           a .pop menu below anchor (the scope
  *                                    parts' and the user menu's)
+ *   topLayer.show(el, anchor, opts)  a page's own menu in the top layer
+ *                                    (0.4.17), placed by anchor; hide(el)
  *
  * Loading before shell.js: push functions onto window.denShellQueue (an
  * array); each runs with denShell once it exists, and a later push runs at
@@ -160,6 +163,8 @@
     "b.down.one": "{n} down",
     "act.pin": "Pin",
     "act.unpin": "Unpin",
+    "act.visit": "Visit",
+    "act.visitX": "Visit {s} (opens a new tab)",
     "act.pinX": "Pin {s}",
     "act.unpinX": "Unpin {s}",
     "toast.pinned": "Pinned {s}",
@@ -220,6 +225,8 @@
     "kind.app": "App",
     "kind.action": "Action",
     "kind.setting": "Setting",
+    "kind.workspace": "Workspace",
+    "pal.goWs": "Go to workspace {ws}",
     "pal.repos": "{n} repos",
     "pal.repos.one": "{n} repo",
     "pal.restart": "Restart {s}",
@@ -366,12 +373,18 @@
     "err.signin.title": "Sign in to {name}",
     "err.signin.where":
       "You're opening {name} from another computer. {name} runs on {host}, so it needs to know this is you.",
-    "err.signin.githubNote":
-      "Uses your GitHub account. The owner of this {name} has to have linked theirs.",
-    "err.signin.githubNoOwner":
-      "Sign in with GitHub needs an owner, and this {name} has none yet. On {host} (not this computer), run:",
+    "err.signin.ghStep1":
+      "On {host}, run {cmd}, or use Settings › Access there.",
+    "err.signin.ghStep2":
+      "It shows a code. Enter it at github.com/login/device and approve.",
+    "err.signin.ghStep3":
+      "Then come back here and press Sign in with GitHub, with the same GitHub account.",
+    "err.signin.ghOwner": "Owner: @{login}",
+    "err.signin.ghOnly":
+      "Only the owner's GitHub account can sign in this way. For anyone else, use Approve this computer.",
+    "err.signin.ghLearn": "Learn more",
     "err.signin.githubRefused":
-      "@{login} isn't the owner of this {name}. Ask the owner to add you, or use 'Approve this computer'.",
+      "@{login} isn't the owner of this {name}. Only the owner's account can use Sign in with GitHub. Use Approve this computer instead.",
     "err.signin.approveOr": "Or approve this computer",
     "err.signin.approve": "Approve this computer",
     "err.signin.step1": "On {host} (not this computer), run:",
@@ -599,6 +612,33 @@
     "ag.bring.agent": "Agent {id}",
     "ag.bring.note":
       "Continues it in the folder it ran in, with Den's tools and guards from now on. It keeps running if you close the pane. Close it in any other terminal first: Den only sees a conversation as open if it was written in the last minute.",
+    "ag.keep.model": "Keeps {m} from the conversation.",
+    "ag.keep.modelNew": "Runs on {m} from now on.",
+    "ag.keep.from":
+      "From now on it works as {p}: its role, its permissions ({mode}), Den's tools and guards. Its history stays.",
+    "ag.keep.lost":
+      "It won't have: {s}. Den runs agents with Den's tools only.",
+    "ag.keep.opt": "Keep {m}",
+    "ag.keep.optNone": "Keep the model it runs",
+    "ag.keep.advNote":
+      "The model it runs stays unless you pick another here. Permissions come from the persona.",
+    "ag.pc.item": "Change persona…",
+    "ag.pc.title": "Change {id}'s persona",
+    "ag.pc.note":
+      "Den stops it and resumes the same conversation as the new persona. Its id, name, folder and tab stay.",
+    "ag.pc.go": "Change persona",
+    "ag.pc.going": "Changing…",
+    "ag.pc.current": "current",
+    "ag.pc.busy": "It's working. Change after this turn, or stop it now?",
+    "ag.pc.after": "After this turn",
+    "ag.pc.now": "Stop it now",
+    "ag.pc.fresh":
+      "{id} is now {p}: nothing to resume yet; started fresh (same conversation id, folder and scope)",
+    "ag.freshLine":
+      "Nothing to resume yet; started fresh (same conversation id, folder and scope)",
+    "ag.pc.done": "{id} is now {p}",
+    "ag.pc.pending": "{id} becomes {p} when this turn ends",
+    "ag.more": "More for {id}",
     "ag.bring.go": "Bring in",
     "ag.bring.going": "Bringing in…",
     "ag.bring.done": "Brought in as {id}",
@@ -745,7 +785,11 @@
       "Its token was revoked (web logout --all): stop and resume it, or start it again, to give it a new one",
     "ag.ended":
       "This session has ended. Its record stays until it is resumed or removed.",
+    "ag.switched": "Switched to {p}",
     "ag.exitedLine": "[the session exited{code}]",
+    "ag.refusedUnknown": "the server refused the terminal",
+    "ag.refusedStatus": "the server refused the terminal ({status})",
+    "ag.goWs": "Open {ws} on Workspaces",
     "ag.lost": "[disconnected: {why}]",
     "ag.reconnect": "Reconnect",
     "ag.noBackend":
@@ -1381,6 +1425,116 @@
     return el;
   }
 
+  // ── the top layer (0.4.17): one placement for every menu ─────────────
+  // A menu shown with topShow is in the browser's top layer (a manual
+  // popover), placed by its anchor: below it, above when there's more room
+  // there, kept inside the window. No overflow or stacking ancestor can
+  // clip or cover it, and it stays where it is in the page, so the page's
+  // own click handlers still reach it. It closes when the page hides it
+  // (display: none), its anchor goes, or topHide.
+  var topOpen = [];
+  var TOP_MARGIN = 8;
+  function topSupported(el) {
+    return typeof el.showPopover === "function";
+  }
+  function topPlace(el, anchor, opts) {
+    var r = anchor.getBoundingClientRect();
+    var gap = opts.gap != null ? opts.gap : 4;
+    el.style.maxHeight = "";
+    var w = el.offsetWidth;
+    var h = el.offsetHeight;
+    var vw = window.innerWidth;
+    var vh = window.innerHeight;
+    var below = vh - r.bottom - gap - TOP_MARGIN;
+    var above = r.top - gap - TOP_MARGIN;
+    var up = h > below && above > below;
+    var room = Math.max(80, up ? above : below);
+    if (h > room) {
+      el.style.maxHeight = room + "px";
+      h = room;
+    }
+    var top = up ? r.top - gap - h : r.bottom + gap;
+    var left = opts.align === "right" ? r.right - w : r.left;
+    left = Math.max(TOP_MARGIN, Math.min(left, vw - w - TOP_MARGIN));
+    // Important, so no page or UA rule (a popover's inset) moves it.
+    el.style.setProperty("top", Math.max(TOP_MARGIN, top) + "px", "important");
+    el.style.setProperty("left", left + "px", "important");
+  }
+  function topIndex(el) {
+    for (var i = 0; i < topOpen.length; i++) if (topOpen[i].el === el) return i;
+    return -1;
+  }
+  function topShow(el, anchor, opts) {
+    if (!el || !anchor) return;
+    opts = opts || {};
+    var i = topIndex(el);
+    if (i >= 0) {
+      topOpen[i].anchor = anchor;
+      topOpen[i].opts = opts;
+    } else {
+      if (topSupported(el)) {
+        if (!el.hasAttribute("popover")) {
+          el.setAttribute("popover", "manual");
+          el.setAttribute("data-den-top-added", "");
+        }
+        try {
+          if (!el.matches(":popover-open")) el.showPopover();
+        } catch (e) {
+          /* not in the document yet: placed as fixed */
+        }
+      }
+      var o = { el: el, anchor: anchor, opts: opts, mo: null };
+      if (typeof MutationObserver === "function") {
+        o.mo = new MutationObserver(function () {
+          topCheck(o);
+        });
+        o.mo.observe(el, {
+          attributes: true,
+          attributeFilter: ["style", "class", "hidden"],
+        });
+      }
+      topOpen.push(o);
+    }
+    el.classList.add("den-toplayer");
+    topPlace(el, anchor, opts);
+  }
+  function topHide(el) {
+    var i = topIndex(el);
+    if (i < 0) return;
+    var o = topOpen.splice(i, 1)[0];
+    if (o.mo) o.mo.disconnect();
+    try {
+      if (el.matches && el.matches(":popover-open")) el.hidePopover();
+    } catch (e) {
+      /* already gone */
+    }
+    if (el.hasAttribute("data-den-top-added")) {
+      el.removeAttribute("popover");
+      el.removeAttribute("data-den-top-added");
+    }
+    el.classList.remove("den-toplayer");
+    el.style.removeProperty("top");
+    el.style.removeProperty("left");
+  }
+  /** The page hid it, or its anchor went: it's closed. */
+  function topCheck(o) {
+    if (
+      !o.el.isConnected ||
+      !o.anchor.isConnected ||
+      o.el.hidden ||
+      getComputedStyle(o.el).display === "none"
+    )
+      topHide(o.el);
+  }
+  function topReplace() {
+    topOpen.slice().forEach(function (o) {
+      topCheck(o);
+      if (topIndex(o.el) >= 0) topPlace(o.el, o.anchor, o.opts);
+    });
+  }
+  window.addEventListener("resize", topReplace);
+  document.addEventListener("scroll", topReplace, true);
+
   // ── menus (.pop, R18): the scope parts' popovers ─────────────────────
   // A menu is { label, items: [{ heading } | { hr: true } | { label, tag?,
   // checked?, href?, onSelect? }] }. Rows with `checked` are radios (✓ when
@@ -1392,6 +1546,7 @@
     if (!openPop) return;
     var o = openPop;
     openPop = null;
+    topHide(o.el);
     if (o.el.remove) o.el.remove();
     o.anchor.setAttribute("aria-expanded", "false");
     // aria-controls names the menu only while it exists.
@@ -1467,15 +1622,14 @@
       }
     });
     pop.innerHTML = html;
-    document.body.appendChild(pop);
+    // Inside a modal, in it: anything outside a modal is inert.
+    var host =
+      (anchor.closest && anchor.closest("dialog[open]")) || document.body;
+    host.appendChild(pop);
     openPop = { el: pop, anchor: anchor };
     anchor.setAttribute("aria-expanded", "true");
     anchor.setAttribute("aria-controls", pop.id);
-    var r = anchor.getBoundingClientRect();
-    var w = pop.offsetWidth;
-    pop.style.top = r.bottom + 6 + "px";
-    pop.style.left =
-      Math.max(8, Math.min(r.left, window.innerWidth - w - 8)) + "px";
+    topShow(pop, anchor, { gap: 6 });
     pop.addEventListener("click", function (e) {
       var row = e.target.closest ? e.target.closest(".den-mi") : null;
       if (!row) return;
@@ -1913,7 +2067,14 @@
    * a link to manage them. onSelect(value, focus): choosing a workspace
    * also makes it the CLI default (header.js).
    */
+  // Every workspace's name, from the Workspace menu's model (header.js).
+  var workspaceNameList = [];
+  function workspaceNames() {
+    return workspaceNameList.slice();
+  }
   function setWorkspaces(model) {
+    workspaceNameList =
+      model && Array.isArray(model.names) ? model.names.slice() : [];
     var btn = document.getElementById("ws-pill");
     if (!btn) return;
     var sep = btn.nextElementSibling;
@@ -4347,6 +4508,7 @@
     setOrg: setOrg,
     setOrgs: setOrgs,
     setWorkspaces: setWorkspaces,
+    workspaceNames: workspaceNames,
     /** Repaint the Env part from #env-sel (after setting its value). */
     syncEnv: syncEnv,
     syncPinToggles: syncPinToggles,
@@ -4355,6 +4517,12 @@
     commands: commands,
     /** A .pop menu below `anchor` (the model as the scope menus'). */
     openMenu: openMenu,
+    /**
+     * The top layer (0.4.17): show(el, anchor, { align: "left"|"right",
+     * gap }) puts a page's own menu above everything, placed by its
+     * anchor; hide(el). The page hiding it (display: none) closes it too.
+     */
+    topLayer: { show: topShow, hide: topHide },
     closeMenu: function () {
       closeMenu(false);
     },
@@ -4514,6 +4682,13 @@
     "  max-height: calc(100vh - 72px); overflow-y: auto; box-sizing: border-box;",
     "  font: 14px/1.45 var(--sans); color: var(--text); }",
     ".den-pop:focus { outline: none; }",
+    // The top layer (0.4.17): a page's menu placed by its anchor (topShow), not
+    // where the UA puts a popover.
+    // No inset here: top and left are topPlace's (an !important inset beat them,
+    // and every menu sat at the window's corner, 0.4.17-dev.0).
+    ".den-toplayer { position: fixed !important; margin: 0 !important;",
+    "  right: auto !important; bottom: auto !important; z-index: 1000; overflow-y: auto;",
+    "  color: var(--text); }",
     // LK-1: the admin-password prompt is a <dialog> in the top layer (a popover, or
     // a modal over another modal): placed by its top/left, no UA box.
     "dialog.den-pop { margin: 0; inset: auto; max-width: none; }",

package/src/ui/server/public/topbar.js

@@ -421,7 +421,15 @@ export function runOf(url, base = "http://localhost/") {
 
 const LS_LAST_RUN = "__DEN_CLI__-last-run";
 const SS_PENDING = "__DEN_CLI__-pending-action";
-const KIND = ["page", "service", "app", "agent", "action", "setting"];
+const KIND = [
+  "page",
+  "service",
+  "app",
+  "agent",
+  "workspace",
+  "action",
+  "setting",
+];
 const kindLabel = (k) =>
   KIND.includes(k)
     ? t(`kind.${k}`)
@@ -906,6 +914,31 @@ function paletteItems() {
       run: () => go(`/agents?open=${encodeURIComponent(x.id)}`),
     });
   }
+  // 0.4.17: Go to workspace <ws>, for every workspace, the front agent's
+  // first (on the Agents page); an agent's name finds its workspace too.
+  const byWs = new Map();
+  const front = document.querySelector("#agr")?.dataset.ws;
+  if (front) byWs.set(front, []);
+  // Every workspace: the Workspace menu's list (the header read it).
+  for (const ws of s?.workspaceNames?.() ?? [])
+    if (!byWs.has(ws)) byWs.set(ws, []);
+  for (const x of palSessions) {
+    if (!x.workspace) continue;
+    const names = byWs.get(x.workspace) ?? [];
+    names.push(x.label, x.displayName ?? "", x.persona ?? "");
+    byWs.set(x.workspace, names);
+  }
+  const wsBase =
+    s?.nav?.().find((n) => n.id === "local-dev")?.href ?? "/local-dev";
+  for (const [ws, names] of byWs)
+    items.push({
+      key: `ws:${ws}`,
+      kind: "workspace",
+      label: t("pal.goWs", { ws }),
+      keywords: [ws, "workspace", "workspaces", ...names.filter(Boolean)],
+      hideEmpty: true,
+      run: () => go(`${wsBase}?ws=${encodeURIComponent(ws)}`),
+    });
   if (s?.nav?.().some((n) => n.id === "agents"))
     items.push({
       key: "agent:start",

package/src/ui/server/public/view-scope.js

@@ -0,0 +1,61 @@
+/**
+ * One rule for org and workspace on a page (0.4.17, ORG-SPEC §5): a page
+ * shows its own org picker only when it filters by org. Otherwise it
+ * follows the top bar's View (Org and Workspace ▾), and says so with the
+ * same note. Environments and Releases both use this.
+ *
+ *   viewScope()            → { scope: "all" | <workspace>, inView: [names] }
+ *   viewNoteHtml(view)     → the "Follows the top bar" note's HTML
+ *   viewQuery(view)        → "&workspace=<ws>" for one workspace, else ""
+ *   viewRepos(view)        → the repos in view (a Set), or null for all
+ */
+
+const esc = (s) =>
+  String(s ?? "").replace(
+    /[&<>"']/g,
+    (c) =>
+      ({
+        "&": "&amp;",
+        "<": "&lt;",
+        ">": "&gt;",
+        '"': "&quot;",
+        "'": "&#39;",
+      })[c],
+  );
+
+/** The top bar's View: all active workspaces, or one. */
+export async function viewScope() {
+  const v = await fetch("/api/scope", { headers: { accept: "json" } })
+    .then((r) => (r.ok ? r.json() : null))
+    .catch(() => null);
+  return {
+    scope: typeof v?.scope === "string" && v.scope ? v.scope : "all",
+    inView: Array.isArray(v?.inView) ? v.inView : [],
+  };
+}
+
+/** The same note on every page that follows the View. */
+export function viewNoteHtml(view) {
+  const what =
+    view.scope === "all"
+      ? "all active workspaces"
+      : `workspace <b>${esc(view.scope)}</b>`;
+  return `<span class="note view-note" data-view="${esc(view.scope)}">Shows ${what}, as the top bar's View. Change it there.</span>`;
+}
+
+/** The health and services query for the View: one workspace, or none. */
+export function viewQuery(view) {
+  return view.scope === "all"
+    ? ""
+    : `&workspace=${encodeURIComponent(view.scope)}`;
+}
+
+/** The repos in the View's workspace, or null when it is all active. */
+export async function viewRepos(view) {
+  if (view.scope === "all") return null;
+  const d = await fetch("/api/workspaces", { headers: { accept: "json" } })
+    .then((r) => (r.ok ? r.json() : null))
+    .catch(() => null);
+  const ws = d?.workspaces?.[view.scope];
+  return ws ? new Set(Object.keys(ws.services ?? {})) : null;
+}

package/src/ui/server/public/workspace-picker.js

@@ -93,6 +93,8 @@ export function buildScopeMenuModel(scope, data, t = enT) {
   return {
     label: active.length === 0 ? t("ws.noneLabel") : (one ?? t("ws.all")),
     items,
+    // Every workspace, active or not: ⌘K's Go to workspace (0.4.17).
+    names: Object.keys(data?.workspaces ?? {}),
     focus: focus ?? null,
     title: t(focus ? "ws.viewTitleFocus" : "ws.viewTitle", {
       ws: inView.join(", ") || t("ws.noneLabel"),

package/src/ui/server/route-classes.ts

@@ -127,6 +127,8 @@ export const ROUTES: readonly RouteEntry[] = [
     "/api/release/config",
     "/api/release/status",
     "/api/release/runs",
+    // 0.4.17: each repo's last test run, from the run-history file.
+    "/api/runs/last",
     "/api/release/branches",
     "/api/release/deploy/active",
     "/api/changelog",
@@ -367,6 +369,11 @@ export const ROUTES: readonly RouteEntry[] = [
     "/api/workspaces/:ws/agents/:id/fresh",
     "starts an agent afresh: a runtime in a PTY",
   ),
+  S(
+    ["POST"],
+    "/api/workspaces/:ws/agents/:id/persona",
+    "changes an agent's persona (AG-18): its session stops and the same conversation resumes, a runtime in a PTY; a person's only",
+  ),
   S(
     ["POST"],
     "/api/workspaces/:ws/agents/:id/relaunch",
@@ -468,6 +475,7 @@ export const REGEX_ROUTES: Readonly<Record<string, readonly string[]>> = {
     "/api/workspaces/:ws/agents/:id/remove",
     "/api/workspaces/:ws/agents/:id/name",
     "/api/workspaces/:ws/agents/:id/paths",
+    "/api/workspaces/:ws/agents/:id/persona",
   ],
   "agent-routes.ts:RUNTIME_PATH": ["/api/agents/runtimes/:id/path"],
   "agent-routes.ts:PERSONA_PATH": ["/api/personas/:id"],

package/src/ui/server/run-history.ts

@@ -0,0 +1,181 @@
+/**
+ * The server's test-run history (0.4.17): every `/api/run` from every
+ * browser, kept in `<state>/run-history.jsonl`, one JSON line per start and
+ * one per end. Workspaces' "Last test run" column reads each repo's latest
+ * from it, so it fills in whoever ran it and survives a restart.
+ *
+ * The file is bounded: past MAX_LINES it keeps the newest KEEP_LINES.
+ * Never throws: a history it can't read or write is an empty one.
+ */
+import * as fs from "fs";
+import * as path from "path";
+
+/** One test run, as its lines describe it. */
+export interface RunEntry {
+  id: string;
+  pillar: string;
+  env: string;
+  /** The repos it tested (the pillar's sources), when known. */
+  repos: string[];
+  startedAt: string;
+  endedAt?: string;
+  exitCode?: number;
+}
+
+type Line =
+  | {
+      t: "start";
+      id: string;
+      pillar: string;
+      env: string;
+      repos: string[];
+      at: string;
+    }
+  | { t: "end"; id: string; at: string; exitCode: number };
+
+/** What `reposOfRun` asks about the repos (index.ts gives the real ones). */
+export interface RunRepoSources {
+  /** synthetic, smoke, journeys, security: the repos the pillar reads. */
+  pillarSources(pillar: string): string[];
+  /** suites: the repos whose `tests:` suites the run will run. */
+  suiteRepos(env: string, only: string[]): string[];
+  /** performance: every module's name (a repo's is `<repo>/<module>`). */
+  perfModules(): Promise<string[]>;
+  /** Every repo's name. */
+  repoNames(): string[];
+}
+
+/**
+ * The repos a run tests, for its history (0.4.17): every run kind that
+ * runs a repo's own tests fills its Last test run. integration is Den's
+ * own: no repo. Never throws: a source it can't read gives none.
+ */
+export async function reposOfRun(
+  pillar: string,
+  env: string,
+  modules: string[],
+  src: RunRepoSources,
+): Promise<string[]> {
+  const uniq = (xs: string[]) => [...new Set(xs.filter(Boolean))];
+  try {
+    if (["synthetic", "smoke", "journeys", "security"].includes(pillar))
+      return uniq(src.pillarSources(pillar));
+    if (pillar === "suites") return uniq(src.suiteRepos(env, modules));
+    if (pillar === "performance") {
+      const repos = new Set(src.repoNames());
+      const chosen = modules.length ? modules : await src.perfModules();
+      return uniq(
+        chosen
+          .filter((n) => n.includes("/"))
+          .map((n) => n.split("/")[0])
+          .filter((r) => repos.has(r)),
+      );
+    }
+  } catch {
+    /* no repos known: the history still has the run */
+  }
+  return [];
+}
+
+export const MAX_LINES = 2000;
+export const KEEP_LINES = 1000;
+
+export function runHistoryFile(stateDir: string): string {
+  return path.join(stateDir, "run-history.jsonl");
+}
+
+function append(stateDir: string, line: Line): void {
+  const file = runHistoryFile(stateDir);
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.appendFileSync(file, `${JSON.stringify(line)}\n`, { mode: 0o600 });
+    const text = fs.readFileSync(file, "utf-8");
+    const lines = text.split("\n").filter(Boolean);
+    if (lines.length > MAX_LINES) {
+      const tmp = `${file}.${process.pid}.tmp`;
+      fs.writeFileSync(tmp, `${lines.slice(-KEEP_LINES).join("\n")}\n`, {
+        mode: 0o600,
+      });
+      fs.renameSync(tmp, file);
+    }
+  } catch {
+    /* no history: the column says "—" */
+  }
+}
+
+/** A run began: its pillar, environment and the repos it tests. */
+export function recordRunStart(
+  stateDir: string,
+  run: { id: string; pillar: string; env: string; repos: string[] },
+  now = new Date(),
+): void {
+  append(stateDir, { t: "start", ...run, at: now.toISOString() });
+}
+
+/** A run ended with `exitCode`. */
+export function recordRunEnd(
+  stateDir: string,
+  id: string,
+  exitCode: number,
+  now = new Date(),
+): void {
+  append(stateDir, { t: "end", id, at: now.toISOString(), exitCode });
+}
+
+/** Every run in the file, oldest first. */
+export function readRuns(stateDir: string): RunEntry[] {
+  let text = "";
+  try {
+    text = fs.readFileSync(runHistoryFile(stateDir), "utf-8");
+  } catch {
+    return [];
+  }
+  const byId = new Map<string, RunEntry>();
+  for (const raw of text.split("\n")) {
+    if (!raw) continue;
+    let l: Partial<Line> & Record<string, unknown>;
+    try {
+      l = JSON.parse(raw) as typeof l;
+    } catch {
+      continue;
+    }
+    if (typeof l.id !== "string" || typeof l.at !== "string") continue;
+    if (l.t === "start") {
+      byId.set(l.id, {
+        id: l.id,
+        pillar: String(l.pillar ?? ""),
+        env: String(l.env ?? ""),
+        repos: Array.isArray(l.repos) ? l.repos.map(String) : [],
+        startedAt: l.at,
+      });
+    } else if (l.t === "end") {
+      const r = byId.get(l.id);
+      if (r) {
+        r.endedAt = l.at;
+        r.exitCode = typeof l.exitCode === "number" ? l.exitCode : 1;
+      }
+    }
+  }
+  return [...byId.values()];
+}
+
+/**
+ * Each repo's latest run. A run that never ended counts as running only
+ * while this server runs it (`live`); one a restart cut off has no end and
+ * is skipped for an earlier one.
+ */
+export function lastRunsByRepo(
+  stateDir: string,
+  live: ReadonlySet<string> = new Set(),
+): Record<string, RunEntry & { running: boolean }> {
+  const out: Record<string, RunEntry & { running: boolean }> = {};
+  for (const r of readRuns(stateDir)) {
+    const running = r.endedAt === undefined && live.has(r.id);
+    if (r.endedAt === undefined && !running) continue;
+    for (const repo of r.repos) {
+      const cur = out[repo];
+      if (!cur || cur.startedAt <= r.startedAt) out[repo] = { ...r, running };
+    }
+  }
+  return out;
+}