@nanobpm/nano-workforce 0.127.0 → 0.128.0

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

@@ -0,0 +1,88 @@
+import type { DocumentLike, ElementLike } from "@nanobpm/agentic/cockpit";
+import type { WorkerDetailView } from "./worker-detail-view.ts";
+
+export interface RenderWorkerDetailOptions {
+  readonly onBack?: () => void;
+  readonly onDrill?: (stream: string) => void;
+}
+
+export interface WorkerDetailDom {
+  readonly root: ElementLike;
+}
+
+function el(doc: DocumentLike, tag: string, className?: string, text?: string): ElementLike {
+  const node = doc.createElement(tag);
+  if (className !== undefined) node.className = className;
+  if (text !== undefined) node.textContent = text;
+  return node;
+}
+
+function backButton(doc: DocumentLike, onBack: (() => void) | undefined): ElementLike {
+  const button = el(doc, "button", "cockpit-worker-detail-back", "← Workers");
+  button.setAttribute("type", "button");
+  if (onBack !== undefined) button.addEventListener("click", onBack);
+  return button;
+}
+
+export function renderWorkerDetail(
+  host: ElementLike,
+  doc: DocumentLike,
+  view: WorkerDetailView,
+  options: RenderWorkerDetailOptions = {},
+): WorkerDetailDom {
+  host.replaceChildren();
+  const root = el(doc, "section", "cockpit-worker-detail");
+  root.appendChild(backButton(doc, options.onBack));
+
+  if (view.kind === "missing") {
+    root.setAttribute("data-worker-missing", view.instance);
+    root.appendChild(el(doc, "h1", "cockpit-title", `Worker ${view.instance}`));
+    root.appendChild(el(doc, "div", "cockpit-worker-detail-empty", `Worker ${view.instance} is not in the current supply report.`));
+    host.appendChild(root);
+    return { root };
+  }
+
+  const worker = view.worker;
+  root.setAttribute("data-worker-detail", worker.instance);
+  root.setAttribute("data-liveness", worker.liveness);
+
+  const header = el(doc, "header", "cockpit-worker-detail-header");
+  const title = el(doc, "h1", "cockpit-title", worker.instance);
+  header.appendChild(title);
+  const meta = el(doc, "dl", "cockpit-worker-detail-meta");
+  for (const [klass, label, value] of [
+    ["identity", "identity", worker.identity],
+    ["host", "host", worker.host],
+    ["family", "family", worker.family],
+    ["liveness", "liveness", worker.liveness],
+  ] as const) {
+    const item = el(doc, "div", "cockpit-worker-detail-meta-item");
+    item.setAttribute("data-field", klass);
+    item.appendChild(el(doc, "dt", undefined, label));
+    const dd = el(doc, "dd", `cockpit-worker-detail-${klass}`, value);
+    if (klass === "liveness") dd.setAttribute("data-liveness", worker.liveness);
+    item.appendChild(dd);
+    meta.appendChild(item);
+  }
+  header.appendChild(meta);
+  root.appendChild(header);
+
+  const current = el(doc, "section", "cockpit-worker-current");
+  current.appendChild(el(doc, "h2", "cockpit-panel-title", "Current job"));
+  if (view.currentJob === undefined) {
+    current.appendChild(el(doc, "div", "cockpit-worker-current-empty", "No active job."));
+  } else {
+    const currentJob = view.currentJob;
+    const button = el(doc, "button", "cockpit-worker-current-job", currentJob.label);
+    button.setAttribute("type", "button");
+    button.setAttribute("data-job-key", currentJob.jobKey);
+    button.setAttribute("data-stream", currentJob.stream);
+    const onDrill = options.onDrill;
+    if (onDrill !== undefined) button.addEventListener("click", () => onDrill(currentJob.stream));
+    current.appendChild(button);
+  }
+  root.appendChild(current);
+
+  host.appendChild(root);
+  return { root };
+}

package/app/agentic/cockpit/worker-detail-view.ts

@@ -0,0 +1,43 @@
+import type { JobCorrelationView, SupplyView, SupplyWorkerView } from "./supply-view.ts";
+
+export interface WorkerCurrentJobView {
+  readonly jobKey: string;
+  readonly stream: string;
+  readonly label: string;
+}
+
+export interface FoundWorkerDetailView {
+  readonly kind: "found";
+  readonly worker: SupplyWorkerView;
+  readonly currentJob?: WorkerCurrentJobView;
+}
+
+export interface MissingWorkerDetailView {
+  readonly kind: "missing";
+  readonly instance: string;
+}
+
+export type WorkerDetailView = FoundWorkerDetailView | MissingWorkerDetailView;
+
+function currentJob(worker: SupplyWorkerView): WorkerCurrentJobView | undefined {
+  const correlation: JobCorrelationView | undefined = worker.correlations[0];
+  if (correlation !== undefined) {
+    return { jobKey: correlation.jobKey, stream: correlation.stream, label: correlation.label };
+  }
+  const jobKey = worker.jobKeys[0];
+  if (jobKey === undefined) return undefined;
+  return { jobKey, stream: worker.stream, label: `job ${jobKey}` };
+}
+
+export function workerDetailView(view: SupplyView, instance: string): WorkerDetailView {
+  const worker = view.workers.find((w) => w.instance === instance);
+  if (worker === undefined) return { kind: "missing", instance };
+  return {
+    kind: "found",
+    worker,
+    ...(() => {
+      const job = currentJob(worker);
+      return job === undefined ? {} : { currentJob: job };
+    })(),
+  };
+}

package/app/agentic/correlation-store.test.ts

@@ -0,0 +1,99 @@
+// Unit tests for the durable worker-attribution store (app/agentic/correlation-store.ts, #485).
+//   - drift guard: db/migrations/078 mirrors AGENTIC_CORRELATION_SCHEMA_SQL;
+//   - record/get/byStream round-trips, including the optional (nullable) engine-context columns;
+//   - upsert semantics (re-recording a jobKey is last-write-wins).
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { test } from "node:test";
+import { fileURLToPath } from "node:url";
+import type { SqliteDb } from "@nanobpm/agentic/transcript";
+import { assert, assertEquals } from "#test-assert";
+import { jobStream } from "./correlation.ts";
+import { AGENTIC_CORRELATION_SCHEMA_SQL, AgenticCorrelationStore } from "./correlation-store.ts";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+
+function memoryDb(): 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("drift guard: migration 078 mirrors AGENTIC_CORRELATION_SCHEMA_SQL", async () => {
+  const migrationPath = join(HERE, "..", "..", "db", "migrations", "078_agentic_correlation.sql");
+  const raw = await readFile(migrationPath, "utf8");
+  const ddl = raw
+    .split("\n")
+    .filter((line) => !line.trimStart().startsWith("--"))
+    .join("\n");
+  const normalise = (s: string) => s.trim().replace(/\s+/g, " ");
+  assertEquals(
+    normalise(ddl),
+    normalise(AGENTIC_CORRELATION_SCHEMA_SQL),
+    "078_agentic_correlation.sql drifted from AGENTIC_CORRELATION_SCHEMA_SQL",
+  );
+  assert(ddl.includes("agentic_correlation"));
+});
+
+test("record + get round-trips full attribution, and byStream decodes the jobKey", () => {
+  const store = new AgenticCorrelationStore(memoryDb());
+  store.record({
+    jobKey: "job-1",
+    stream: jobStream("job-1"),
+    instance: "worker-A",
+    identity: "leaf:token",
+    host: "merlin.local",
+    processInstanceKey: "pi-9",
+    bpmnProcessId: "pr-flow",
+    elementId: "agent",
+    planKey: "owner/repo#142",
+    linkedAt: "2026-08-23T00:00:00.000Z",
+    completedAt: "2026-08-23T00:05:00.000Z",
+  });
+
+  const got = store.get("job-1");
+  assertEquals(got?.instance, "worker-A");
+  assertEquals(got?.identity, "leaf:token");
+  assertEquals(got?.host, "merlin.local");
+  assertEquals(got?.processInstanceKey, "pi-9");
+  assertEquals(got?.planKey, "owner/repo#142");
+  assertEquals(got?.completedAt, "2026-08-23T00:05:00.000Z");
+  // The same row is reachable from the stream id.
+  assertEquals(store.byStream(jobStream("job-1"))?.instance, "worker-A");
+});
+
+test("optional context columns are omitted (not null) when unknown", () => {
+  const store = new AgenticCorrelationStore(memoryDb());
+  store.record({
+    jobKey: "job-2",
+    stream: jobStream("job-2"),
+    instance: "worker-B",
+    completedAt: "2026-08-23T01:00:00.000Z",
+  });
+  const got = store.get("job-2");
+  assertEquals(got?.instance, "worker-B");
+  assert(!("processInstanceKey" in (got ?? {})), "unknown context is omitted, never a null key");
+  assert(!("identity" in (got ?? {})), "unknown identity is omitted");
+});
+
+test("record is an upsert: re-recording a jobKey is last-write-wins", () => {
+  const store = new AgenticCorrelationStore(memoryDb());
+  const base = { jobKey: "job-3", stream: jobStream("job-3"), completedAt: "2026-08-23T02:00:00.000Z" };
+  store.record({ ...base, instance: "worker-C" });
+  store.record({ ...base, instance: "worker-C", host: "second.local", completedAt: "2026-08-23T02:10:00.000Z" });
+  const got = store.get("job-3");
+  assertEquals(got?.host, "second.local");
+  assertEquals(got?.completedAt, "2026-08-23T02:10:00.000Z");
+});
+
+test("get is undefined for an unknown jobKey and byStream undefined for a non-job stream", () => {
+  const store = new AgenticCorrelationStore(memoryDb());
+  assertEquals(store.get("nope"), undefined);
+  assertEquals(store.byStream("worker-A"), undefined);
+  assertEquals(store.get(""), undefined);
+});

package/app/agentic/correlation-store.ts

@@ -0,0 +1,162 @@
+// nano-workforce — the DURABLE jobKey ⇄ worker-attribution store (#485, provisioning #232).
+//
+// The in-memory {@link ./correlation.ts | CorrelationRegistry} is the live join, but it is RELEASED
+// on job end / worker disconnect (`releaseJob` / `releaseInstance`) and is empty after a restart. So a
+// COMPLETED (past) session — the exact case the cockpit "past sessions" / worker-history view reads —
+// loses which worker ran it (instance / identity / host) and its process-instance / plan context: the
+// live registry no longer holds the row, and the package-mirrored transcript store
+// (`db/migrations/024_agentic_transcript.sql`, byte-for-byte guarded) carries no correlation columns.
+//
+// This app-side table closes that gap WITHOUT touching the mirrored transcript schema (exactly the
+// shape #232 called for): at job-completion time the relay slice records the attribution here, keyed
+// by jobKey, so the transcript read path can recover a past session's worker + context after the
+// worker has exited. Advisory / read-only (ADR 0056) — it NEVER gates a BPMN sequence flow.
+//
+// Single source of truth: {@link AGENTIC_CORRELATION_SCHEMA_SQL} is the canonical DDL. It is applied
+// idempotently on store construction (so unit tests over an in-memory DB have the table) AND mirrored
+// byte-for-byte by the forward-only migration `db/migrations/078_agentic_correlation.sql`, which a
+// drift-guard test (`correlation-store.test.ts`) pins so the two can never diverge.
+import type { SqliteDb } from "@nanobpm/agentic/transcript";
+import { jobKeyOfStream } from "./correlation.ts";
+
+/** The canonical DDL for the durable correlation table. The `078_*` migration mirrors this exactly. */
+export const AGENTIC_CORRELATION_SCHEMA_SQL = `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);
+`;
+
+/** One durable attribution row: which worker ran a job, plus its (best-effort) engine context. */
+export interface DurableCorrelation {
+  readonly jobKey: string;
+  readonly stream: string;
+  readonly instance: string;
+  readonly identity?: string;
+  readonly host?: string;
+  readonly processInstanceKey?: string;
+  readonly bpmnProcessId?: string;
+  readonly elementId?: string;
+  readonly planKey?: string;
+  /** When the job was first linked (its first `produce`), ISO-8601, when known. */
+  readonly linkedAt?: string;
+  /** When the job completed (was flushed / released), ISO-8601. */
+  readonly completedAt: string;
+}
+
+/** A row as stored (nullable columns come back as `null`). */
+interface Row {
+  job_key: string;
+  stream: string;
+  instance: string;
+  identity: string | null;
+  host: string | null;
+  process_instance_key: string | null;
+  bpmn_process_id: string | null;
+  element_id: string | null;
+  plan_key: string | null;
+  linked_at: string | null;
+  completed_at: string;
+}
+
+function fromRow(r: Row): DurableCorrelation {
+  const out: DurableCorrelation = {
+    jobKey: r.job_key,
+    stream: r.stream,
+    instance: r.instance,
+    completedAt: r.completed_at,
+  };
+  return {
+    ...out,
+    ...(r.identity !== null ? { identity: r.identity } : {}),
+    ...(r.host !== null ? { host: r.host } : {}),
+    ...(r.process_instance_key !== null ? { processInstanceKey: r.process_instance_key } : {}),
+    ...(r.bpmn_process_id !== null ? { bpmnProcessId: r.bpmn_process_id } : {}),
+    ...(r.element_id !== null ? { elementId: r.element_id } : {}),
+    ...(r.plan_key !== null ? { planKey: r.plan_key } : {}),
+    ...(r.linked_at !== null ? { linkedAt: r.linked_at } : {}),
+  };
+}
+
+/**
+ * The durable worker-attribution store over the app's SQLite handle. Synchronous (mirrors
+ * {@link SqliteDb} and the relay slice's sync frame handling), advisory — a persistence failure never
+ * bubbles into a frame handler; callers wrap {@link record} defensively.
+ */
+export class AgenticCorrelationStore {
+  readonly #db: SqliteDb;
+
+  constructor(db: SqliteDb) {
+    this.#db = db;
+    // Idempotent — the migration applies the same DDL at boot; this makes the table present for
+    // unit tests over an in-memory DB (and is a no-op alongside the migration).
+    this.#db.exec(AGENTIC_CORRELATION_SCHEMA_SQL);
+  }
+
+  /** Upsert a completed job's attribution (last write wins on jobKey). */
+  record(entry: DurableCorrelation): void {
+    this.#db.run(
+      `INSERT INTO agentic_correlation
+         (job_key, stream, instance, identity, host, process_instance_key, bpmn_process_id, element_id, plan_key, linked_at, completed_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(job_key) DO UPDATE SET
+         stream = excluded.stream,
+         instance = excluded.instance,
+         identity = excluded.identity,
+         host = excluded.host,
+         process_instance_key = excluded.process_instance_key,
+         bpmn_process_id = excluded.bpmn_process_id,
+         element_id = excluded.element_id,
+         plan_key = excluded.plan_key,
+         linked_at = excluded.linked_at,
+         completed_at = excluded.completed_at`,
+      [
+        entry.jobKey,
+        entry.stream,
+        entry.instance,
+        entry.identity ?? null,
+        entry.host ?? null,
+        entry.processInstanceKey ?? null,
+        entry.bpmnProcessId ?? null,
+        entry.elementId ?? null,
+        entry.planKey ?? null,
+        entry.linkedAt ?? null,
+        entry.completedAt,
+      ],
+    );
+  }
+
+  /** The durable attribution for a jobKey, or undefined when none was recorded. */
+  get(jobKey: string): DurableCorrelation | undefined {
+    if (jobKey === "") return undefined;
+    const rows = this.#db.all<Row>("SELECT * FROM agentic_correlation WHERE job_key = ?", [jobKey]);
+    return rows.length > 0 ? fromRow(rows[0]) : undefined;
+  }
+
+  /** The durable attribution for a `job:<jobKey>` stream id, or undefined for a non-job stream. */
+  byStream(stream: string): DurableCorrelation | undefined {
+    const jobKey = jobKeyOfStream(stream);
+    return jobKey === undefined ? undefined : this.get(jobKey);
+  }
+
+  /** Every durable attribution recorded for a worker instance, newest completion first. */
+  byInstance(instance: string): DurableCorrelation[] {
+    if (instance === "") return [];
+    const rows = this.#db.all<Row>(
+      "SELECT * FROM agentic_correlation WHERE instance = ? ORDER BY completed_at DESC, job_key DESC",
+      [instance],
+    );
+    return rows.map(fromRow);
+  }
+}

package/app/agentic/families/presence.family.test.ts

@@ -138,6 +138,18 @@ test("instanceForConnection: resolves the worker instance owning a connection (H
   assertEquals(registry.instanceForConnection(""), undefined, "empty connection → undefined");
 });
 
+test("attributionOf: resolves a worker instance's durable identity + host for job attribution (#485)", () => {
+  const store = createPresenceStore(memSqlite());
+  store.ensureSchema();
+  store.register({ instance: "w1", connectionId: "c1", identity: "leafA", capability: { host: "boxA1" } });
+  store.register({ instance: "w2", connectionId: "c2", identity: "leafB", capability: {} });
+  const registry = new PresenceRegistry(store, () => new Set(["c1", "c2"]));
+  assertEquals(registry.attributionOf("w1"), { identity: "leafA", host: "boxA1" });
+  assertEquals(registry.attributionOf("w2"), { identity: "leafB", host: undefined }, "no host → host undefined");
+  assertEquals(registry.attributionOf("nope"), undefined, "unknown instance → undefined");
+  assertEquals(registry.attributionOf(""), undefined, "empty instance → undefined");
+});
+
 test("reconcile: removes rows whose connection the hub has closed, keeps live ones", () => {
   const store = createPresenceStore(memSqlite());
   store.ensureSchema();

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

@@ -148,6 +148,20 @@ export class PresenceRegistry {
     return undefined;
   }
 
+  /**
+   * Resolve a worker instance's durable identity attributes (presence identity + host) for job
+   * attribution (#485). Returns the most recently registered matching row's attributes, or undefined
+   * when the instance is unknown (e.g. it already deregistered).
+   */
+  attributionOf(instance: string): { identity?: string; host?: string } | undefined {
+    if (instance === "") return undefined;
+    let match: { identity?: string; host?: string } | undefined;
+    for (const row of this.#store.list()) {
+      if (row.instance === instance) match = { identity: row.identity, host: row.capability.host };
+    }
+    return match;
+  }
+
   /**
    * Eagerly drop presence rows whose connection the hub has already closed (a disconnect the hub's
    * single close listener removed from its in-memory registry). Rows also age out on the presence

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

@@ -20,6 +20,7 @@ import { type SqliteDb, TRANSCRIPT_SCHEMA_SQL } from "@nanobpm/agentic/transcrip
 import { assert, assertEquals } from "#test-assert";
 import { noopLog } from "../../../test/log.ts";
 import { CorrelationRegistry, jobStream } from "../correlation.ts";
+import { AgenticCorrelationStore } from "../correlation-store.ts";
 import {
   type CorrelationLink,
   createRelayFamily,
@@ -139,6 +140,11 @@ function mkCorrelatedService(
   db: SqliteDb | undefined,
   correlation: CorrelationRegistry,
   byConnection: Map<string, string>,
+  extra: {
+    attributionForInstance?: (instance: string) => { identity?: string; host?: string } | undefined;
+    correlationStore?: AgenticCorrelationStore;
+    now?: () => string;
+  } = {},
 ): { service: RelayTranscriptService; hub: CapturingHub } {
   const hub = capturingHub();
   const service = new RelayTranscriptService({
@@ -148,6 +154,9 @@ function mkCorrelatedService(
     log: noopLog(),
     correlation: () => correlation,
     instanceForConnection: (id) => byConnection.get(id),
+    attributionForInstance: extra.attributionForInstance,
+    correlationStore: extra.correlationStore,
+    now: extra.now,
   });
   return { service, hub };
 }
@@ -349,6 +358,69 @@ test("H6 correlation write-side: a late produce after completion does not resurr
   service.teardown();
 });
 
+test("H6 correlation write-side: a worker starting a NEW job over its live connection supersedes its prior job", () => {
+  const registry = new ConnectionRegistry();
+  const correlation = new CorrelationRegistry();
+  // One worker, ONE long-lived connection — exactly the fleet reality: a worker relays every job it
+  // runs over the same channel connection, one job at a time (correlation.ts). The connection never
+  // disconnects between jobs, so the disconnect-driven #reconcile release never fires; without a
+  // supersede-on-next-job rule the worker's supply row would accumulate EVERY job it ever ran.
+  const byConnection = new Map([["prod", "worker-A"]]);
+  const { service, hub } = mkCorrelatedService(registry, memoryDb(), correlation, byConnection);
+  const p = connect("prod", registry);
+
+  // Job 1: the worker relays k1's terminal → linked.
+  hub.handler?.(produce(jobStream("k1"), 1, "job-1 line"), p.conn);
+  assertEquals(correlation.jobKeysFor("worker-A"), ["k1"], "job 1 is the current job");
+
+  // Job 2 begins on the SAME live connection (no disconnect). The worker relaying k2's terminal PROVES
+  // k1 finished (one job at a time) → k1 is superseded: released AND flushed to a durable past session.
+  hub.handler?.(produce(jobStream("k2"), 1, "job-2 line"), p.conn);
+  assertEquals(correlation.jobKeysFor("worker-A"), ["k2"], "the supply row shows ONLY the current job — no accumulation");
+  assertEquals(correlation.resolve("k1"), undefined, "the prior job's correlation is released");
+  assertEquals(correlation.count(), 1);
+
+  // The superseded job is not lost — its transcript is flushed and completed, i.e. a replayable past session.
+  const priorMeta = service.transcriptOf(jobStream("k1"));
+  assertEquals(priorMeta?.status, "completed", "the superseded job becomes a completed past session");
+  assertEquals(service.reattach(jobStream("k1"), 0)?.entries.length, 1, "the past session replays its captured terminal");
+  service.teardown();
+});
+
+test("H6 durable attribution: completing/superseding a job persists the worker's attribution to the correlation store", () => {
+  const registry = new ConnectionRegistry();
+  const correlation = new CorrelationRegistry();
+  const db = memoryDb();
+  const store = new AgenticCorrelationStore(db);
+  const byConnection = new Map([["prod", "worker-A"]]);
+  // The presence-backed resolver: worker-A's durable identity/host, available while it is registered
+  // but gone once it exits — which is exactly why the job's attribution must be persisted at completion.
+  const attributionForInstance = (instance: string) =>
+    instance === "worker-A" ? { identity: "gpu-box-7", host: "us-east-1a" } : undefined;
+  const { service, hub } = mkCorrelatedService(registry, db, correlation, byConnection, {
+    attributionForInstance,
+    correlationStore: store,
+    now: () => "2024-01-02T03:04:05.000Z",
+  });
+  const p = connect("prod", registry);
+
+  // Job 1 runs, then the worker starts job 2 on the same live connection → job 1 is superseded and
+  // released. Its attribution must be durably recorded BEFORE the live correlation forgets it.
+  hub.handler?.(produce(jobStream("k1"), 1, "job-1 line"), p.conn);
+  hub.handler?.(produce(jobStream("k2"), 1, "job-2 line"), p.conn);
+
+  const durable = store.get("k1");
+  assert(durable !== undefined, "the superseded job's attribution is persisted");
+  assertEquals(durable?.instance, "worker-A");
+  assertEquals(durable?.identity, "gpu-box-7");
+  assertEquals(durable?.host, "us-east-1a");
+  assertEquals(durable?.stream, jobStream("k1"));
+  assertEquals(durable?.completedAt, "2024-01-02T03:04:05.000Z");
+  // The still-active job is NOT yet recorded (attribution is written on completion, not on link).
+  assertEquals(store.get("k2"), undefined, "the active job has no completion attribution yet");
+  service.teardown();
+});
+
 /**
  * A {@link CorrelationLink} wrapper that delegates to a real registry but can be flipped to throw on
  * `link()`/`releaseJob()`, exercising the advisory-resilience contract: `#link`/`#unlink` are