@nanobpm/nano-workforce 0.127.0 → 0.129.0

package/app/lineage.ts

@@ -21,6 +21,7 @@
 import type { DataLayer } from "@nanobpm/urban";
 import { deriveDelivery, TERMINAL_STATUSES } from "./delivery.ts";
 import { type FeatureRun, featureRuns } from "./feature.ts";
+import { derivedTrackingTable } from "./instanceTracking.ts";
 import { type Plan, type PlanTask, plans, planTasks } from "./plan.ts";
 
 const now = () => new Date().toISOString();
@@ -307,9 +308,19 @@ interface PrRow {
   // Epic-phase projection this module maintains (issue #304, migration 043): the parent epic's phase
   // label for an epic slice PR, NULL otherwise. Read here only to keep the write idempotent.
   epic_phase_label: string | null;
+  // The ADR-0065 derived tracking edge (`pull_requests__tracking.derived_status`). Present ONLY on
+  // rows read through the derived VIEW (`prRowsRead`); undefined on base-table reads/writes. The
+  // frontier stage is derived from THIS, not the base transient `status`, so an out-of-band-
+  // terminated slice reads `abandoned` rather than a stale `converging`.
+  derived_status?: string;
 }
 
 const prRows = (data: DataLayer) => data.table<PrRow>("pull_requests", "pr_key");
+/** Read-only accessor over the PR derived tracking VIEW (`pull_requests__tracking`). The lineage
+ * frontier classifies on the reconciler-derived edge, so `collectThreads` reads through this and
+ * `toLineagePr` folds `derived_status` onto `LineagePr.status`. Writes stay on `prRows`. */
+const prRowsRead = (data: DataLayer) =>
+  derivedTrackingTable<PrRow & { derived_status: string }>(data, "pull_requests", "pr_key");
 
 /** The `lineage_thread_view` VIEW row (migration 064) — the read shape the Lineage page binds. The
  *  view PASSES THROUGH the procedural frontier columns from `lineage_threads` and DERIVES the
@@ -382,7 +393,9 @@ function toLineagePr(row: PrRow): LineagePr {
     prKey: row.pr_key,
     title: row.title,
     url: row.url,
-    status: row.status,
+    // Classify the frontier on the ADR-0065 derived edge when the row came through the tracking VIEW
+    // (`prRowsRead`); fall back to the base transient for any base-table row.
+    status: row.derived_status ?? row.status,
     round: row.current_round,
     processKey: row.process_key,
     outcome: row.outcome,
@@ -394,7 +407,7 @@ function toLineagePr(row: PrRow): LineagePr {
 async function collectThreads(
   data: DataLayer,
 ): Promise<{ threads: Map<string, LineageThread>; allPrs: PrRow[] }> {
-  const allPrs = await prRows(data).all();
+  const allPrs = await prRowsRead(data).all();
   const prByKey = new Map<string, PrRow>();
   for (const pr of allPrs) prByKey.set(pr.pr_key, pr);
 

package/app/promotionPoll.test.ts

@@ -6,6 +6,7 @@
 // recording engine: open exactly one PR, never a duplicate on re-run, never for a converging epic,
 // and never for a `main`-based epic.
 import { test } from "node:test";
+import { withTrackingViews } from "../test/trackingViews.ts";
 import { assert, assertEquals } from "#test-assert";
 import type { DataLayer, EngineClient } from "@nanobpm/urban";
 import { resetDefaultBranchCache } from "./github.ts";
@@ -41,7 +42,7 @@ function memData(): { data: DataLayer; stores: Record<string, any[]> } {
       },
     };
   }
-  const data = { table: (n: string, pk?: string) => tbl(n, pk) } as any as DataLayer;
+  const data = { table: withTrackingViews((n: string, pk?: string) => tbl(n, pk)) } as any as DataLayer;
   return { data, stores };
 }
 

package/app/retro.test.ts

@@ -3,6 +3,7 @@ import { test } from "node:test";
 import { assert, assertEquals, assertStringIncludes } from "#test-assert";
 import type { DataLayer, EngineClient } from "@nanobpm/urban";
 import { memBlackboardSource } from "../test/blackboardDb.ts";
+import { withTrackingViews } from "../test/trackingViews.ts";
 import { appendEntry } from "./blackboard.ts";
 import { recordTaskDelta } from "./taskDelta.ts";
 import {
@@ -47,7 +48,7 @@ function memData(): { data: DataLayer; stores: Record<string, any[]> } {
       },
     };
   }
-  const data = { table: (n: string, pk?: string) => tbl(n, pk), source: memBlackboardSource().source } as any as DataLayer;
+  const data = { table: withTrackingViews((n: string, pk?: string) => tbl(n, pk)), source: memBlackboardSource().source } as any as DataLayer;
   return { data, stores };
 }
 

package/app/retro.ts

@@ -17,6 +17,7 @@ import type { DataLayer, EngineClient, Logger } from "@nanobpm/urban";
 import { type BlackboardEntry, isUniqueViolation, readBlackboard } from "./blackboard.ts";
 import { hasDeliveredImplementationForPlan } from "./conformance.ts";
 import { TERMINAL_STATUSES } from "./delivery.ts";
+import { derivedTrackingTable } from "./instanceTracking.ts";
 import { planReviews, planTasks } from "./plan.ts";
 import { aggregateEpicDeltas } from "./taskDelta.ts";
 
@@ -55,7 +56,11 @@ interface PlanRow extends Record<string, unknown> {
 
 const plansTbl = (data: DataLayer) => data.table<PlanRow>("plans", "plan_key");
 const prsTbl = (data: DataLayer) =>
-  data.table<{ pr_key: string; status: string }>("pull_requests", "pr_key");
+  derivedTrackingTable<{ pr_key: string; derived_status: string }>(
+    data,
+    "pull_requests",
+    "pr_key",
+  );
 const retroStartsTbl = (data: DataLayer) =>
   data.table<{ plan_key: string; started_at: string }>("plan_retro_starts", "plan_key");
 
@@ -77,8 +82,10 @@ export async function isPlanComplete(data: DataLayer, planKey: string): Promise<
     if (SETTLED_TASKLESS.has(t.status)) continue;
     // Any task that is meant to yield a PR must have a terminal PR to be settled.
     if (!t.pr_key) return false; // pending/escalated/etc. with no PR yet → still in flight
+    // Any task that is meant to yield a PR must have a terminal PR to be settled. Read the ADR-0065
+    // derived edge so an out-of-band-terminated (`abandoned`) PR is recognised as terminal here.
     const pr = await prsTbl(data).get(t.pr_key);
-    if (!pr || !TERMINAL_PR_STATUSES.has(pr.status)) return false;
+    if (!pr || !TERMINAL_PR_STATUSES.has(pr.derived_status)) return false;
   }
   return true;
 }

package/app/service.test.ts

@@ -8,6 +8,7 @@
 import { test } from "node:test";
 import { assertEquals, assertRejects, assertStringIncludes } from "#test-assert";
 import { memDataFor } from "../test/worldDb.ts";
+import { withTrackingViews } from "../test/trackingViews.ts";
 import { DurableResumeRegistry } from "./durableResume.ts";
 import { WorldStore } from "./world/index.ts";
 import { abandonClosedPr, parsePr, pollCapabilityGatesImpl, pollIncidentsImpl, pollWaveGatesImpl, repoEnvelopeVars, startMerge, submitPr, worldRestoreSha } from "./service.ts";
@@ -71,7 +72,7 @@ test("re-submit of a cancelled PR marks stale open escalations", async () => {
       pr_dependencies: { rows: [], key: "pr_key" },
     };
     const data = {
-      table: (name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key),
+      table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
     } as any;
     const engine = {
       createInstance: () => Promise.resolve({ processInstanceKey: "PI-9" }),
@@ -137,7 +138,7 @@ test("pollIncidents mirrors an ACTIVE incident onto the PR row, then clears it,
     pull_requests: { rows: [row], key: "pr_key" },
   };
   const data = {
-    table: (name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key),
+    table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
   } as any;
   const headers = { "content-type": "application/json" };
 
@@ -190,7 +191,7 @@ test("pollIncidents never queries a PR with no live instance and clears any stal
     pull_requests: { rows: [noKey, terminal], key: "pr_key" },
   };
   const data = {
-    table: (name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key),
+    table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
   } as any;
   const headers = { "content-type": "application/json" };
 
@@ -223,7 +224,7 @@ test("pollIncidents picks the oldest incident by creationTime, sorting a missing
     pull_requests: { rows: [row], key: "pr_key" },
   };
   const data = {
-    table: (name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key),
+    table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
   } as any;
   const headers = { "content-type": "application/json" };
 
@@ -262,7 +263,7 @@ test("submitPr stringifies a numeric processInstanceKey (contract: string | null
       pr_dependencies: { rows: [], key: "pr_key" },
     };
     const data = {
-      table: (name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key),
+      table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
     } as any;
     const engine = {
       // A large key delivered as a JS number — the exact case that breaks dev response validation
@@ -296,7 +297,7 @@ function captureConvergeOnly() {
     pr_dependencies: { rows: [], key: "pr_key" },
   };
   const data = {
-    table: (name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key),
+    table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
   } as any;
   let captured: unknown;
   const engine = {
@@ -347,7 +348,7 @@ function captureRoot() {
     pr_dependencies: { rows: [], key: "pr_key" },
   };
   const data = {
-    table: (name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key),
+    table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
   } as any;
   let captured: unknown;
   const engine = {
@@ -629,7 +630,7 @@ test("pollWaveGatesImpl is level-triggered: PRs merged before the token arrives
       },
     };
     const data = {
-      table: (name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key),
+      table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
     } as any;
 
     const published: { name: string; correlationKey?: string }[] = [];
@@ -718,7 +719,7 @@ test("pollWaveGatesImpl never releases the barrier on an unverifiable subscripti
       },
     };
     const data = {
-      table: (name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key),
+      table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
     } as any;
 
     const published: { name: string; correlationKey?: string }[] = [];
@@ -822,7 +823,7 @@ test("pollWaveGatesImpl releases the wave when a member PR is closed-unmerged an
       merges: { rows: [], key: "id" },
     };
     const data = {
-      table: (name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key),
+      table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
     } as any;
 
     const published: { name: string; correlationKey?: string }[] = [];
@@ -878,7 +879,7 @@ test("abandonClosedPr is idempotent — the terminal merges audit row is written
     merges: { rows: [], key: "id" },
   };
   const data = {
-    table: (name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key),
+    table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
   } as any;
 
   await abandonClosedPr(data, "owner/repo#70", "closed without merging");
@@ -906,7 +907,7 @@ test("abandonClosedPr self-heals a missing pull_requests parent row before the F
     merges: { rows: [], key: "id" },
   };
   const data = {
-    table: (name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key),
+    table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
   } as any;
 
   await abandonClosedPr(data, "owner/repo#71", "closed without merging");
@@ -932,7 +933,7 @@ test("abandonClosedPr rejects a malformed prKey with a clear error before any FK
     merges: { rows: [], key: "id" },
   };
   const data = {
-    table: (name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key),
+    table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
   } as any;
 
   const err = await assertRejects(() => abandonClosedPr(data, "not-a-valid-pr-key", "closed without merging"));
@@ -1004,7 +1005,7 @@ function capsProbeExec(ready: boolean) {
 
 function capsDataLayer(stores: Record<string, { rows: any[]; key: string }>) {
   return {
-    table: (name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key),
+    table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
   } as any;
 }
 

package/app/service.ts

@@ -7,7 +7,6 @@
 //
 // Data access goes through the record-oriented gateway (`data.table<T>(name, pk)` — the RAD
 // `Table<T>` surface), not hand-written SQL. Row shapes are declared inline here.
-import { readFileSync } from "node:fs";
 import type { DataLayer, EngineClient } from "@nanobpm/urban";
 import { ABANDONED_STATUS, abandonUrl, mintAbandonToken, renderAbandonBrief } from "./abandon.ts";
 import { escalationFormId } from "./agentCompletion.ts";
@@ -51,6 +50,7 @@ import {
   type PrState,
   requestCopilotReview,
 } from "./github.ts";
+import { activeStatusesFor, derivedTrackingTable } from "./instanceTracking.ts";
 import { pollLineage } from "./lineage.ts";
 import { mergeLanes, readExclusions } from "./mergeExclusion.ts";
 import {
@@ -253,6 +253,16 @@ interface Escalation {
 }
 
 const prs = (data: DataLayer) => data.table<PullRequest>("pull_requests", "pr_key");
+/** A PR row as seen through its derived tracking VIEW (`pull_requests__tracking`): the base columns
+ * plus urban's ADR-0065 `derived_status`, which folds the reconciler's terminal edge
+ * (out-of-band terminate → `abandoned`) over the worker-owned transient. */
+type TrackedPullRequest = PullRequest & { derived_status: string };
+/** Read-only accessor over the PR derived tracking VIEW. Use this — and read `derived_status`, not
+ * `status` — for any terminal-edge classification (delivery/promotion/feature reconciliation), so an
+ * out-of-band-terminated PR (whose base row is still `converging`) is correctly seen as `abandoned`.
+ * Worker-written terminals (`merged`/`converged`) pass through unchanged. Writes stay on `prs`. */
+const prsTracking = (data: DataLayer) =>
+  derivedTrackingTable<TrackedPullRequest>(data, "pull_requests", "pr_key");
 const escs = (data: DataLayer) => data.table<Escalation>("escalations", "id");
 const deps = (data: DataLayer) => data.table<PrDependency>("pr_dependencies", "pr_key");
 
@@ -1948,7 +1958,8 @@ export async function derivePlanDelivery(
     let status = statusByPrKey?.get(t.pr_key);
     if (status === undefined && !statusByPrKey) {
       // On-demand caller: fetch just this slice's PR row rather than loading the whole table.
-      status = (await prs(data).get(t.pr_key))?.status;
+      // Read the ADR-0065 derived edge so an out-of-band-terminated slice reads `abandoned`.
+      status = (await prsTracking(data).get(t.pr_key))?.derived_status;
     }
     prStatuses.push(status ?? MISSING_PR_STATUS);
   }
@@ -2028,8 +2039,9 @@ export async function pollWaitGate(data: DataLayer) {
  * default branch, so there is nothing to promote. Best-effort + per-plan isolated. */
 export async function pollPromotion(data: DataLayer, engine: EngineClient, token: string) {
   // Preload every PR status once per pass (mirrors pollDelivery — avoids an N+1 `prs(data).get`).
+  // Read the ADR-0065 derived edge (`derived_status`) so a terminated slice reads `abandoned`.
   const statusByPrKey = new Map<string, string>();
-  for (const pr of await prs(data).all()) statusByPrKey.set(pr.pr_key, pr.status);
+  for (const pr of await prsTracking(data).all()) statusByPrKey.set(pr.pr_key, pr.derived_status);
   for (const plan of await plans(data).all()) {
     const base = plan.base_branch;
     // A non-`epic/*` base is never promotable — short-circuit before the per-plan delivery join.
@@ -2107,8 +2119,9 @@ export async function pollPromotion(data: DataLayer, engine: EngineClient, token
  * Never touches a run that isn't `converging` — additive/derived only, idempotent, best-effort. */
 export async function pollFeatureDelivery(data: DataLayer) {
   // Preload every PR status once per pass (mirrors pollDelivery — avoids an N+1 `prs(data).get`).
+  // Read the ADR-0065 derived edge (`derived_status`) so a terminated run reads `abandoned`.
   const statusByPrKey = new Map<string, string>();
-  for (const pr of await prs(data).all()) statusByPrKey.set(pr.pr_key, pr.status);
+  for (const pr of await prsTracking(data).all()) statusByPrKey.set(pr.pr_key, pr.derived_status);
   // Only `converging` runs are ever reconciled — query them via the `feature_runs(status)` index
   // (db/migrations/028) instead of scanning all history, so this pass stays O(in-flight), not
   // O(total runs), as the table grows.
@@ -2130,26 +2143,6 @@ export async function pollFeatureDelivery(data: DataLayer) {
   }
 }
 
-/** The app manifest, read and parsed exactly ONCE at module load. `activeStatusesFor` is invoked
- * three times during module initialization (the PR/plan/feature constants below); parsing here keeps
- * that to a single synchronous `readFileSync` + `JSON.parse` instead of one per lookup. */
-const APP_MANIFEST: { instanceTracking?: { table: string; activeStatuses?: string[] }[] } = JSON.parse(
-  readFileSync(new URL("../nano.app.json", import.meta.url), "utf8"),
-);
-
-/** Read a tracked table's parked-and-active statuses from the single source of truth
- * (`instanceTracking.<table>.activeStatuses` in nano.app.json), so an app-side scan can never drift
- * from the reconciler's notion of "in-flight". Throws if the binding is missing/empty. */
-function activeStatusesFor(table: string): readonly string[] {
-  const binding = APP_MANIFEST.instanceTracking?.find((b) => b.table === table);
-  if (!binding?.activeStatuses?.length) {
-    throw new Error(
-      `nano.app.json: instanceTracking[table="${table}"].activeStatuses is missing or empty`,
-    );
-  }
-  return binding.activeStatuses;
-}
-
 /** The `pull_requests` statuses a PR instance can be parked-and-active on, DERIVED from the single
  * source of truth (`instanceTracking.pull_requests.activeStatuses` in nano.app.json) so the app-side
  * scan can never drift from the reconciler's notion of "in-flight". `pollUserTasks` scans only these

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/e2e/convergence-loop.e2e.ts

@@ -22,6 +22,7 @@ import { mkdtempSync, rmSync, readFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { after, before, describe, test } from "node:test";
 import { bootTestApp, type TestApp } from "@nanobpm/urban-testkit";
+import { trackingTargetFor } from "../app/instanceTracking.ts";
 
 // The app root is this repo's root (one level up from `e2e/`) — where nano.app.json + openapi.yaml
 // + db/migrations + resources/processes live.
@@ -160,16 +161,20 @@ describe("nano-workforce e2e (urban-testkit pilot)", () => {
 
     // The operation registered the PR aggregate (instanceTracking table) and started a real engine
     // instance — synchronously, before any worker ran (we never settled).
-    const prs = app.db.table<{ pr_key: string; status: string; process_key: string | null }>(
-      "pull_requests",
-      "pr_key",
-    );
+    const prs = app.db.table<{
+      pr_key: string;
+      status: string;
+      process_key: string | null;
+      abandon_token: string | null;
+    }>("pull_requests", "pr_key");
     const row = await prs.findOne({ pr_key: prKey });
     assert.ok(row, "a pull_requests row was registered");
     assert.equal(row?.status, "converging", "the PR is tracked as actively converging");
     assert.ok(row?.process_key, "the row carries the engine process-instance key");
+    assert.ok(row?.abandon_token, "the row carries a #76 abandon-check capability token");
 
     const processInstanceKey = row!.process_key!;
+    const abandonToken = row!.abandon_token!;
     const before = await app.engine.searchProcessInstances({
       processInstanceKeys: [processInstanceKey],
     });
@@ -182,11 +187,39 @@ describe("nano-workforce e2e (urban-testkit pilot)", () => {
     assert.equal(stillActive?.status, "converging", "row not yet reconciled before any poll fires");
 
     // Advance past the instanceTracking pollMs (derived from nano.app.json above, plus a margin):
-    // the reconciler observes TERMINATED and applies the manifest `onTerminated.set` → status
-    // `abandoned`.
+    // the reconciler observes TERMINATED and feeds urban's instance projection. Under ADR-0065
+    // (urban 0.81.0, the writer→source inversion) it NO LONGER writes `abandoned` onto the base row;
+    // the terminal edge is DERIVED on read via the managed `pull_requests__tracking` VIEW.
     await app.advanceTime(PR_POLL_MS + 1000);
-    const reconciled = await prs.findOne({ pr_key: prKey });
-    assert.equal(reconciled?.status, "abandoned", "reconciler abandoned the terminated PR's row");
+
+    // (1) The base row keeps only the worker-owned transient — it stays `converging`, NOT rewritten.
+    const baseRow = await prs.findOne({ pr_key: prKey });
+    assert.equal(
+      baseRow?.status,
+      "converging",
+      "ADR-0065: the reconciler no longer writes the terminal edge onto the base row",
+    );
+
+    // (2) The derived tracking VIEW reports the terminal edge (`abandoned`) via `derived_status`. Its
+    // name/column are resolved by the app's SSOT helper, which defers to urban's own target resolver.
+    const target = trackingTargetFor("pull_requests");
+    const view = app.db.table<{ pr_key: string } & Record<string, unknown>>(target.view, "pr_key");
+    const derived = await view.findOne({ pr_key: prKey });
+    assert.equal(
+      derived?.[target.statusColumn],
+      "abandoned",
+      "the derived read-model reports the terminated PR as abandoned",
+    );
+
+    // (3) End-to-end, the #76 cooperative abandon-check endpoint (which a servicing agent curls
+    // before any irreversible action) now reports `abandoned: true` — the whole point of the edge.
+    const abandonCheck = await api.call<{ prKey: string; status: string; abandoned: boolean }>(
+      "checkAbandon",
+      { query: { token: abandonToken } },
+    );
+    assert.equal(abandonCheck.status, 200, "the abandon check resolves the known token");
+    assert.equal(abandonCheck.body.abandoned, true, "a servicing agent is told to abort the run");
+    assert.equal(abandonCheck.body.status, "abandoned", "the reported status is the derived edge");
   });
 
   test("coverage gate: every operation the pilot claims to own was exercised", () => {

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/acknowledgeEpic.test.ts

@@ -18,6 +18,7 @@ import { assertEquals } from "#test-assert";
 import type { AppApi } from "@nanobpm/urban";
 import { deriveEpicBucket, epicIsAcknowledgeable } from "../app/delivery.ts";
 import { noopLog } from "../test/log.ts";
+import { withTrackingViews } from "../test/trackingViews.ts";
 import handler from "./acknowledgeEpic.ts";
 
 // An in-memory data layer wired through the `plans` gateway (now a plain record table). `extra` seeds
@@ -52,7 +53,7 @@ function memApp(
     };
   }
   const app = {
-    data: { table: (n: string, pk?: string) => tbl(n, pk) },
+    data: { table: withTrackingViews((n: string, pk?: string) => tbl(n, pk)) },
     log: noopLog(),
   } as any as AppApi;
   return { app, rows: stores.plans };

package/operations/checkAbandon.test.ts

@@ -3,6 +3,7 @@ import { test } from "node:test";
 import { assertEquals } from "#test-assert";
 import type { AppApi } from "@nanobpm/urban";
 import { noopLog } from "../test/log.ts";
+import { withTrackingViews } from "../test/trackingViews.ts";
 import handler from "./checkAbandon.ts";
 
 function memApp(): { app: AppApi } {
@@ -19,7 +20,7 @@ function memApp(): { app: AppApi } {
       },
     };
   }
-  const app = { data: { table: (n: string) => tbl(n) }, log: noopLog() } as any as AppApi;
+  const app = { data: { table: withTrackingViews((n: string) => tbl(n)) }, log: noopLog() } as any as AppApi;
   return { app };
 }
 

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/getLineage.test.ts

@@ -6,6 +6,7 @@ import { test } from "node:test";
 import { assert, assertEquals } from "#test-assert";
 import type { AppApi } from "@nanobpm/urban";
 import { noopLog } from "../test/log.ts";
+import { withTrackingViews } from "../test/trackingViews.ts";
 import handler from "./getLineage.ts";
 
 function memApp(stores: Record<string, any[]>): AppApi {
@@ -20,7 +21,7 @@ function memApp(stores: Record<string, any[]>): AppApi {
       },
     };
   };
-  return { data: { table }, log: noopLog() } as any as AppApi;
+  return { data: { table: withTrackingViews(table) }, log: noopLog() } as any as AppApi;
 }
 
 function input(query: Record<string, string> = {}, headers: Record<string, string> = {}) {

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.129.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",
@@ -59,12 +59,12 @@
   },
   "dependencies": {
     "@nanobpm/agentic": "^0.4.0",
-    "@nanobpm/urban": "^0.80.0",
+    "@nanobpm/urban": "^0.81.0",
     "bpmn-auto-layout": "^2.0.0-alpha.2"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.11",
-    "@nanobpm/urban-testkit": "^0.12.16",
+    "@nanobpm/urban-testkit": "^0.13.1",
     "@nanobpm/workflow": "^0.14.0",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",