@nanobpm/nano-workforce 0.127.0 → 0.128.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,10 @@
+# [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/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 } : {}),
   };
 }
 

package/app/agentic/cockpit/worker-detail-render.test.ts

@@ -0,0 +1,86 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { FakeDocument, FakeElement } from "../../../test/agentic-cockpit-doubles.ts";
+import { renderWorkerDetail } from "./worker-detail-render.ts";
+import { supplyView, type SupplyReport } from "./supply-view.ts";
+import { workerDetailView } from "./worker-detail-view.ts";
+
+const doc = new FakeDocument();
+
+const report: SupplyReport = {
+  count: 1,
+  workers: [
+    {
+      instance: "wk-a",
+      identity: "leaf-1",
+      stream: "job:6494",
+      family: "senior",
+      host: "h1",
+      jobKeys: ["6494"],
+      live: true,
+      staleMs: 0,
+    },
+  ],
+  leaves: [
+    {
+      token: "leaf-1",
+      workers: [
+        {
+          instance: "wk-a",
+          identity: "leaf-1",
+          stream: "job:6494",
+          family: "senior",
+          host: "h1",
+          jobKeys: ["6494"],
+          live: true,
+          staleMs: 0,
+        },
+      ],
+    },
+  ],
+  correlations: [
+    {
+      jobKey: "6494",
+      stream: "job:6494",
+      bpmnProcessId: "plan-fanout",
+      processInstanceKey: "4612",
+      planKey: "o/r#142",
+    },
+  ],
+};
+
+test("derives and renders the worker detail header and current job drill", () => {
+  const host = new FakeElement("body");
+  const drilled: string[] = [];
+  const backed: string[] = [];
+  const detail = workerDetailView(supplyView(report), "wk-a");
+  renderWorkerDetail(host, doc, detail, { onBack: () => backed.push("back"), onDrill: (stream) => drilled.push(stream) });
+
+  assert.equal(host.byData("worker-detail", "wk-a").length, 1);
+  assert.equal(host.byClass("cockpit-worker-detail-identity")[0]?.text(), "leaf-1");
+  assert.equal(host.byClass("cockpit-worker-detail-family")[0]?.text(), "senior");
+  assert.equal(host.byClass("cockpit-worker-detail-host")[0]?.text(), "h1");
+  assert.equal(host.byData("liveness", "live").length >= 1, true);
+
+  const job = host.byClass("cockpit-worker-current-job")[0];
+  assert.equal(job?.getAttribute("data-job-key"), "6494");
+  assert.equal(job?.getAttribute("data-stream"), "job:6494");
+  assert.equal(job?.text(), "plan-fanout · inst 4612 · o/r#142");
+  job?.dispatch("click");
+  assert.deepEqual(drilled, ["job:6494"]);
+
+  host.byClass("cockpit-worker-detail-back")[0]?.dispatch("click");
+  assert.deepEqual(backed, ["back"]);
+});
+
+test("renders a missing-worker detail state with a back action", () => {
+  const host = new FakeElement("body");
+  const backed: string[] = [];
+  renderWorkerDetail(host, doc, workerDetailView(supplyView(report), "missing"), { onBack: () => backed.push("back") });
+
+  assert.equal(host.byData("worker-missing", "missing").length, 1);
+  assert.equal(host.byClass("cockpit-worker-detail-empty")[0]?.text(), "Worker missing is not in the current supply report.");
+  host.byClass("cockpit-worker-detail-back")[0]?.dispatch("click");
+  assert.deepEqual(backed, ["back"]);
+});