@nanobpm/nano-workforce 0.127.0 → 0.128.0

package/app/agentic/families/relay.family.ts

@@ -33,7 +33,8 @@ import {
   type TranscriptStream,
 } from "@nanobpm/agentic/transcript";
 import type { Logger } from "@nanobpm/urban";
-import { currentCorrelation, type JobContext, jobKeyOfStream } from "../correlation.ts";
+import { currentCorrelation, type JobContext, type JobCorrelation, jobKeyOfStream } from "../correlation.ts";
+import { AgenticCorrelationStore } from "../correlation-store.ts";
 import type { AgenticContext, AgenticFamily } from "../registry.ts";
 import { currentPresenceRegistry } from "./presence.family.ts";
 
@@ -89,6 +90,13 @@ interface StreamState {
    * instance is not yet resolvable (a register/produce race), so a later `produce` frame retries.
    */
   linked: boolean;
+  /**
+   * The worker instance a `job:<jobKey>` stream was linked under (H6). Recorded so a stream's release
+   * (completion / disconnect) can tidy the {@link RelayTranscriptService.#jobStreamByInstance}
+   * supersede index, and so the "one job at a time per worker" supersede rule can identify the
+   * instance's prior job stream.
+   */
+  instance?: string;
 }
 
 /**
@@ -99,6 +107,19 @@ interface StreamState {
 export interface CorrelationLink {
   link(instance: string, jobKey: string, context?: JobContext): void;
   releaseJob(jobKey: string): void;
+  /**
+   * The (still-live) engine context for a jobKey, when the write-side exposes it. Optional so the
+   * minimal double in tests need not implement it; the real {@link CorrelationRegistry} does, and the
+   * relay slice reads it at completion to persist a job's process-instance / plan context durably
+   * before the correlation is released (#485).
+   */
+  resolve?(jobKey: string): JobCorrelation | undefined;
+}
+
+/** A worker's durable identity attributes, resolved from the presence registry at completion time. */
+export interface WorkerAttribution {
+  readonly identity?: string;
+  readonly host?: string;
 }
 
 export interface RelayTranscriptServiceOptions {
@@ -137,6 +158,20 @@ export interface RelayTranscriptServiceOptions {
    * ({@link currentPresenceRegistry}). A resolver returning undefined → no linking (advisory).
    */
   readonly instanceForConnection?: (connectionId: string) => string | undefined;
+  /**
+   * Resolve a producing worker instance's durable identity attributes (identity / host) — read at
+   * job-completion time and persisted with the attribution so a PAST session stays attributable to a
+   * worker after it exits (#485). {@link createRelayFamily} wires it to the presence registry; omitted
+   * → attribution is recorded with instance only (still attributable), never an error.
+   */
+  readonly attributionForInstance?: (instance: string) => WorkerAttribution | undefined;
+  /**
+   * The durable worker-attribution store (#485). Omitted → constructed from {@link db} (absent db →
+   * no durable attribution). Injectable so a test can supply an in-memory store.
+   */
+  readonly correlationStore?: AgenticCorrelationStore;
+  /** "Now" as an ISO-8601 instant, injectable for deterministic completion timestamps. */
+  readonly now?: () => string;
 }
 
 /** The minimal per-connection surface the relay handler receives from the hub (a {@link RelayHub} `RelayConnection`). */
@@ -158,19 +193,41 @@ export class RelayTranscriptService {
   /** The transcript store, or `undefined` when no DataLayer is mounted (relay still works, unpersisted). */
   readonly store: TranscriptStore | undefined;
 
+  /** The durable worker-attribution store (#485), or `undefined` when unpersisted. Exposed so the read path can attribute released jobs. */
+  get correlationStore(): AgenticCorrelationStore | undefined {
+    return this.#correlationStore;
+  }
+
   readonly #registry: ConnectionRegistry;
   readonly #log: Logger;
   readonly #streams = new Map<string, StreamState>();
+  /**
+   * The `job:<jobKey>` relay stream each worker instance is CURRENTLY relaying (H6, #149). A worker
+   * relays every job it runs over one long-lived channel connection, one job at a time
+   * (`../correlation.ts`), so that connection never disconnects between jobs — the disconnect-driven
+   * `#reconcile` release never fires. This index lets a NEW job's first `produce` supersede the
+   * worker's PRIOR job (complete its stream → flush transcript + release correlation), so a supply
+   * row shows only the current job instead of accumulating every job the connection ever ran.
+   */
+  readonly #jobStreamByInstance = new Map<string, string>();
   /** The correlation write-side accessor (H6, #149) — resolved per call so a late family mount wins. */
   readonly #correlation: () => CorrelationLink | undefined;
   /** The connection → producing-instance resolver (H6, #149). */
   readonly #instanceForConnection: (connectionId: string) => string | undefined;
+  /** Resolve a worker instance's durable identity attributes for attribution (#485). */
+  readonly #attributionForInstance: (instance: string) => WorkerAttribution | undefined;
+  /** The durable worker-attribution store, or undefined when unpersisted (#485). */
+  readonly #correlationStore: AgenticCorrelationStore | undefined;
+  /** "Now" as an ISO-8601 instant (injectable for deterministic tests). */
+  readonly #now: () => string;
 
   constructor(options: RelayTranscriptServiceOptions) {
     this.#registry = options.registry;
     this.#log = options.log;
     this.#correlation = options.correlation ?? currentCorrelation;
     this.#instanceForConnection = options.instanceForConnection ?? (() => undefined);
+    this.#attributionForInstance = options.attributionForInstance ?? (() => undefined);
+    this.#now = options.now ?? (() => new Date().toISOString());
     // Persistence is advisory: a store that can't be constructed or whose schema can't be applied
     // (locked/permission-denied/unavailable SQLite) must NOT fail the family mount — fall back to
     // running the relay unpersisted rather than tearing down the whole agentic channel.
@@ -188,6 +245,21 @@ export class RelayTranscriptService {
     }
     this.store = store;
 
+    // The durable worker-attribution store (#485) — advisory, same failure posture as the transcript
+    // store: an unbuildable store falls back to no durable attribution, never a mount failure.
+    let correlationStore = options.correlationStore;
+    if (correlationStore === undefined && options.db) {
+      try {
+        correlationStore = new AgenticCorrelationStore(options.db);
+      } catch (err) {
+        this.#log.warn("agentic correlation store unavailable — past sessions unattributed", {
+          err: String(err),
+        });
+        correlationStore = undefined;
+      }
+    }
+    this.#correlationStore = correlationStore;
+
     this.relay = new RelayHub({
       ...options.relay,
       onFenced: (stream, incarnation, current) => {
@@ -357,8 +429,17 @@ export class RelayTranscriptService {
     const correlation = this.#correlation();
     if (!correlation) return;
     try {
+      // One job at a time per worker (`../correlation.ts`): the worker relaying a NEW job's terminal
+      // over its live connection PROVES its prior job finished. Supersede it — complete the prior
+      // stream (flush transcript → durable past session, release its correlation) BEFORE linking the
+      // new one — so the worker's supply row never accumulates jobs the disconnect-driven release
+      // would otherwise strand behind a connection that stays open across jobs.
+      const priorStream = this.#jobStreamByInstance.get(instance);
+      if (priorStream !== undefined && priorStream !== stream) this.completeStream(priorStream);
       correlation.link(instance, jobKey);
       state.linked = true;
+      state.instance = instance;
+      this.#jobStreamByInstance.set(instance, stream);
     } catch (err) {
       // Advisory — never throws into the frame handler. Swallow a throwing injectable correlation and
       // leave the stream UNLINKED so a later `produce` retries the link.
@@ -376,8 +457,17 @@ export class RelayTranscriptService {
     const jobKey = jobKeyOfStream(stream);
     if (jobKey === undefined) return;
     try {
+      // Persist the completed job's durable worker attribution + (best-effort) engine context BEFORE
+      // releasing the live correlation, so a PAST session stays attributable to a worker after it
+      // exits (#485) — the in-memory registry is about to forget it. Advisory, best-effort.
+      this.#persistAttribution(stream, jobKey, state);
       this.#correlation()?.releaseJob(jobKey);
       state.linked = false;
+      // Tidy the supersede index so it never points a released instance at a completed stream and
+      // stays bounded across the worker's lifetime.
+      if (state.instance !== undefined && this.#jobStreamByInstance.get(state.instance) === stream) {
+        this.#jobStreamByInstance.delete(state.instance);
+      }
     } catch (err) {
       // Advisory — never throws into the frame handler. Swallow a throwing injectable correlation and
       // leave `state.linked` true so the flag honestly records that the release did NOT happen (rather
@@ -393,6 +483,41 @@ export class RelayTranscriptService {
     }
   }
 
+  /**
+   * Record a completed job's durable attribution (#485): which worker ran it (instance + presence
+   * identity/host) and its still-live engine context (process instance / plan), keyed by jobKey, so
+   * the transcript read path can attribute the PAST session after the live correlation is released
+   * and after a restart. Advisory — a persistence fault is logged, never thrown into the frame
+   * handler, and never blocks the correlation release.
+   */
+  #persistAttribution(stream: string, jobKey: string, state: StreamState): void {
+    const store = this.#correlationStore;
+    const instance = state.instance;
+    if (store === undefined || instance === undefined || instance === "") return;
+    try {
+      const attribution = this.#attributionForInstance(instance) ?? {};
+      const context = this.#correlation()?.resolve?.(jobKey);
+      store.record({
+        jobKey,
+        stream,
+        instance,
+        completedAt: this.#now(),
+        ...(attribution.identity !== undefined ? { identity: attribution.identity } : {}),
+        ...(attribution.host !== undefined ? { host: attribution.host } : {}),
+        ...(context?.processInstanceKey !== undefined ? { processInstanceKey: context.processInstanceKey } : {}),
+        ...(context?.bpmnProcessId !== undefined ? { bpmnProcessId: context.bpmnProcessId } : {}),
+        ...(context?.elementId !== undefined ? { elementId: context.elementId } : {}),
+        ...(context?.planKey !== undefined ? { planKey: context.planKey } : {}),
+      });
+    } catch (err) {
+      this.#log.warn("agentic correlation attribution persist failed — past session left unattributed", {
+        stream,
+        jobKey,
+        err: String(err),
+      });
+    }
+  }
+
   /**
    * Flush + complete every ephemeral stream whose producer connection is no longer live (the S1
    * registry dropped it on close or liveness timeout), and release its job correlation (H6, #149).
@@ -460,6 +585,10 @@ export function createRelayFamily(options: {
         // are read per call, so this works regardless of family mount order (relay may mount before
         // presence/correlation). Absent registries → no linking, still advisory-correct.
         instanceForConnection: (connectionId) => currentPresenceRegistry()?.instanceForConnection(connectionId),
+        // #485: resolve a completed job's worker attribution (presence identity/host) from the live
+        // presence registry, read per call for the same mount-order independence. Absent → attribution
+        // records instance only.
+        attributionForInstance: (instance) => currentPresenceRegistry()?.attributionOf(instance),
         correlation: currentCorrelation,
       });
       setCurrentRelayTranscriptService(service);

package/app/agentic/transcript-read.test.ts

@@ -5,9 +5,11 @@
 // time-window semantics directly on listTranscripts() — inclusive boundaries, ordering, and the
 // interaction with a missing/invalid createdAt — where a hand-built store lets us fix exact timestamps.
 import { test } from "node:test";
-import type { TranscriptStore, TranscriptStream } from "@nanobpm/agentic/transcript";
-import { assertEquals } from "#test-assert";
-import { listTranscripts } from "./transcript-read.ts";
+import { DatabaseSync } from "node:sqlite";
+import type { SqliteDb, TranscriptStore, TranscriptStream } from "@nanobpm/agentic/transcript";
+import { assert, assertEquals } from "#test-assert";
+import { AgenticCorrelationStore } from "./correlation-store.ts";
+import { correlationFieldsFor, listTranscripts } from "./transcript-read.ts";
 
 /** A read-only TranscriptStore double: list() returns the seeded metas; read() has no retained chunks. */
 function fakeStore(metas: TranscriptStream[]): TranscriptStore {
@@ -70,3 +72,53 @@ test("listTranscripts: a session with an unparseable createdAt is retained regar
   const out = listTranscripts(store, undefined, { since: late });
   assertEquals(new Set(out.map((t) => t.stream)), new Set(["job:bad"]));
 });
+
+function memoryStore(): SqliteDb {
+  const raw = new DatabaseSync(":memory:");
+  return {
+    exec: (sql) => raw.exec(sql),
+    run: (sql, params = []) => raw.prepare(sql).run(...params),
+    all: <T = Record<string, unknown>>(sql: string, params: unknown[] = []): T[] =>
+      raw.prepare(sql).all(...params) as T[],
+  };
+}
+
+test("durable fallback: a released (past) job is attributed from the durable store when the live registry is empty", () => {
+  // The exact past-session case: the live correlation registry no longer holds the job (undefined here),
+  // so worker attribution + context must come from the durable store recorded at completion.
+  const durable = new AgenticCorrelationStore(memoryStore());
+  durable.record({
+    jobKey: "k1",
+    stream: "job:k1",
+    instance: "worker-A",
+    identity: "gpu-box-7",
+    host: "us-east-1a",
+    processInstanceKey: "pi-9",
+    planKey: "acme/repo#42",
+    completedAt: mid,
+  });
+
+  const fields = correlationFieldsFor("job:k1", undefined, durable);
+  assertEquals(fields.jobKey, "k1");
+  assertEquals(fields.instance, "worker-A");
+  assertEquals(fields.identity, "gpu-box-7");
+  assertEquals(fields.host, "us-east-1a");
+  assertEquals(fields.processInstanceKey, "pi-9");
+  assertEquals(fields.planKey, "acme/repo#42");
+});
+
+test("listTranscripts: the instance filter returns only sessions the durable store attributes to that worker", () => {
+  const store = fakeStore([meta("job:k1", early), meta("job:k2", mid), meta("job:k3", late)]);
+  const durable = new AgenticCorrelationStore(memoryStore());
+  durable.record({ jobKey: "k1", stream: "job:k1", instance: "worker-A", completedAt: early });
+  durable.record({ jobKey: "k2", stream: "job:k2", instance: "worker-B", completedAt: mid });
+  durable.record({ jobKey: "k3", stream: "job:k3", instance: "worker-A", completedAt: late });
+
+  const out = listTranscripts(store, undefined, { instance: "worker-A" }, durable);
+  assertEquals(
+    out.map((t) => t.stream),
+    ["job:k3", "job:k1"],
+    "only worker-A's sessions, newest-first",
+  );
+  assert(out.every((t) => t.instance === "worker-A"), "each row is attributed to worker-A");
+});

package/app/agentic/transcript-read.ts

@@ -17,6 +17,7 @@
 import type { TranscriptChunk, TranscriptStore, TranscriptStream } from "@nanobpm/agentic/transcript";
 import type { AgenticTranscript, AgenticTranscriptData } from "../../nano-generated/api-io.d.ts";
 import { type CorrelationRegistry, jobKeyOfStream } from "./correlation.ts";
+import type { AgenticCorrelationStore } from "./correlation-store.ts";
 import { utf8ByteLength } from "./transcript-events.ts";
 
 /** Total captured bytes across a set of retained chunks (UTF-8, the on-the-wire terminal encoding). */
@@ -26,21 +27,34 @@ export function byteLengthOf(chunks: readonly TranscriptChunk[]): number {
   return total;
 }
 
-/** The correlation fields (jobKey + engine context) a stream id resolves to, best-effort. */
+/** The correlation fields (jobKey + engine context + worker attribution) a stream id resolves to, best-effort. */
 interface CorrelationFields {
   jobKey?: string;
   processInstanceKey?: string;
   bpmnProcessId?: string;
   elementId?: string;
   planKey?: string;
+  /** The worker instance that ran the job (durable — survives release / restart). */
+  instance?: string;
+  /** The worker's durable identity, when recorded. */
+  identity?: string;
+  /** The worker's host, when recorded. */
+  host?: string;
 }
 
 /**
- * Resolve a stream id to its correlation fields: the jobKey is always decoded from a `job:<jobKey>`
- * stream id; the engine context (process instance / plan) is added only when the correlation registry
- * still holds the (live) job. Non-job streams yield an empty object.
+ * Resolve a stream id to its correlation fields. The jobKey is always decoded from a `job:<jobKey>`
+ * stream id. Engine context (process instance / plan) + worker attribution (instance / identity /
+ * host) come from the LIVE registry while the job is still linked, and fall back to the DURABLE store
+ * (`AgenticCorrelationStore`) once the job has completed and its live correlation was released — so a
+ * PAST session stays attributable to its worker after the worker exits or the process restarts.
+ * Non-job streams yield an empty object.
  */
-export function correlationFieldsFor(stream: string, correlation: CorrelationRegistry | undefined): CorrelationFields {
+export function correlationFieldsFor(
+  stream: string,
+  correlation: CorrelationRegistry | undefined,
+  durable?: AgenticCorrelationStore | undefined,
+): CorrelationFields {
   const jobKey = jobKeyOfStream(stream);
   if (jobKey === undefined) return {};
   const fields: CorrelationFields = { jobKey };
@@ -51,6 +65,20 @@ export function correlationFieldsFor(stream: string, correlation: CorrelationReg
     if (context.elementId !== undefined) fields.elementId = context.elementId;
     if (context.planKey !== undefined) fields.planKey = context.planKey;
   }
+  // Durable fallback: fill any field the live registry did not supply (a released past session, or a
+  // worker-attribution field the in-memory registry never carried). Live values take precedence.
+  const row = durable?.get(jobKey);
+  if (row) {
+    if (fields.processInstanceKey === undefined && row.processInstanceKey !== undefined) {
+      fields.processInstanceKey = row.processInstanceKey;
+    }
+    if (fields.bpmnProcessId === undefined && row.bpmnProcessId !== undefined) fields.bpmnProcessId = row.bpmnProcessId;
+    if (fields.elementId === undefined && row.elementId !== undefined) fields.elementId = row.elementId;
+    if (fields.planKey === undefined && row.planKey !== undefined) fields.planKey = row.planKey;
+    if (row.instance !== undefined) fields.instance = row.instance;
+    if (row.identity !== undefined) fields.identity = row.identity;
+    if (row.host !== undefined) fields.host = row.host;
+  }
   return fields;
 }
 
@@ -59,6 +87,7 @@ export function toTranscript(
   meta: TranscriptStream,
   store: TranscriptStore,
   correlation: CorrelationRegistry | undefined,
+  durable?: AgenticCorrelationStore | undefined,
 ): AgenticTranscript {
   const chunks = store.read(meta.stream);
   const out: AgenticTranscript = {
@@ -72,12 +101,15 @@ export function toTranscript(
   };
   if (meta.completedAt !== undefined) out.completedAt = meta.completedAt;
   if (meta.firstOffset !== undefined) out.firstOffset = meta.firstOffset;
-  const fields = correlationFieldsFor(meta.stream, correlation);
+  const fields = correlationFieldsFor(meta.stream, correlation, durable);
   if (fields.jobKey !== undefined) out.jobKey = fields.jobKey;
   if (fields.processInstanceKey !== undefined) out.processInstanceKey = fields.processInstanceKey;
   if (fields.bpmnProcessId !== undefined) out.bpmnProcessId = fields.bpmnProcessId;
   if (fields.elementId !== undefined) out.elementId = fields.elementId;
   if (fields.planKey !== undefined) out.planKey = fields.planKey;
+  if (fields.instance !== undefined) out.instance = fields.instance;
+  if (fields.identity !== undefined) out.identity = fields.identity;
+  if (fields.host !== undefined) out.host = fields.host;
   return out;
 }
 
@@ -86,6 +118,8 @@ export interface TranscriptFilter {
   readonly jobKey?: string;
   readonly processInstanceKey?: string;
   readonly planKey?: string;
+  /** The worker instance that ran the session (durable attribution) — powers the worker-history view. */
+  readonly instance?: string;
   /** ISO-8601 lower bound (inclusive) on the session's createdAt. */
   readonly since?: string;
   /** ISO-8601 upper bound (inclusive) on the session's createdAt. */
@@ -95,22 +129,24 @@ export interface TranscriptFilter {
 /**
  * List every captured session projected to the wire shape, sorted newest-first by createdAt (then by
  * stream for a stable tie-break), after applying the (advisory) filters. jobKey / process-instance /
- * plan filters match the correlation-enriched fields; since/until bound createdAt.
+ * plan / instance filters match the correlation-enriched fields; since/until bound createdAt.
  */
 export function listTranscripts(
   store: TranscriptStore,
   correlation: CorrelationRegistry | undefined,
   filter: TranscriptFilter = {},
+  durable?: AgenticCorrelationStore | undefined,
 ): AgenticTranscript[] {
   const sinceMs = filter.since !== undefined ? Date.parse(filter.since) : undefined;
   const untilMs = filter.until !== undefined ? Date.parse(filter.until) : undefined;
   const rows = store
     .list()
-    .map((meta) => toTranscript(meta, store, correlation))
+    .map((meta) => toTranscript(meta, store, correlation, durable))
     .filter((t) => {
       if (filter.jobKey !== undefined && t.jobKey !== filter.jobKey) return false;
       if (filter.processInstanceKey !== undefined && t.processInstanceKey !== filter.processInstanceKey) return false;
       if (filter.planKey !== undefined && t.planKey !== filter.planKey) return false;
+      if (filter.instance !== undefined && t.instance !== filter.instance) return false;
       const createdMs = Date.parse(t.createdAt);
       if (sinceMs !== undefined && Number.isFinite(createdMs) && createdMs < sinceMs) return false;
       if (untilMs !== undefined && Number.isFinite(createdMs) && createdMs > untilMs) return false;
@@ -134,6 +170,7 @@ export function readTranscriptFrom(
   from: number,
   store: TranscriptStore,
   correlation: CorrelationRegistry | undefined,
+  durable?: AgenticCorrelationStore | undefined,
 ): AgenticTranscriptData | undefined {
   const meta = store.get(stream);
   if (meta === undefined) return undefined;
@@ -152,11 +189,14 @@ export function readTranscriptFrom(
     entries,
   };
   if (meta.completedAt !== undefined) out.completedAt = meta.completedAt;
-  const fields = correlationFieldsFor(meta.stream, correlation);
+  const fields = correlationFieldsFor(meta.stream, correlation, durable);
   if (fields.jobKey !== undefined) out.jobKey = fields.jobKey;
   if (fields.processInstanceKey !== undefined) out.processInstanceKey = fields.processInstanceKey;
   if (fields.bpmnProcessId !== undefined) out.bpmnProcessId = fields.bpmnProcessId;
   if (fields.elementId !== undefined) out.elementId = fields.elementId;
   if (fields.planKey !== undefined) out.planKey = fields.planKey;
+  if (fields.instance !== undefined) out.instance = fields.instance;
+  if (fields.identity !== undefined) out.identity = fields.identity;
+  if (fields.host !== undefined) out.host = fields.host;
   return out;
 }

package/db/migrations/078_agentic_correlation.sql

@@ -0,0 +1,32 @@
+-- Durable per-job worker attribution + engine context (#485, provisioning #232).
+--
+-- The in-memory correlation registry (app/agentic/correlation.ts) is the live jobKey ⇄ worker join,
+-- but it is RELEASED on job end / worker disconnect and is empty after a restart. So a COMPLETED
+-- (past) session — what the cockpit "past sessions" / worker-history view reads — otherwise loses
+-- which worker ran it (instance / identity / host) and its process-instance / plan context. The
+-- package-mirrored transcript store (024_agentic_transcript.sql, byte-for-byte guarded) carries no
+-- correlation columns, so this app-side table closes the gap WITHOUT touching that mirrored schema.
+--
+-- The relay slice records a row here at job-completion time; the transcript read path falls back to
+-- it when the live registry has released the job. Advisory / read-only (ADR 0056) — it NEVER gates a
+-- BPMN sequence flow.
+--
+-- Single source of truth: this DDL mirrors AGENTIC_CORRELATION_SCHEMA_SQL in
+-- app/agentic/correlation-store.ts byte-for-byte; a drift-guard test (correlation-store.test.ts) pins
+-- the two together.
+CREATE TABLE IF NOT EXISTS agentic_correlation (
+  job_key TEXT PRIMARY KEY,
+  stream TEXT NOT NULL,
+  instance TEXT NOT NULL,
+  identity TEXT,
+  host TEXT,
+  process_instance_key TEXT,
+  bpmn_process_id TEXT,
+  element_id TEXT,
+  plan_key TEXT,
+  linked_at TEXT,
+  completed_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS ix_agentic_correlation_instance ON agentic_correlation (instance);
+CREATE INDEX IF NOT EXISTS ix_agentic_correlation_process_instance ON agentic_correlation (process_instance_key);
+CREATE INDEX IF NOT EXISTS ix_agentic_correlation_plan ON agentic_correlation (plan_key);

package/openapi.yaml

@@ -646,6 +646,16 @@ components:
         planKey:
           type: string
           description: The plan / epic key this job was part of (e.g. owner/repo#142), when still known (advisory).
+        instance:
+          type: string
+          description: The worker instance that ran the session, recovered from durable attribution — present even
+            after the worker exited or the process restarted (advisory).
+        identity:
+          type: string
+          description: The worker's durable identity (presence identity), when recorded (advisory).
+        host:
+          type: string
+          description: The worker's host, when recorded (advisory).
     AgenticTranscriptList:
       type: object
       description: The list of captured agent sessions (past + open) — the cockpit "past sessions" feed.
@@ -742,6 +752,15 @@ components:
         planKey:
           type: string
           description: The plan / epic key, when still known (advisory).
+        instance:
+          type: string
+          description: The worker instance that ran the session, from durable attribution (advisory).
+        identity:
+          type: string
+          description: The worker's durable identity, when recorded (advisory).
+        host:
+          type: string
+          description: The worker's host, when recorded (advisory).
         entries:
           type: array
           description: The retained chunks with `offset >= from`, in offset order.
@@ -2448,6 +2467,13 @@ paths:
           schema:
             type: string
           description: Return only transcripts whose (still-known) correlation names this plan / epic key.
+        - name: instance
+          in: query
+          required: false
+          schema:
+            type: string
+          description: Return only sessions run by this worker instance (durable attribution) — powers the
+            per-worker history view. Survives worker exit / process restart.
         - name: since
           in: query
           required: false

package/operations/getAgenticTranscript.ts

@@ -28,13 +28,14 @@ export default defineOperation("getAgenticTranscript", async ({ params, query, r
     return { status: 400, body: { error: "invalid from: expected a non-negative integer offset" } };
   }
 
-  const store = currentRelayTranscriptService()?.store;
+  const service = currentRelayTranscriptService();
+  const store = service?.store;
   if (!store) {
     // No transcript store mounted (relay unmounted or unpersisted) - nothing to replay.
     return { status: 404, body: { error: "no transcript for stream" } };
   }
 
-  const data = readTranscriptFrom(params.stream, from, store, currentCorrelation());
+  const data = readTranscriptFrom(params.stream, from, store, currentCorrelation(), service?.correlationStore);
   if (data === undefined) {
     return { status: 404, body: { error: "no transcript for stream" } };
   }

package/operations/listAgenticTranscripts.ts

@@ -47,10 +47,11 @@ export default defineOperation("listAgenticTranscripts", async ({ query, req },
     ...(query.jobKey !== undefined ? { jobKey: query.jobKey } : {}),
     ...(query.processInstanceKey !== undefined ? { processInstanceKey: query.processInstanceKey } : {}),
     ...(query.planKey !== undefined ? { planKey: query.planKey } : {}),
+    ...(query.instance !== undefined ? { instance: query.instance } : {}),
     ...(query.since !== undefined ? { since: query.since } : {}),
     ...(query.until !== undefined ? { until: query.until } : {}),
   };
-  const transcripts = listTranscripts(store, currentCorrelation(), filter);
+  const transcripts = listTranscripts(store, currentCorrelation(), filter, service?.correlationStore);
   const body: AgenticTranscriptList = {
     count: transcripts.length,
     generatedAt: new Date().toISOString(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.127.0",
+  "version": "0.128.0",
   "description": "Nano Workforce — an Agent Graph Orchestration application for Agentic SDLC: durable BPMN processes that coordinate a graph of AI agents across the software delivery lifecycle.",
   "type": "module",
   "main": "main.ts",

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;