@nanobpm/nano-workforce 0.127.0 → 0.129.0

package/pages/cockpit/cockpit.css

@@ -119,7 +119,10 @@
 .cockpit-dot[data-liveness="stale"] { background: var(--cockpit-amber); }
 .cockpit-dot[data-liveness="down"] { background: var(--cockpit-red); }
 
-.cockpit-worker {
+.cockpit-worker,
+.cockpit-worker-drill,
+.cockpit-worker-detail-back,
+.cockpit-worker-current-job {
   background: none;
   border: none;
   color: var(--cockpit-text);
@@ -130,7 +133,15 @@
   text-underline-offset: 2px;
 }
 
-.cockpit-worker:hover { color: #58a6ff; }
+.cockpit-worker-drill {
+  color: var(--cockpit-muted);
+  font-size: 12px;
+}
+
+.cockpit-worker:hover,
+.cockpit-worker-drill:hover,
+.cockpit-worker-detail-back:hover,
+.cockpit-worker-current-job:hover { color: #58a6ff; }
 
 .cockpit-supply-process { color: var(--cockpit-muted); }
 
@@ -220,6 +231,58 @@
   padding: 8px 0;
 }
 
+/* ── Worker detail route (#/cockpit/worker/<instance>): header + current job + filtered history. ── */
+
+.cockpit-worker-detail {
+  display: grid;
+  gap: 12px;
+}
+
+.cockpit-worker-detail-back {
+  justify-self: start;
+  color: var(--cockpit-muted);
+}
+
+.cockpit-worker-detail-header {
+  display: grid;
+  gap: 8px;
+}
+
+.cockpit-worker-detail-meta {
+  display: grid;
+  gap: 8px;
+  grid-template-columns: repeat(auto-fit, minmax(140px, 1fr));
+  margin: 0;
+}
+
+.cockpit-worker-detail-meta-item {
+  border: 1px solid rgba(34, 48, 65, 0.7);
+  border-radius: 6px;
+  padding: 8px;
+}
+
+.cockpit-worker-detail-meta-item dt {
+  color: var(--cockpit-muted);
+  font-size: 11px;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+
+.cockpit-worker-detail-meta-item dd {
+  margin: 2px 0 0;
+  overflow-wrap: anywhere;
+}
+
+.cockpit-worker-current {
+  border-top: 1px solid rgba(34, 48, 65, 0.7);
+  padding-top: 10px;
+}
+
+.cockpit-worker-current-empty,
+.cockpit-worker-detail-empty {
+  color: var(--cockpit-muted);
+}
+
 /* Distinguish a live terminal from a replayed (static) past session at a glance. */
 .cockpit-terminal[data-terminal-mode="replay"] {
   border-color: #8957e5;

package/pages/cockpit/mount.js

@@ -27,6 +27,21 @@ function isPosInt(value) {
   return Number.isSafeInteger(value) && value > 0;
 }
 
+function parseCockpitRoute(hash) {
+  const route = hash.startsWith("#") ? hash.slice(1) : hash;
+  if (route === "" || route === "/cockpit" || route === "/cockpit/") return { kind: "main" };
+  const prefix = "/cockpit/worker/";
+  if (!route.startsWith(prefix)) return { kind: "main" };
+  const raw = route.slice(prefix.length);
+  if (raw === "") return { kind: "main" };
+  try {
+    const instance = decodeURIComponent(raw);
+    return instance === "" ? { kind: "main" } : { kind: "worker", instance };
+  } catch {
+    return { kind: "main" };
+  }
+}
+
 // ── supply projection (mirrors app/agentic/cockpit/supply-view.ts) ─────────────────────────────
 
 function liveness(worker, staleAfterMs) {
@@ -97,7 +112,22 @@ function dot(doc, live) {
   return node;
 }
 
-function workerRow(doc, worker, onDrill) {
+function currentJob(worker) {
+  const correlation = worker.correlations[0];
+  if (correlation != null) return { jobKey: correlation.jobKey, stream: correlation.stream, label: correlation.label };
+  const jobKey = worker.jobKeys[0];
+  if (jobKey == null) return undefined;
+  return { jobKey, stream: worker.stream, label: `job ${jobKey}` };
+}
+
+function workerDetailView(view, instance) {
+  const worker = view.workers.find((w) => w.instance === instance);
+  if (worker == null) return { kind: "missing", instance };
+  const job = currentJob(worker);
+  return job == null ? { kind: "found", worker } : { kind: "found", worker, currentJob: job };
+}
+
+function workerRow(doc, worker, onDrill, onOpenWorker) {
   const row = el(doc, "tr", "cockpit-supply-worker");
   row.setAttribute("data-worker", worker.instance);
   row.setAttribute("data-liveness", worker.liveness);
@@ -107,9 +137,16 @@ function workerRow(doc, worker, onDrill) {
   nameCell.appendChild(dot(doc, worker.liveness));
   const button = el(doc, "button", "cockpit-worker", worker.instance);
   button.setAttribute("type", "button");
+  button.setAttribute("data-instance", worker.instance);
   button.setAttribute("data-stream", worker.stream);
-  if (onDrill) button.addEventListener("click", () => onDrill(worker.stream));
+  if (onOpenWorker) button.addEventListener("click", () => onOpenWorker(worker.instance));
   nameCell.appendChild(button);
+  const drill = el(doc, "button", "cockpit-worker-drill", "terminal");
+  drill.setAttribute("type", "button");
+  drill.setAttribute("data-instance", worker.instance);
+  drill.setAttribute("data-stream", worker.stream);
+  if (onDrill) drill.addEventListener("click", () => onDrill(worker.stream));
+  nameCell.appendChild(drill);
   row.appendChild(nameCell);
 
   row.appendChild(el(doc, "td", "cockpit-td cockpit-supply-family", worker.family));
@@ -138,7 +175,7 @@ function workerRow(doc, worker, onDrill) {
   return row;
 }
 
-function leafSection(doc, leaf, onDrill) {
+function leafSection(doc, leaf, onDrill, onOpenWorker) {
   const section = el(doc, "section", "cockpit-leaf");
   section.setAttribute("data-leaf", leaf.token);
   const header = el(doc, "div", "cockpit-leaf-head");
@@ -152,13 +189,13 @@ function leafSection(doc, leaf, onDrill) {
   thead.appendChild(head);
   table.appendChild(thead);
   const tbody = el(doc, "tbody", "cockpit-supply-tbody");
-  for (const worker of leaf.workers) tbody.appendChild(workerRow(doc, worker, onDrill));
+  for (const worker of leaf.workers) tbody.appendChild(workerRow(doc, worker, onDrill, onOpenWorker));
   table.appendChild(tbody);
   section.appendChild(table);
   return section;
 }
 
-function renderSupply(host, doc, view, onDrill) {
+function renderSupply(host, doc, view, onDrill, onOpenWorker) {
   host.replaceChildren();
   const root = el(doc, "div", "cockpit-supply");
   root.setAttribute("data-worker-count", String(view.count));
@@ -177,11 +214,68 @@ function renderSupply(host, doc, view, onDrill) {
     return;
   }
   const list = el(doc, "div", "cockpit-supply-list");
-  for (const leaf of view.leaves) list.appendChild(leafSection(doc, leaf, onDrill));
+  for (const leaf of view.leaves) list.appendChild(leafSection(doc, leaf, onDrill, onOpenWorker));
   root.appendChild(list);
   host.appendChild(root);
 }
 
+function backButton(doc, onBack) {
+  const button = el(doc, "button", "cockpit-worker-detail-back", "\u2190 Workers");
+  button.setAttribute("type", "button");
+  if (onBack) button.addEventListener("click", onBack);
+  return button;
+}
+
+function renderWorkerDetail(host, doc, view, onBack, onDrill) {
+  host.replaceChildren();
+  const root = el(doc, "section", "cockpit-worker-detail");
+  root.appendChild(backButton(doc, onBack));
+  if (view.kind === "missing") {
+    root.setAttribute("data-worker-missing", view.instance);
+    root.appendChild(el(doc, "h1", "cockpit-title", `Worker ${view.instance}`));
+    root.appendChild(el(doc, "div", "cockpit-worker-detail-empty", `Worker ${view.instance} is not in the current supply report.`));
+    host.appendChild(root);
+    return;
+  }
+  const worker = view.worker;
+  root.setAttribute("data-worker-detail", worker.instance);
+  root.setAttribute("data-liveness", worker.liveness);
+  const header = el(doc, "header", "cockpit-worker-detail-header");
+  header.appendChild(el(doc, "h1", "cockpit-title", worker.instance));
+  const meta = el(doc, "dl", "cockpit-worker-detail-meta");
+  for (const [klass, label, value] of [
+    ["identity", "identity", worker.identity],
+    ["host", "host", worker.host],
+    ["family", "family", worker.family],
+    ["liveness", "liveness", worker.liveness],
+  ]) {
+    const item = el(doc, "div", "cockpit-worker-detail-meta-item");
+    item.setAttribute("data-field", klass);
+    item.appendChild(el(doc, "dt", undefined, label));
+    const dd = el(doc, "dd", `cockpit-worker-detail-${klass}`, value);
+    if (klass === "liveness") dd.setAttribute("data-liveness", worker.liveness);
+    item.appendChild(dd);
+    meta.appendChild(item);
+  }
+  header.appendChild(meta);
+  root.appendChild(header);
+  const current = el(doc, "section", "cockpit-worker-current");
+  current.appendChild(el(doc, "h2", "cockpit-panel-title", "Current job"));
+  if (view.currentJob == null) {
+    current.appendChild(el(doc, "div", "cockpit-worker-current-empty", "No active job."));
+  } else {
+    const job = view.currentJob;
+    const button = el(doc, "button", "cockpit-worker-current-job", job.label);
+    button.setAttribute("type", "button");
+    button.setAttribute("data-job-key", job.jobKey);
+    button.setAttribute("data-stream", job.stream);
+    if (onDrill) button.addEventListener("click", () => onDrill(job.stream));
+    current.appendChild(button);
+  }
+  root.appendChild(current);
+  host.appendChild(root);
+}
+
 // ── past-sessions projection + render (mirrors app/agentic/cockpit/transcript-view.ts + -render.ts) ──
 
 function humanBytes(bytes) {
@@ -251,18 +345,18 @@ function sessionRow(doc, session, onReplay, activeStream) {
   return row;
 }
 
-function renderTranscripts(host, doc, view, onReplay, activeStream) {
+function renderTranscripts(host, doc, view, onReplay, activeStream, title = "Past sessions", emptyText = "No captured sessions yet.") {
   host.replaceChildren();
   const root = el(doc, "div", "cockpit-past");
   root.setAttribute("data-session-count", String(view.count));
   const header = el(doc, "header", "cockpit-past-header");
-  header.appendChild(el(doc, "h2", "cockpit-past-title", "Past sessions"));
+  header.appendChild(el(doc, "h2", "cockpit-past-title", title));
   const summary = el(doc, "span", "cockpit-past-summary", view.retention != null ? `${view.count} \u00b7 kept ${view.retention}` : `${view.count}`);
   summary.setAttribute("data-summary", "past");
   header.appendChild(summary);
   root.appendChild(header);
   if (view.count === 0) {
-    const empty = el(doc, "div", "cockpit-past-empty", "No captured sessions yet.");
+    const empty = el(doc, "div", "cockpit-past-empty", emptyText);
     empty.setAttribute("data-empty", "true");
     root.appendChild(empty);
     host.appendChild(root);
@@ -413,12 +507,15 @@ export function mountCockpit(host, opts = {}) {
   let terminal; // the current xterm sink
   let mode; // "live" | "replay" | undefined
   let shownStream;
+  let route = parseCockpitRoute(location.hash);
+  let view;
   // Bumped by every drillInto()/replayInto()/dispose() that claims the terminal region, so a slow
   // replay fetch that resolves after a newer selection drops its result instead of clobbering it.
   let opToken = 0;
   // True while a refreshPast() fetch is outstanding, so the supply poll never stacks past-fetches
   // against a slow/hung transcripts endpoint.
   let pastRefreshing = false;
+  let pastRefreshPending = false;
 
   function setMode(next, stream) {
     mode = next;
@@ -436,6 +533,52 @@ export function mountCockpit(host, opts = {}) {
     terminal = undefined;
   }
 
+  function routeInstance() {
+    return route.kind === "worker" ? route.instance : undefined;
+  }
+
+  function renderRoute() {
+    if (view == null) return;
+    if (route.kind === "worker") {
+      renderWorkerDetail(listRegion, doc, workerDetailView(view, route.instance), backToMain, drillInto);
+      return;
+    }
+    renderSupply(listRegion, doc, view, drillInto, openWorker);
+  }
+
+  function openWorker(instance) {
+    const hash = `#/cockpit/worker/${encodeURIComponent(instance)}`;
+    if (location.hash === hash) {
+      route = { kind: "worker", instance };
+      renderRoute();
+      void refreshPast(instance);
+      return;
+    }
+    location.hash = hash;
+  }
+
+  function backToMain() {
+    if (location.hash === "#/cockpit") {
+      route = { kind: "main" };
+      renderRoute();
+      void refreshPast();
+      return;
+    }
+    location.hash = "#/cockpit";
+  }
+
+  function onHashChange() {
+    route = parseCockpitRoute(location.hash);
+    try {
+      renderRoute();
+    } catch (err) {
+      onError(err);
+    }
+    void refreshPast(routeInstance());
+  }
+
+  window.addEventListener("hashchange", onHashChange);
+
   function drillInto(stream) {
     if (disposed || (mode === "live" && drill?.stream === stream)) return;
     // Claim the terminal region: bump the op token so an in-flight replay drops its stale result.
@@ -503,16 +646,26 @@ export function mountCockpit(host, opts = {}) {
       const session = new TerminalSession({ stream, sink, send: () => {}, from: data.from ?? 0 });
       replayTranscript(session, data);
       setMode("replay", stream);
-      void refreshPast();
+      void refreshPast(routeInstance());
     } catch (err) {
       onError(err);
     }
   }
 
-  async function refreshPast() {
+  function transcriptsListUrl(instance) {
+    if (instance == null) return transcriptsUrl;
+    const url = new URL(transcriptsUrl, location.href);
+    url.searchParams.set("instance", instance);
+    return url.href;
+  }
+
+  async function refreshPast(instance = routeInstance()) {
     // Single-flight: while one past-fetch is outstanding (including a hung one), skip starting another
     // so the supply poll can't stack pending fetches against a slow/unresponsive transcripts endpoint.
-    if (pastRefreshing) return;
+    if (pastRefreshing) {
+      pastRefreshPending = true;
+      return;
+    }
     pastRefreshing = true;
     try {
       let report;
@@ -525,7 +678,7 @@ export function mountCockpit(host, opts = {}) {
         abortTimer.unref?.();
         let res;
         try {
-          res = await fetch(transcriptsUrl, { headers: jsonHeaders(), signal: controller.signal });
+          res = await fetch(transcriptsListUrl(instance), { headers: jsonHeaders(), signal: controller.signal });
         } finally {
           clearTimeout(abortTimer);
         }
@@ -536,13 +689,29 @@ export function mountCockpit(host, opts = {}) {
         return;
       }
       if (disposed) return;
+      if (routeInstance() !== instance) {
+        pastRefreshPending = true;
+        return;
+      }
       try {
-        renderTranscripts(pastRegion, doc, transcriptsView(report), replayInto, mode === "replay" ? shownStream : undefined);
+        renderTranscripts(
+          pastRegion,
+          doc,
+          transcriptsView(report),
+          replayInto,
+          mode === "replay" ? shownStream : undefined,
+          instance == null ? "Past sessions" : "Job history",
+          instance == null ? "No captured sessions yet." : "No captured sessions for this worker yet.",
+        );
       } catch (err) {
         onError(err);
       }
     } finally {
       pastRefreshing = false;
+      if (pastRefreshPending && !disposed) {
+        pastRefreshPending = false;
+        void refreshPast(routeInstance());
+      }
     }
   }
 
@@ -559,12 +728,13 @@ export function mountCockpit(host, opts = {}) {
     }
     if (disposed) return;
     try {
-      renderSupply(listRegion, doc, supplyView(report, staleAfterMs), drillInto);
+      view = supplyView(report, staleAfterMs);
+      renderRoute();
     } catch (err) {
       onError(err);
     }
     // Fire-and-forget: a hung transcripts endpoint must never stall the supply poll's next tick.
-    void refreshPast();
+    void refreshPast(routeInstance());
   }
 
   function tick(gen) {
@@ -594,6 +764,7 @@ export function mountCockpit(host, opts = {}) {
     stop();
     teardownTerminal();
     setMode(undefined, undefined);
+    window.removeEventListener("hashchange", onHashChange);
   }
 
   start();

package/test/trackingViews.ts

@@ -0,0 +1,50 @@
+// Test-only helper: make a hand-rolled fake `DataLayer.table(name)` also serve the ADR-0065 derived
+// tracking VIEWs (`<table>__tracking`) that the real `@nanobpm/urban` runtime auto-provisions.
+//
+// The app's terminal-edge readers (app/abandon.ts, app/lineage.ts, app/conformance.ts, app/retro.ts,
+// app/service.ts) route through `<table>__tracking` and read `derived_status`. The in-memory fakes in
+// the unit tests only model base tables keyed by name, so a read of `pull_requests__tracking` would
+// hit an empty store. Wrapping a fake's `table` resolver with `withTrackingViews` transparently
+// aliases any tracking VIEW onto its base store and projects the derived column.
+//
+// Fidelity: a fake has no engine instance-state, so it can only compute the VIEW's `ELSE
+// base.<statusField>` fall-through branch — which is exactly how these tests model an already-settled
+// PR (they seed the terminal directly onto the base row). So `derived_status := base.<statusField>`
+// reproduces the real view's pass-through semantics for the states unit tests exercise, with zero
+// duplicated view-naming logic (it defers to the app's SSOT resolvers in app/instanceTracking.ts).
+import { baseStatusFieldFor, baseTableForTrackingView, trackingTargetFor } from "../app/instanceTracking.ts";
+
+// biome-ignore lint/suspicious/noExplicitAny: test-only fake `table` resolver over dynamic row shapes.
+type TableFn = (name: string, pk?: string) => any;
+
+/** Decorate a fake `table(name, pk)` resolver so it also serves every `<table>__tracking` derived
+ * VIEW off the corresponding base store, projecting `derived_status := base.<statusField>` onto each
+ * row the read methods (`findOne`/`get`/`find`/`all`) return. A non-tracking name is passed through
+ * untouched, and the VIEW is read-only (writes are never wrapped). */
+export function withTrackingViews<F extends TableFn>(base: F): F {
+  return ((name: string, pk?: string) => {
+    const baseName = baseTableForTrackingView(name);
+    if (!baseName) return base(name, pk);
+    const inner = base(baseName, pk);
+    const derivedColumn = trackingTargetFor(baseName).statusColumn;
+    const statusField = baseStatusFieldFor(baseName);
+    // biome-ignore lint/suspicious/noExplicitAny: test-only projection over dynamic row shapes.
+    const project = (row: any) =>
+      row == null ? row : { ...row, [derivedColumn]: row[statusField] };
+    // biome-ignore lint/suspicious/noExplicitAny: test-only Proxy over a dynamic DataLayer table.
+    return new Proxy(inner, {
+      get(target: any, prop: string) {
+        const value = target[prop];
+        if (typeof value !== "function") return value;
+        const bound = value.bind(target);
+        if (prop === "findOne" || prop === "get") {
+          return async (...args: unknown[]) => project(await bound(...args));
+        }
+        if (prop === "find" || prop === "all") {
+          return async (...args: unknown[]) => (await bound(...args)).map(project);
+        }
+        return bound;
+      },
+    });
+  }) as F;
+}

package/test/worldDb.ts

@@ -7,6 +7,7 @@ import { DatabaseSync, type SQLInputValue } from "node:sqlite";
 import { afterEach } from "node:test";
 import { fileURLToPath } from "node:url";
 import type { DataLayer } from "@nanobpm/urban";
+import { withTrackingViews } from "./trackingViews.ts";
 
 const openDbs = new Set<DatabaseSync>();
 afterEach(() => {
@@ -103,7 +104,7 @@ export function memDataFor(migrationFiles: readonly string[]): { data: DataLayer
     db.exec(sql);
   }
   const data = {
-    table: (name: string, pk = "id") => gateway(db, name, pk),
+    table: withTrackingViews((name: string, pk = "id") => gateway(db, name, pk)),
     open: () => openDataSource(db),
   } as unknown as DataLayer;
   return { data, db };

package/workers/retro-gather/worker.test.ts

@@ -3,6 +3,7 @@ import { assert, assertEquals, assertStringIncludes } from "#test-assert";
 import type { DataLayer } from "@nanobpm/urban";
 import { noopLog } from "../../test/log.ts";
 import { memBlackboardSource } from "../../test/blackboardDb.ts";
+import { withTrackingViews } from "../../test/trackingViews.ts";
 import { appendEntry } from "../../app/blackboard.ts";
 import handler from "./worker.ts";
 
@@ -30,7 +31,7 @@ function memData(): { data: DataLayer; stores: Record<string, any[]> } {
       async update() {},
     };
   }
-  const data = { table: (n: string, pk?: string) => tbl(n, pk), source: memBlackboardSource().source } as any as DataLayer;
+  const data = { table: withTrackingViews((n: string, pk?: string) => tbl(n, pk)), source: memBlackboardSource().source } as any as DataLayer;
   return { data, stores };
 }