@nanobpm/nano-workforce 0.127.0 → 0.129.0

package/.github/workflows/release.yml

@@ -74,22 +74,45 @@ jobs:
     if: needs.gate.outputs.should_release == 'true'
     runs-on: ubuntu-latest
     permissions:
-      contents: write # create tags, GitHub Releases, push CHANGELOG/version bump
-      issues: write # comment on released issues
-      pull-requests: write # comment on released PRs
+      # The privileged work (push to `main`, tags, Releases, issue/PR comments) is
+      # done with the release App token below — it is the ruleset bypass actor. The
+      # job's own GITHUB_TOKEN only needs OIDC for npm Trusted Publishing.
+      contents: read
       id-token: write # OIDC token for npm Trusted Publishing (no NPM_TOKEN)
     steps:
+      # Mint a short-lived token for the dedicated release GitHub App. This App is
+      # the ruleset's bypass actor, so @semantic-release/git can push the version
+      # bump + tags straight to a protected `main` (the default GITHUB_TOKEN can't:
+      # it isn't — and at repo level can't be — a ruleset bypass actor). See
+      # AGENTS.md "Releases bypass the ruleset via a dedicated App" and the
+      # `main` ruleset's bypass_actors.
+      - name: Mint release App token
+        id: app-token
+        uses: actions/create-github-app-token@v1
+        with:
+          app-id: ${{ secrets.RELEASE_APP_ID }}
+          private-key: ${{ secrets.RELEASE_APP_PRIVATE_KEY }}
+
       - name: Checkout
         uses: actions/checkout@v4
         with:
           ref: ${{ github.event.workflow_run.head_sha }} # release the exact gated commit
           fetch-depth: 0 # semantic-release needs full history + tags
           persist-credentials: true # let @semantic-release/git push the release commit
+          token: ${{ steps.app-token.outputs.token }} # push as the bypass-actor App
+
+      - name: Resolve App bot user id
+        id: app-user
+        env:
+          GH_TOKEN: ${{ steps.app-token.outputs.token }}
+        run: |
+          id="$(gh api "/users/${{ steps.app-token.outputs.app-slug }}[bot]" --jq .id)"
+          echo "id=$id" >> "$GITHUB_OUTPUT"
 
       - name: Configure git author
         run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git config user.name "${{ steps.app-token.outputs.app-slug }}[bot]"
+          git config user.email "${{ steps.app-user.outputs.id }}+${{ steps.app-token.outputs.app-slug }}[bot]@users.noreply.github.com"
 
       - name: Setup Node.js
         uses: actions/setup-node@v4
@@ -107,7 +130,7 @@ jobs:
 
       - name: Release
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_TOKEN: ${{ steps.app-token.outputs.token }} # bypass-actor App token
           # No NPM_TOKEN / NODE_AUTH_TOKEN: publishing uses OIDC Trusted Publishing.
           NPM_CONFIG_PROVENANCE: "true"
         run: npx semantic-release

package/AGENTS.md

@@ -388,6 +388,25 @@ already reddened `main`. Grouping is `ALLGREEN` (SQUASH merge), so any red entry
 invalidates the whole batch. `Conventional PR title` passes through on
 `merge_group` (the title was validated when the PR entered the queue).
 
+### Releases bypass the ruleset via a dedicated App (do not break this)
+
+The ruleset that protects `main` would also reject the **release** automation:
+`semantic-release` (`@semantic-release/git`) pushes the `chore(release): X
+[skip ci]` version/CHANGELOG commit and tags **directly** to `main`, which the
+`pull_request` / `merge_queue` / `required_status_checks` rules forbid.
+
+To allow exactly that push — and nothing else — the `main` ruleset lists a
+**dedicated release GitHub App** as an `Integration` **bypass actor**
+(`bypass_mode: always`). The `Release` workflow mints a short-lived token for
+that App (`actions/create-github-app-token`) and hands it to `semantic-release`;
+the job's own `GITHUB_TOKEN` is scoped to `contents: read` + `id-token: write`
+(OIDC npm publish) and is **not** a bypass actor.
+
+> ⚠️ **Coupling:** the default `GITHUB_TOKEN` cannot be a repo-level ruleset
+> bypass actor, so the release depends on the App bypass actor staying in the
+> ruleset. **Whenever you edit the `main` ruleset, keep the release App in
+> `bypass_actors`** — dropping it wedges every release (GH013 on the push).
+
 ## Distributed fleet: NANO_WORKFORCE_BASE_URL
 
 The abandon and blackboard hooks are how a **distributed worker fleet** calls back

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [0.129.0](https://github.com/nanobpm/nano-workforce/compare/v0.128.0...v0.129.0) (2026-08-23)
+
+
+### Features
+
+* adopt ADR-0065 derived instanceTracking read-models (urban 0.81.0) ([#489](https://github.com/nanobpm/nano-workforce/issues/489)) ([ce25501](https://github.com/nanobpm/nano-workforce/commit/ce255013b383eb4d593526c5f34e74aaab535d25)), closes [#318](https://github.com/nanobpm/nano-workforce/issues/318) [nano-workforce#422](https://github.com/nano-workforce/issues/422) [#76](https://github.com/nanobpm/nano-workforce/issues/76)
+
+# [0.128.0](https://github.com/nanobpm/nano-workforce/compare/v0.127.0...v0.128.0) (2026-08-23)
+
+
+### Features
+
+* **cockpit:** release worker correlation on job end + durable attribution + worker detail history page ([#488](https://github.com/nanobpm/nano-workforce/issues/488)) ([51c1a53](https://github.com/nanobpm/nano-workforce/commit/51c1a539535d6d65177aa4e2e46ff3ce390bec18)), closes [#232](https://github.com/nanobpm/nano-workforce/issues/232)
+
 # [0.127.0](https://github.com/nanobpm/nano-workforce/compare/v0.126.0...v0.127.0) (2026-08-23)
 
 

package/app/abandon.test.ts

@@ -1,7 +1,8 @@
 // Tests for the cooperative abandon-check helpers (issue #76).
 import { test } from "node:test";
-import { assertEquals, assertNotEquals } from "#test-assert";
+import { assertEquals, assertNotEquals, assertRejects } from "#test-assert";
 import type { DataLayer } from "@nanobpm/urban";
+import { withTrackingViews } from "../test/trackingViews.ts";
 import {
   abandonStatusForToken,
   abandonTokenFromUrl,
@@ -26,7 +27,7 @@ function memData(): DataLayer {
       },
     };
   }
-  return { table: (n: string) => tbl(n) } as any as DataLayer;
+  return { table: withTrackingViews((n: string) => tbl(n)) } as any as DataLayer;
 }
 
 async function seedPr(data: DataLayer, pr_key: string, abandon_token: string, status: string) {
@@ -106,3 +107,16 @@ test("abandonStatusForToken derives abandoned from the row status", async () =>
   });
   assertEquals(await abandonStatusForToken(data, "nope"), undefined);
 });
+
+test("abandonStatusForToken fails CLOSED on a non-string derived status", async () => {
+  // A malformed/missing derived_status must never be reported as `abandoned:false`
+  // (that would let a cancelled run proceed with irreversible side effects). It throws
+  // instead, which the operation dispatcher maps to a 500 so the agent's `curl -f` aborts.
+  const data = memData();
+  await data.table("pull_requests", "pr_key").insert({
+    pr_key: "o/r#3",
+    abandon_token: "weird",
+    status: 123,
+  });
+  await assertRejects(() => abandonStatusForToken(data, "weird"), Error, "is not a string");
+});

package/app/abandon.ts

@@ -10,23 +10,28 @@
 // Design invariants (mirroring the blackboard, app/blackboard.ts):
 //   - CAPABILITY URL. The per-PR token IS the credential; the agent curls the exact URL it was
 //     handed in its prompt. An unknown token is a 404 (never leaks which PRs exist).
-//   - DERIVED, not a separate marker. `abandoned` is read straight off `pull_requests.status`,
-//     which Urban's cancel primitive sets to 'abandoned' on cancel (via the `instanceTracking`
-//     `onTerminated.set` patch, applied the instant the instance terminates). No new state to
-//     keep in sync.
+//   - DERIVED, not a separate marker. `abandoned` is read off the PR's ADR-0065 derived tracking
+//     VIEW (`pull_requests__tracking.derived_status`). Since urban 0.81.0 the `instanceTracking`
+//     reconciler no longer WRITES 'abandoned' onto the base row on cancel; it feeds urban's instance
+//     projection and the `onTerminated.set` edge is recomputed on every read as `derived_status`. So
+//     an out-of-band cancel leaves the base `status` at its transient (e.g. `converging`) but the
+//     derived view reports 'abandoned' immediately — reading the view keeps the abort-check correct
+//     with no new state to sync. (`abandonClosedPr`, #352, still writes 'abandoned' onto the base
+//     row directly; the view passes that worker-written terminal through unchanged.)
 //   - ADVISORY. Like the blackboard, this never hard-locks; it narrows an unavoidable
 //     check-then-push (TOCTOU) window to near-zero. Job fencing in the harness (issue #76 layer 2)
 //     is what makes it airtight.
 import type { DataLayer } from "@nanobpm/urban";
 import { publicBaseUrl } from "./blackboard.ts";
+import { trackingTargetFor } from "./instanceTracking.ts";
 
-/** The one app-row status meaning a PR is terminally abandoned — the run must not be worked on
- * further. Two disjoint producers flip a row here, and both are non-completion terminals that must
+/** The one derived-status value meaning a PR is terminally abandoned — the run must not be worked on
+ * further. Two disjoint producers surface a row here, and both are non-completion terminals that must
  * stop a servicing agent:
- *   1. an explicit **cancel** of a live convergence/merge run (Urban's cancel primitive, via the
- *      `instanceTracking` `onTerminated.set` patch), and
+ *   1. an explicit **cancel** of a live convergence/merge run (Urban's cancel primitive terminates
+ *      the instance; the `instanceTracking` `onTerminated.set` edge derives `abandoned` on read), and
  *   2. **`abandonClosedPr`** reconciling a wave-member PR that was **closed on GitHub without
- *      merging** (#352) — for both `pull_requests` and its `plan_tasks`.
+ *      merging** (#352) — for both `pull_requests` and its `plan_tasks` — by writing the base row.
  * Convergence/merge terminal states `converged`/`merged` are NOT abandonment. In either abandoned
  * case a servicing agent should stop, so the abandon-check endpoint treating both as `abandoned:
  * true` is correct. */
@@ -69,32 +74,49 @@ export function abandonTokenFromUrl(url: string | null | undefined): string | un
   }
 }
 
-/** Resolve an abandon token back to its PR key, or undefined when the token is unknown. */
+/** Resolve an abandon token back to its PR key, or undefined when the token is unknown. Reads the
+ * derived tracking VIEW (a strict superset of the base row) so this stays valid post-ADR-0065. */
 export async function prKeyForAbandonToken(
   data: DataLayer,
   token: string,
 ): Promise<string | undefined> {
   if (!token) return undefined;
   const row = await data
-    .table<{ pr_key: string; abandon_token: string | null }>("pull_requests", "pr_key")
+    .table<{ pr_key: string; abandon_token: string | null }>(
+      trackingTargetFor("pull_requests").view,
+      "pr_key",
+    )
     .findOne({ abandon_token: token });
   return row?.pr_key;
 }
 
-/** The abandon status of a PR, or undefined when the token is unknown. */
+/** The abandon status of a PR, or undefined when the token is unknown. Reads the ADR-0065 derived
+ * tracking VIEW's `derived_status`, so an out-of-band-cancelled run (whose base row is still
+ * `converging`) is correctly reported `abandoned: true` the instant the instance terminates. */
 export async function abandonStatusForToken(
   data: DataLayer,
   token: string,
 ): Promise<{ prKey: string; status: string; abandoned: boolean } | undefined> {
   if (!token) return undefined;
+  const target = trackingTargetFor("pull_requests");
   const row = await data
-    .table<{ pr_key: string; abandon_token: string | null; status: string }>(
-      "pull_requests",
-      "pr_key",
-    )
+    .table<
+      { pr_key: string; abandon_token: string | null } & Record<string, unknown>
+    >(target.view, "pr_key")
     .findOne({ abandon_token: token });
   if (!row) return undefined;
-  return { prKey: row.pr_key, status: row.status, abandoned: isAbandoned(row.status) };
+  const rawStatus = row[target.statusColumn];
+  if (typeof rawStatus !== "string") {
+    // Fail CLOSED: a missing/non-string derived_status must never be reported as
+    // `abandoned:false`. The abort brief tells agents to proceed on a 200 with
+    // `abandoned:false`, so surfacing this as a thrown error (→ 500, which trips the
+    // agent's `curl -f` and aborts) is the safe direction for a cancelled run.
+    throw new Error(
+      `abandonStatusForToken: ${target.view}.${target.statusColumn} is not a string`,
+    );
+  }
+  const status = rawStatus;
+  return { prKey: row.pr_key, status, abandoned: isAbandoned(status) };
 }
 
 /** The instruction block appended (verbatim, via `appendPrompt`) to each side-effecting agent's

package/app/agentic/cockpit/cockpit-route.test.ts

@@ -0,0 +1,21 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { parseCockpitRoute } from "./cockpit-route.ts";
+
+test("parses empty and main cockpit hashes as the main route", () => {
+  assert.deepEqual(parseCockpitRoute(""), { kind: "main" });
+  assert.deepEqual(parseCockpitRoute("#/cockpit"), { kind: "main" });
+  assert.deepEqual(parseCockpitRoute("#/cockpit/"), { kind: "main" });
+});
+
+test("parses URL-decoded worker detail hashes", () => {
+  assert.deepEqual(parseCockpitRoute("#/cockpit/worker/wk-a"), { kind: "worker", instance: "wk-a" });
+  assert.deepEqual(parseCockpitRoute("#/cockpit/worker/leaf%2Fwk%201"), { kind: "worker", instance: "leaf/wk 1" });
+});
+
+test("empty worker and junk hashes fall back to the main route", () => {
+  assert.deepEqual(parseCockpitRoute("#/cockpit/worker/"), { kind: "main" });
+  assert.deepEqual(parseCockpitRoute("#/elsewhere"), { kind: "main" });
+  assert.deepEqual(parseCockpitRoute("#/cockpit/worker/%E0%A4%A"), { kind: "main" });
+});

package/app/agentic/cockpit/cockpit-route.ts

@@ -0,0 +1,17 @@
+export type CockpitRoute = { readonly kind: "main" } | { readonly kind: "worker"; readonly instance: string };
+
+/** Parse the cockpit hash route. Unknown or malformed hashes fall back to the main list. */
+export function parseCockpitRoute(hash: string): CockpitRoute {
+  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" };
+  }
+}

package/app/agentic/cockpit/index.ts

@@ -5,6 +5,10 @@
 //
 // The DEMAND×supply matrix, missing-agent-type reds, and diversity-SLO lights are OUT OF SCOPE for
 // this epic (#142) and deferred to the paired enrolment epic #152.
+export {
+  type CockpitRoute,
+  parseCockpitRoute,
+} from "./cockpit-route.ts";
 export {
   bootSupplyCockpit,
   type CreateTerminal,
@@ -51,3 +55,15 @@ export {
   type TranscriptView,
   transcriptsView,
 } from "./transcript-view.ts";
+export {
+  type RenderWorkerDetailOptions,
+  renderWorkerDetail,
+  type WorkerDetailDom,
+} from "./worker-detail-render.ts";
+export {
+  type FoundWorkerDetailView,
+  type MissingWorkerDetailView,
+  type WorkerCurrentJobView,
+  type WorkerDetailView,
+  workerDetailView,
+} from "./worker-detail-view.ts";

package/app/agentic/cockpit/supply-boot-past.test.ts

@@ -138,6 +138,50 @@ test("clicking a past-session button drives a replay", async () => {
   assert.deepEqual(r.terminalWrites, ["PA", "ST"]);
 });
 
+test("opening a worker detail fetches that worker's transcript history and wires replay", async () => {
+  const r = rig();
+  const fetchedFor: Array<string | undefined> = [];
+  const env: SupplyCockpitEnv = {
+    ...r.env,
+    fetchTranscripts: (instance?: string) => {
+      fetchedFor.push(instance);
+      return Promise.resolve(transcripts);
+    },
+  };
+  const cockpit = bootSupplyCockpit(env);
+  await cockpit.refresh();
+  await flush();
+
+  cockpit.openWorker("wk-a");
+  await flush();
+  assert.equal(cockpit.currentRoute.kind, "worker");
+  assert.equal(cockpit.currentRoute.kind === "worker" ? cockpit.currentRoute.instance : undefined, "wk-a");
+  assert.equal(r.host.byData("worker-detail", "wk-a").length, 1, "worker detail header rendered");
+  assert.deepEqual(fetchedFor, [undefined, "wk-a"], "main history is global; detail history is instance-filtered");
+
+  const button = r.host.byClass("cockpit-past-replay").find((b) => b.getAttribute("data-stream") === "job:past");
+  button?.dispatch("click");
+  await flush();
+  assert.equal(cockpit.currentMode, "replay");
+  assert.deepEqual(r.terminalWrites, ["PA", "ST"]);
+});
+
+test("clicking a worker name opens the detail page without breaking current-job drill", async () => {
+  const r = rig();
+  const cockpit = bootSupplyCockpit(r.env);
+  await cockpit.refresh();
+  await flush();
+
+  r.host.byClass("cockpit-worker")[0]?.dispatch("click");
+  await flush();
+  assert.equal(cockpit.currentRoute.kind, "worker");
+  assert.equal(r.host.byData("worker-detail", "wk-a").length, 1);
+
+  r.host.byClass("cockpit-worker-current-job")[0]?.dispatch("click");
+  assert.equal(cockpit.currentMode, "live");
+  assert.equal(cockpit.currentStream, "job:live");
+});
+
 test("replaying after a live drill tears the live stream down and switches to replay", async () => {
   const r = rig();
   const cockpit = bootSupplyCockpit(r.env);

package/app/agentic/cockpit/supply-boot.test.ts

@@ -126,11 +126,11 @@ test("drilling into a worker subscribes its relay stream on connect", async () =
   assert.deepEqual(subs[0]?.payload, { op: "subscribe", stream: "wk-a", from: 0, credit: 1024 });
 });
 
-test("clicking a rendered worker button drills its stream", async () => {
+test("clicking a rendered worker drill button drills its stream", async () => {
   const r = rig();
   const cockpit = bootSupplyCockpit(r.env);
   await cockpit.refresh();
-  const button = r.host.byClass("cockpit-worker").find((b) => b.getAttribute("data-stream") === "wk-a");
+  const button = r.host.byClass("cockpit-worker-drill").find((b) => b.getAttribute("data-stream") === "wk-a");
   button?.dispatch("click");
   assert.equal(cockpit.currentStream, "wk-a");
   assert.equal(r.sockets.length, 1);

package/app/agentic/cockpit/supply-boot.ts

@@ -28,12 +28,15 @@ import {
   TerminalSession,
   type TerminalSink,
 } from "@nanobpm/agentic/cockpit";
+import type { CockpitRoute } from "./cockpit-route.ts";
 import { renderSupply } from "./supply-render.ts";
-import type { SupplyReport } from "./supply-view.ts";
+import type { SupplyReport, SupplyView } from "./supply-view.ts";
 import { supplyView } from "./supply-view.ts";
 import { renderTranscripts, replayTranscript, type TranscriptDataReport } from "./transcript-render.ts";
 import type { TranscriptListReport } from "./transcript-view.ts";
 import { transcriptsView } from "./transcript-view.ts";
+import { renderWorkerDetail } from "./worker-detail-render.ts";
+import { workerDetailView } from "./worker-detail-view.ts";
 
 /** Mounts a terminal into `host` and returns the sink relay output is written to. */
 export type CreateTerminal = (host: ElementLike) => TerminalSink;
@@ -55,7 +58,7 @@ export interface SupplyCockpitEnv {
    * Fetches the captured-session list (`GET /agentic/transcripts`) for the "past sessions" history.
    * Optional: when omitted the past-sessions panel is not rendered (live-only cockpit).
    */
-  readonly fetchTranscripts?: () => Promise<TranscriptListReport>;
+  readonly fetchTranscripts?: (instance?: string) => Promise<TranscriptListReport>;
   /**
    * Fetches a stored transcript's bytes (`GET /agentic/transcripts/{stream}`) for static replay.
    * Required for the "past sessions" replay to work; must be provided together with {@link fetchTranscripts}.
@@ -99,6 +102,12 @@ export interface SupplyCockpitHandle {
   drill(stream: string): void;
   /** Replay a captured past session's stored transcript statically into the terminal (no live worker). */
   replay(stream: string): Promise<void>;
+  /** Open a worker's dedicated detail page. */
+  openWorker(instance: string): void;
+  /** Return to the main worker list. */
+  back(): void;
+  /** The current cockpit route. */
+  readonly currentRoute: CockpitRoute;
   /** The stream currently drilled into or replayed, if any. */
   readonly currentStream: string | undefined;
   /** Whether the terminal is showing a LIVE stream or a REPLAYED transcript (undefined when idle). */
@@ -152,6 +161,9 @@ class SupplyCockpit implements SupplyCockpitHandle {
   // True while a #refreshPast() fetch is in flight, so the supply poll never stacks past-fetches and a
   // hung transcripts endpoint can't accumulate pending calls.
   #pastRefreshing = false;
+  #pastRefreshPending = false;
+  #route: CockpitRoute = { kind: "main" };
+  #view: SupplyView | undefined;
   // Bumped by every start()/stop() so an in-flight #tick() from a previous start cycle can't
   // reschedule after a stop→start race and leave two overlapping poll chains running.
   #generation = 0;
@@ -248,6 +260,10 @@ class SupplyCockpit implements SupplyCockpitHandle {
     return this.#mode;
   }
 
+  get currentRoute(): CockpitRoute {
+    return this.#route;
+  }
+
   /** Reflect the terminal region's playback mode on the panel (title + `data-terminal-mode`). */
   #setMode(mode: TerminalMode | undefined, stream: string | undefined): void {
     this.#mode = mode;
@@ -270,47 +286,75 @@ class SupplyCockpit implements SupplyCockpitHandle {
     }
     if (this.#disposed) return;
     try {
-      renderSupply(this.#listRegion, this.#env.doc, supplyView(report, { staleAfterMs: this.#env.staleAfterMs }), {
-        onDrill: (stream) => this.drill(stream),
-      });
+      this.#view = supplyView(report, { staleAfterMs: this.#env.staleAfterMs });
+      this.#renderRoute();
     } catch (err) {
       this.#env.onError?.(err);
     }
     // Fire-and-forget: the "past sessions" refresh must never gate the supply poll's next tick. A
     // transcripts endpoint that hangs (not just rejects) would otherwise stall #refresh() forever and
     // wedge the live worker list. #refreshPast is single-flight, so a slow fetch can't pile up either.
-    void this.#refreshPast();
+    void this.#refreshPast(this.#route.kind === "worker" ? this.#route.instance : undefined);
+  }
+
+  #renderRoute(): void {
+    const view = this.#view;
+    if (view === undefined) return;
+    if (this.#route.kind === "worker") {
+      renderWorkerDetail(this.#listRegion, this.#env.doc, workerDetailView(view, this.#route.instance), {
+        onBack: () => this.back(),
+        onDrill: (stream) => this.drill(stream),
+      });
+      return;
+    }
+    renderSupply(this.#listRegion, this.#env.doc, view, {
+      onDrill: (stream) => this.drill(stream),
+      onOpenWorker: (instance) => this.openWorker(instance),
+    });
   }
 
   /** Fetch + render the "past sessions" history list, when a transcript source is wired. Independent
    * of the supply fetch: a transcript-endpoint fault (or hang) never blocks the live worker list. */
-  async #refreshPast(): Promise<void> {
+  async #refreshPast(instance?: string): Promise<void> {
     const fetchTranscripts = this.#env.fetchTranscripts;
     if (fetchTranscripts === undefined || this.#pastRegion === undefined) return;
     // Single-flight: while one past-fetch is outstanding (including a hung one), skip starting another
     // so the poll can't stack pending fetches against a slow/unresponsive transcripts endpoint.
-    if (this.#pastRefreshing) return;
+    if (this.#pastRefreshing) {
+      this.#pastRefreshPending = true;
+      return;
+    }
     this.#pastRefreshing = true;
     try {
       let report: TranscriptListReport;
       try {
-        report = await this.#bounded(fetchTranscripts, "transcripts");
+        report = await this.#bounded(() => fetchTranscripts(instance), "transcripts");
       } catch (err) {
         if (this.#disposed) return;
         this.#env.onError?.(err);
         return;
       }
       if (this.#disposed || this.#pastRegion === undefined) return;
+      const currentInstance = this.#route.kind === "worker" ? this.#route.instance : undefined;
+      if (currentInstance !== instance) {
+        this.#pastRefreshPending = true;
+        return;
+      }
       try {
         renderTranscripts(this.#pastRegion, this.#env.doc, transcriptsView(report), {
           onReplay: (stream) => void this.replay(stream),
           ...(this.#mode === "replay" && this.#shownStream !== undefined ? { activeStream: this.#shownStream } : {}),
+          ...(instance !== undefined ? { title: "Job history", emptyText: "No captured sessions for this worker yet." } : {}),
         });
       } catch (err) {
         this.#env.onError?.(err);
       }
     } finally {
       this.#pastRefreshing = false;
+      if (this.#pastRefreshPending && !this.#disposed) {
+        this.#pastRefreshPending = false;
+        void this.#refreshPast(this.#route.kind === "worker" ? this.#route.instance : undefined);
+      }
     }
   }
 
@@ -492,10 +536,32 @@ class SupplyCockpit implements SupplyCockpitHandle {
       replayTranscript(session, data);
       this.#setMode("replay", stream);
       // Re-render the past list so the just-selected session shows as active (best-effort).
-      void this.#refreshPast();
+      void this.#refreshPast(this.#route.kind === "worker" ? this.#route.instance : undefined);
+    } catch (err) {
+      this.#env.onError?.(err);
+    }
+  }
+
+  openWorker(instance: string): void {
+    if (this.#disposed) return;
+    this.#route = { kind: "worker", instance };
+    try {
+      this.#renderRoute();
     } catch (err) {
       this.#env.onError?.(err);
     }
+    void this.#refreshPast(instance);
+  }
+
+  back(): void {
+    if (this.#disposed) return;
+    this.#route = { kind: "main" };
+    try {
+      this.#renderRoute();
+    } catch (err) {
+      this.#env.onError?.(err);
+    }
+    void this.#refreshPast();
   }
 
   dispose(): void {

package/app/agentic/cockpit/supply-render.test.ts

@@ -44,13 +44,22 @@ test("renders one leaf section with a worker row per worker (family, host, jobs,
   assert.equal(rowB?.byClass("cockpit-supply-jobs")[0]?.text(), "—");
 });
 
-test("worker buttons carry the drill stream and fire onDrill on click", () => {
+test("worker name buttons open the worker detail route and the inline terminal drill still drills", () => {
   const host = new FakeElement("body");
   const drilled: string[] = [];
-  renderSupply(host, doc, supplyView(sample), { onDrill: (stream) => drilled.push(stream) });
+  const opened: string[] = [];
+  renderSupply(host, doc, supplyView(sample), {
+    onDrill: (stream) => drilled.push(stream),
+    onOpenWorker: (instance) => opened.push(instance),
+  });
 
-  const button = host.byClass("cockpit-worker").find((b) => b.getAttribute("data-stream") === "wk-a");
-  assert.ok(button, "the worker button was rendered with its stream id");
+  const worker = host.byClass("cockpit-worker").find((b) => b.getAttribute("data-instance") === "wk-a");
+  assert.ok(worker, "the worker name button was rendered with its instance id");
+  worker?.dispatch("click");
+  assert.deepEqual(opened, ["wk-a"]);
+
+  const button = host.byClass("cockpit-worker-drill").find((b) => b.getAttribute("data-stream") === "wk-a");
+  assert.ok(button, "the inline live-terminal drill button was rendered with its stream id");
   button?.dispatch("click");
   assert.deepEqual(drilled, ["wk-a"]);
 });

package/app/agentic/cockpit/supply-render.ts

@@ -23,6 +23,8 @@ import type { Liveness, SupplyLeafView, SupplyView, SupplyWorkerView } from "./s
 export interface RenderSupplyOptions {
   /** Called with a worker's relay stream id when the operator drills into it. */
   readonly onDrill?: (stream: string) => void;
+  /** Called with a worker instance when the operator opens its dedicated detail page. */
+  readonly onOpenWorker?: (instance: string) => void;
 }
 
 /** Handles into the rendered tree the caller may need. */
@@ -54,12 +56,22 @@ function workerRow(doc: DocumentLike, worker: SupplyWorkerView, options: RenderS
   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);
+  const onOpenWorker = options.onOpenWorker;
+  if (onOpenWorker !== undefined) {
+    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);
   button.setAttribute("data-stream", worker.stream);
   const onDrill = options.onDrill;
   if (onDrill !== undefined) {
-    button.addEventListener("click", () => onDrill(worker.stream));
+    drill.addEventListener("click", () => onDrill(worker.stream));
   }
-  nameCell.appendChild(button);
+  nameCell.appendChild(drill);
   row.appendChild(nameCell);
 
   row.appendChild(el(doc, "td", "cockpit-td cockpit-supply-family", worker.family));

package/app/agentic/cockpit/transcript-render.ts

@@ -23,6 +23,10 @@ export interface RenderTranscriptsOptions {
   readonly onReplay?: (stream: string) => void;
   /** The stream currently being replayed, if any — highlighted in the list. */
   readonly activeStream?: string;
+  /** Panel title. Defaults to the global cockpit history label. */
+  readonly title?: string;
+  /** Empty-state copy. Defaults to the global cockpit history copy. */
+  readonly emptyText?: string;
 }
 
 /** Handles into the rendered tree the caller may need. */
@@ -74,14 +78,14 @@ export function renderTranscripts(
   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", options.title ?? "Past sessions"));
   const summary = el(doc, "span", "cockpit-past-summary", view.retention !== undefined ? `${view.count} · 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", options.emptyText ?? "No captured sessions yet.");
     empty.setAttribute("data-empty", "true");
     root.appendChild(empty);
     host.appendChild(root);