@nanobpm/nano-workforce 0.126.0 → 0.128.0

package/.github/workflows/invariants.yml

@@ -11,11 +11,19 @@ name: Whole-repo invariants (merge-skew guard)
 #
 # This lean workflow re-asserts those whole-repo invariants where the merge actually happens:
 #   - `merge_group`  — the queue's PROSPECTIVE merged commit, so a skew is blocked BEFORE it lands.
+#                      THIS is the merge-skew guard: `derived == f(sources_A ∪ sources_B)`.
+#   - `pull_request` — required so the SAME check (matched by job name) also reports on the PR head.
+#                      GitHub's merge queue will not enqueue a PR until every required status check
+#                      has reported on it, and a check that fires only on `merge_group` never does —
+#                      it stays "expected" and the PR can never enter the queue (deadlock). The PR-head
+#                      run also validates the PR's OWN tree (a self-collision / stale artifact the PR
+#                      introduces alone), catching it before the queue rather than at merge time.
 #   - `push: [main]` — a fast backstop that fails a `main`-scoped build within minutes if something
 #                      slipped through, instead of first surfacing on an unrelated open PR.
 #   - `schedule`     — a daily catch-all for any skew introduced by a merge that bypassed the queue.
 on:
   merge_group:
+  pull_request:
   push:
     branches: [main]
   schedule:

package/.github/workflows/pr-title-lint.yml

@@ -7,6 +7,13 @@ name: PR title lint
 on:
   pull_request:
     types: [opened, edited, synchronize, reopened]
+  # Required status checks in the `main` merge queue must ALSO report on the
+  # queue's speculative `merge_group` commit, or the queue stalls forever waiting
+  # for a check that only ran on the PR. A `merge_group` commit has no PR title to
+  # lint (the title was already validated when the PR entered the queue), so the
+  # job runs with its only step skipped and reports success — the green the queue
+  # needs, without re-linting.
+  merge_group:
 
 permissions:
   pull-requests: read
@@ -16,7 +23,8 @@ jobs:
     name: Conventional PR title
     runs-on: ubuntu-latest
     steps:
-      - uses: amannn/action-semantic-pull-request@v5
+      - if: github.event_name == 'pull_request'
+        uses: amannn/action-semantic-pull-request@v5
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:

package/.github/workflows/release.yml

@@ -43,8 +43,14 @@ jobs:
           REPO: ${{ github.repository }}
         run: |
           set -euo pipefail
-          # These must ALL be `success` on the release commit before we ship. Keep
-          # in lock-step with the `main` ruleset's required status checks.
+          # These must ALL be `success` on the release commit before we ship.
+          # This is the `main` ruleset's required-check set MINUS the PR-only
+          # checks: `Conventional PR title` gates the merge queue but never runs
+          # on `push:main` (it has no PR title to lint on a merge commit — see
+          # pr-title-lint.yml), so requiring it here would deadlock every release.
+          # With the merge queue enabled these checks already passed on the
+          # speculative merged commit before it landed; this `push:main` gate is
+          # the backstop. Keep in lock-step with the ruleset's required checks.
           required=("typecheck + test (Node)" "whole-repo invariants")
           # Dedupe to ONE row per check name — the latest run (max .id) — so re-runs
           # can't leave us reading a stale conclusion. Slurp every page into a
@@ -68,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
@@ -101,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

@@ -370,6 +370,43 @@ agents:
 - **Never `git push --force` on `main`;** use `--force-with-lease` on feature
   branches.
 
+### Merging to `main` (merge queue)
+
+`main` is protected by an **active ruleset** with a **GitHub merge queue**. You
+do not merge a PR directly — you **add it to the queue** (UI "Merge when ready",
+or the product merge loop's queued-merge path). The queue then builds the
+**prospective merged commit** (`merge_group`) and only lands it if the required
+checks pass **on that speculative tree**:
+
+- `typecheck + test (Node)`, `whole-repo invariants`, `Conventional PR title`.
+
+`whole-repo invariants` (the merge-skew guard, #366) runs only on the
+`merge_group` commit and on `push:main`, never on a plain PR — so a
+green-in-isolation PR that would collide once merged (a duplicate migration
+prefix, a layout/artifact drift) is **blocked at merge time**, not after it has
+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.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)
+
+
+### Features
+
+* **tasks:** collapse Tasks page to one user_tasks list, complete via engine forms ([#461](https://github.com/nanobpm/nano-workforce/issues/461)) ([#484](https://github.com/nanobpm/nano-workforce/issues/484)) ([bbc0745](https://github.com/nanobpm/nano-workforce/commit/bbc0745ddc7b5f79cfee5096dfbd07cf29ea0f38)), closes [nano-ide#457](https://github.com/nano-ide/issues/457) [#445](https://github.com/nanobpm/nano-workforce/issues/445) [#458](https://github.com/nanobpm/nano-workforce/issues/458)
+
 # [0.126.0](https://github.com/nanobpm/nano-workforce/compare/v0.125.0...v0.126.0) (2026-08-23)
 
 

package/app/agentCompletion.ts

@@ -122,6 +122,17 @@ const ESCALATION_FORM_BY_ELEMENT: Readonly<Record<string, string>> = {
   // (returns `null`) and the completer accepts the captured form variables for the emit binder to type.
 };
 
+/** The fixed `.form` linkage (a `zeebe:formDefinition formId`) that governs a fixed-form escalation
+ *  kind's completion, or `undefined` for a kind with no static form (the delivery-graph `human` node,
+ *  which renders DIFFERENT forms per node — its `formKey` only ever comes from the engine at runtime).
+ *  Exposed so the Tasks-inbox poller can denormalise a row's `form_key` from this SAME single source of
+ *  truth when the raw `/v2/user-tasks/search` result omits the engine-resolved key (issue #461) — the
+ *  REST gateway addresses a deployed form by value whether that value is a deploy key or an authored
+ *  form id, so this id resolves the same deployed `.form` the completer validates against. */
+export function escalationFormId(elementId: string): string | undefined {
+  return ESCALATION_FORM_BY_ELEMENT[elementId];
+}
+
 /** A field's `conditional.hide` rule, parsed from the FEEL subset the `.form` files use
  *  (`=<ref> != "<value>"` / `=<ref> == "<value>"`). A required field is only enforced when it is
  *  actually shown, so an "answer only when resolution=answer" field is not demanded on the abandon

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);

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

@@ -26,6 +26,9 @@ export interface TranscriptSummaryReport {
   readonly bpmnProcessId?: string;
   readonly elementId?: string;
   readonly planKey?: string;
+  readonly instance?: string;
+  readonly identity?: string;
+  readonly host?: string;
 }
 
 /** The transcript list report the cockpit polls (mirrors `AgenticTranscriptList`). */
@@ -54,6 +57,9 @@ export interface TranscriptView {
   readonly byteLength: number;
   /** When the session was captured — completedAt when sealed, else createdAt. */
   readonly capturedAt: string;
+  readonly instance?: string;
+  readonly identity?: string;
+  readonly host?: string;
 }
 
 /** The full renderable "past sessions" view. */
@@ -106,6 +112,9 @@ function sessionView(t: TranscriptSummaryReport): TranscriptView {
     size: humanBytes(t.byteLength),
     byteLength: t.byteLength,
     capturedAt: t.completedAt ?? t.createdAt,
+    ...(t.instance !== undefined ? { instance: t.instance } : {}),
+    ...(t.identity !== undefined ? { identity: t.identity } : {}),
+    ...(t.host !== undefined ? { host: t.host } : {}),
   };
 }