@nanobpm/nano-workforce 0.143.0 → 0.144.0

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.144.0](https://github.com/nanobpm/nano-workforce/compare/v0.143.0...v0.144.0) (2026-08-25)
+
+### Features
+
+* **stepper:** derived stepper v1 — one pipeline projection for feature + delivery graph ([#541](https://github.com/nanobpm/nano-workforce/issues/541)) ([#546](https://github.com/nanobpm/nano-workforce/issues/546)) ([0aa365a](https://github.com/nanobpm/nano-workforce/commit/0aa365af158df3de3c79f8a42226a2694a75af52)), closes [#540](https://github.com/nanobpm/nano-workforce/issues/540) [#538](https://github.com/nanobpm/nano-workforce/issues/538) [205/#386](https://github.com/205/nano-workforce/issues/386) [#542](https://github.com/nanobpm/nano-workforce/issues/542)
+
 ## [0.143.0](https://github.com/nanobpm/nano-workforce/compare/v0.142.0...v0.143.0) (2026-08-25)
 
 ### Features

package/app/deliveryGraphReadModel.test.ts

@@ -0,0 +1,392 @@
+// Read-model coverage for the delivery-graph progress projection — the member-PR rollup, the coarse-key
+// stage/stage_state derivation, and the promoted `pipeline` render binding — authored via Urban's
+// ADR-0065 declare-once primitives (app/deliveryGraphReadModel.ts). ADR 0006 §4b, issue #541 / S7; the
+// exemplars are app/featureReadModel.test.ts and app/planReadModel.test.ts.
+//
+// Guards:
+//   1. DRIFT GUARD — migration 087 embeds the rollup VIEW DDL VERBATIM from `rollup.viewDdl()` and each
+//      derived column VERBATIM from `deliveryGraphReadModel.sqlSelectFor(...)`, so the checked-in VIEWs
+//      cannot drift from the declarations.
+//   2. FRAMEWORK PARITY GUARD — `assertRollupParity` / `assertReadModelParity` prove the SQL and TS
+//      lowerings each declaration compiles to agree.
+//   3. END-TO-END BEHAVIOUR on the REAL migration VIEW (087 applied to an in-memory DB): the coarse-key
+//      matrix, the member-PR temper, the terminal-fold bypass, and the companion `park_label`.
+//   4. PARITY vs TODAY'S PHASE — for representative `deriveDeliveryPhase` outputs (what the plain Phase
+//      text cell showed), the derived stepper matches, and the actionable park label is retained.
+//   5. ONE PROJECTION — the VIEW's (stage, state) equals `reduceFrontier` of the single derived branch,
+//      tying the render half to the canonical axis (app/stepAxis.ts).
+//   6. PAGE BINDINGS — the delivery-graph pages bind the derived VIEW + the `pipeline` kind, not a plain
+//      `phase` text cell on the raw table.
+
+import { readFileSync } from "node:fs";
+import { DatabaseSync } from "node:sqlite";
+import { test } from "node:test";
+import { fileURLToPath } from "node:url";
+import { assertReadModelParity, assertRollupParity, type ParityDb, type ParitySample, type ProcessInstanceState, type RollupInputs } from "@nanobpm/urban";
+import { assert, assertEquals } from "#test-assert";
+import { deriveDeliveryPhase } from "./deliveryGraphRun.ts";
+import {
+  DELIVERY_GRAPH_READ_MODEL_BASE_ALIAS,
+  DELIVERY_GRAPH_READ_MODEL_DERIVED,
+  DELIVERY_GRAPH_ROLLUPS,
+  deliveryGraphPrCounts,
+  deliveryGraphReadModel,
+  PR_COUNTS_LOOKUP,
+} from "./deliveryGraphReadModel.ts";
+import { reduceFrontier, type StepKey } from "./stepAxis.ts";
+import { applyMigrationSet, readMigrationSetFromDisk } from "../test/migrations.ts";
+
+const MIG = (name: string) => readFileSync(fileURLToPath(new URL(`../db/migrations/${name}`, import.meta.url)), "utf8");
+const PAGE = (name: string) => JSON.parse(readFileSync(fileURLToPath(new URL(`../pages/${name}`, import.meta.url)), "utf8"));
+
+const READ_MODEL_MIGRATION = "087_delivery_graph_read_model.sql";
+
+// A minimal in-memory DB carrying the base `delivery_graph_runs` / `pull_requests` shapes the VIEW
+// reads, plus stand-ins for the managed `<table>__tracking` derived VIEWs urban provisions at mount
+// (each re-exports `base.*` plus the terminal-folded `derived_status`). `derived_status_override` models
+// the reconciler's derive edge (a terminated instance ⇒ `failed`/`abandoned` while base `status` stays
+// frozen). Then migration 087 (the rollup VIEW + the read model VIEW) is applied.
+function viewDb(): DatabaseSync {
+  const db = new DatabaseSync(":memory:");
+  db.exec(
+    `CREATE TABLE delivery_graph_runs (
+       run_key TEXT PRIMARY KEY, process_key TEXT, process_definition_id TEXT, digest TEXT,
+       status TEXT, side_effecting INTEGER, node_count INTEGER, human_node_count INTEGER,
+       side_effect_count INTEGER, title TEXT, phase TEXT, phase_node_id TEXT, human_labels TEXT,
+       created_at TEXT, updated_at TEXT, derived_status_override TEXT);
+     CREATE TABLE pull_requests (pr_key TEXT PRIMARY KEY, root_request_key TEXT, status TEXT,
+       derived_status_override TEXT);`,
+  );
+  db.exec(
+    `CREATE VIEW delivery_graph_runs__tracking AS
+       SELECT d.*, COALESCE(d.derived_status_override, d.status) AS derived_status FROM delivery_graph_runs d;
+     CREATE VIEW pull_requests__tracking AS
+       SELECT p.*, COALESCE(p.derived_status_override, p.status) AS derived_status FROM pull_requests p;`,
+  );
+  db.exec(MIG(READ_MODEL_MIGRATION));
+  return db;
+}
+
+interface SampleRun {
+  status: string;
+  phase?: string | null;
+  phase_node_id?: string | null;
+  derived_status_override?: string | null;
+}
+
+function addRun(db: DatabaseSync, run_key: string, run: SampleRun): void {
+  db.prepare(
+    `INSERT INTO delivery_graph_runs
+       (run_key, process_key, process_definition_id, digest, status, side_effecting, node_count,
+        human_node_count, side_effect_count, title, phase, phase_node_id, human_labels, created_at,
+        updated_at, derived_status_override)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    run_key,
+    `pk-${run_key}`,
+    "delivery-graph",
+    `digest-${run_key}`,
+    run.status,
+    0,
+    3,
+    1,
+    0,
+    `Graph ${run_key}`,
+    run.phase ?? null,
+    run.phase_node_id ?? null,
+    null,
+    "2026-01-01T00:00:00Z",
+    "2026-01-01T00:00:00Z",
+    run.derived_status_override ?? null,
+  );
+}
+
+function addPr(db: DatabaseSync, pr_key: string, root_request_key: string | null, status: string, derived_status_override: string | null = null): void {
+  db.prepare("INSERT INTO pull_requests (pr_key, root_request_key, status, derived_status_override) VALUES (?, ?, ?, ?)").run(
+    pr_key,
+    root_request_key,
+    status,
+    derived_status_override,
+  );
+}
+
+function projection(db: DatabaseSync, run_key: string): { stage: string; stage_state: string | null; park_label: string | null; status: string } {
+  const r = db
+    .prepare("SELECT stage, stage_state, park_label, status FROM delivery_graph_read_model WHERE run_key = ?")
+    .get(run_key) as { stage: string; stage_state: string | null; park_label: string | null; status: string };
+  return { stage: r.stage, stage_state: r.stage_state, park_label: r.park_label, status: r.status };
+}
+
+// A `ParityDb` over node:sqlite's `DatabaseSync` for the framework parity guards.
+function parityDb(db: DatabaseSync): ParityDb {
+  return {
+    exec: (sql) => db.exec(sql),
+    all: <T = Record<string, unknown>>(sql: string, params: unknown[] = []) => db.prepare(sql).all(...(params as never[])) as T[],
+    run: (sql, params: unknown[] = []) => {
+      const r = db.prepare(sql).run(...(params as never[]));
+      return { changes: Number(r.changes), lastInsertRowid: r.lastInsertRowid };
+    },
+  };
+}
+
+// ── 1. DRIFT GUARD ────────────────────────────────────────────────────────────────────────────────
+
+test("DRIFT GUARD: migration 087 embeds the rollup VIEW DDL VERBATIM from rollup.viewDdl() (the VIEW cannot drift from defineRollup)", () => {
+  const sql = MIG(READ_MODEL_MIGRATION);
+  for (const rollup of DELIVERY_GRAPH_ROLLUPS) {
+    assert(
+      sql.includes(rollup.viewDdl()),
+      `migration ${READ_MODEL_MIGRATION} no longer embeds the declaration's VIEW DDL for rollup "${rollup.decl.name}" — ` +
+        `regenerate it from app/deliveryGraphReadModel.ts. Expected to contain:\n${rollup.viewDdl()}`,
+    );
+    assert(new RegExp(`DROP VIEW IF EXISTS ${rollup.decl.name};`).test(sql), `087 must DROP "${rollup.decl.name}" first`);
+  }
+});
+
+test("DRIFT GUARD: migration 087 embeds each derived column VERBATIM from deliveryGraphReadModel.sqlSelectFor (the VIEW cannot drift from the declaration)", () => {
+  const sql = MIG(READ_MODEL_MIGRATION);
+  const alias = DELIVERY_GRAPH_READ_MODEL_BASE_ALIAS;
+  for (const c of DELIVERY_GRAPH_READ_MODEL_DERIVED) {
+    const emitted = deliveryGraphReadModel.sqlSelectFor(c, { baseAlias: alias });
+    assert(
+      sql.includes(`${emitted} AS ${c}`),
+      `migration ${READ_MODEL_MIGRATION} no longer embeds the declaration's SQL for "${c}" — regenerate it from ` +
+        `app/deliveryGraphReadModel.ts. Expected to contain:\n  ${emitted} AS ${c}`,
+    );
+  }
+  assert(/DROP VIEW IF EXISTS delivery_graph_read_model;/.test(sql), "087 must DROP the VIEW first");
+  assert(/CREATE VIEW delivery_graph_read_model AS/.test(sql), "087 must (re)create delivery_graph_read_model");
+  // Base identity pass-throughs — DERIVED from the REAL `delivery_graph_runs` schema (the migration
+  // chain applied to a throwaway DB), NOT a hand-kept list that could silently omit a column: the VIEW
+  // must re-export EVERY base column so the static pages↔schema contract guard sees them (and a future
+  // regeneration can't drop one without failing here). `status` is the one exception — it is exposed as
+  // the effective COALESCE below rather than a bare pass-through — so it is asserted separately.
+  const schemaDb = new DatabaseSync(":memory:");
+  applyMigrationSet(schemaDb, readMigrationSetFromDisk());
+  const baseColumns = (schemaDb.prepare("PRAGMA table_info(delivery_graph_runs)").all() as { name: string }[]).map((r) => r.name);
+  schemaDb.close();
+  assert(baseColumns.length > 0, "the migration chain must create the delivery_graph_runs base table");
+  for (const base of baseColumns) {
+    if (base === "status") continue;
+    assert(sql.includes(`dg.${base} AS ${base}`), `087 must pass base column "${base}" through the VIEW (derived from the real delivery_graph_runs schema)`);
+  }
+  assert(sql.includes("COALESCE(dg.derived_status, dg.status) AS status"), "087 must expose the effective status so the pages' Active/History filter tracks a terminated run");
+  assert(sql.includes("AS park_label"), "087 must carry the hand-authored park_label companion column");
+  // FROM/JOIN relations are DERIVED from the declaration (baseTable + lookup rollup name + join keys).
+  const alias2 = DELIVERY_GRAPH_READ_MODEL_BASE_ALIAS;
+  assert(sql.includes(`FROM ${deliveryGraphReadModel.decl.baseTable} ${alias2}`), `087's FROM must be the declaration's baseTable "${deliveryGraphReadModel.decl.baseTable}"`);
+  for (const lk of deliveryGraphReadModel.decl.lookups) {
+    const on = lk.on.map((k) => `${alias2}.${k.base} = ${lk.as}.${k.rollup}`).join(" AND ");
+    const join = `LEFT JOIN ${lk.rollup.decl.name} ${lk.as} ON ${on}`;
+    assert(sql.includes(join), `087 must LEFT JOIN the declaration's "${lk.rollup.decl.name}" lookup exactly as "${join}"`);
+  }
+});
+
+// ── 2. FRAMEWORK PARITY GUARD ──────────────────────────────────────────────────────────────────────
+
+test("FRAMEWORK PARITY GUARD: delivery_graph_pr_counts VIEW and TS reduce agree (assertRollupParity)", () => {
+  const sampleSets: RollupInputs[] = [
+    {
+      pull_requests__tracking: [
+        { pr_key: "p0", root_request_key: "run-a", derived_status: "converging" },
+        { pr_key: "p1", root_request_key: "run-a", derived_status: "merged" },
+        { pr_key: "p2", root_request_key: "run-a", derived_status: "waiting_review" },
+        { pr_key: "p3", root_request_key: "run-b", derived_status: "abandoned" },
+        { pr_key: "p4", root_request_key: "run-b", derived_status: "converged" },
+        { pr_key: "p5", root_request_key: null, derived_status: "converging" },
+      ],
+    },
+    { pull_requests__tracking: [] },
+  ];
+  for (const rollup of DELIVERY_GRAPH_ROLLUPS) {
+    const db = new DatabaseSync(":memory:");
+    assertRollupParity(rollup, parityDb(db), sampleSets);
+    db.close();
+  }
+});
+
+test("FRAMEWORK PARITY GUARD: deliveryGraphReadModel's SQL and TS lowerings agree over the status × PR-in-flight matrix (assertReadModelParity)", () => {
+  const samples: ParitySample[] = [];
+  for (const status of ["awaiting-approval", "running", "done", "failed", "abandoned"]) {
+    for (const derived_status of [status, "failed"]) {
+      for (const prs_in_flight of [0, 1, 3]) {
+        samples.push({
+          baseRow: { run_key: "self", status, derived_status },
+          lookups: { [PR_COUNTS_LOOKUP]: [{ root_request_key: "self", prs_in_flight }] },
+        });
+      }
+    }
+  }
+  const db = new DatabaseSync(":memory:");
+  assertReadModelParity(deliveryGraphReadModel, parityDb(db), samples, { sql: { baseAlias: DELIVERY_GRAPH_READ_MODEL_BASE_ALIAS } });
+  db.close();
+});
+
+// ── 3. END-TO-END BEHAVIOUR on the real migration VIEW ────────────────────────────────────────────
+
+test("the migration 087 VIEW maps the run lifecycle onto the coarse STAGE_KEYS bracket + render state", () => {
+  const db = viewDb();
+  // awaiting-approval (reserved legacy pre-dispatch rows) → the initial Requested bracket.
+  addRun(db, "await", { status: "awaiting-approval", phase: "Awaiting approval" });
+  // running, dispatch begun, no PR frontier → the deterministic initial Implementing.
+  addRun(db, "run-plain", { status: "running", phase: "Running" });
+  // terminal done → Done / ok (settles outright).
+  addRun(db, "done", { status: "done", phase: "Completed" });
+  // terminal failed / abandoned → the Done tail bracket / failed.
+  addRun(db, "failed", { status: "failed", phase: "Failed" });
+  addRun(db, "aband", { status: "abandoned", phase: "Failed" });
+
+  assertEquals(projection(db, "await"), { stage: "Requested", stage_state: null, park_label: null, status: "awaiting-approval" });
+  assertEquals(projection(db, "run-plain"), { stage: "Implementing", stage_state: null, park_label: null, status: "running" });
+  assertEquals(projection(db, "done"), { stage: "Done", stage_state: "ok", park_label: null, status: "done" });
+  assertEquals(projection(db, "failed"), { stage: "Done", stage_state: "failed", park_label: null, status: "failed" });
+  assertEquals(projection(db, "aband"), { stage: "Done", stage_state: "failed", park_label: null, status: "abandoned" });
+  db.close();
+});
+
+test("a running run with a member PR still in flight (root_request_key = run_key) tempers to Converging; all-terminal members stay Implementing", () => {
+  const db = viewDb();
+  addRun(db, "run-c", { status: "running", phase: "Running" });
+  addPr(db, "pr-open", "run-c", "converging");
+  addPr(db, "pr-merged", "run-c", "merged");
+
+  addRun(db, "run-i", { status: "running", phase: "Running" });
+  addPr(db, "pr-done", "run-i", "merged");
+  addPr(db, "pr-gone", "run-i", "abandoned");
+
+  assertEquals(projection(db, "run-c").stage, "Converging");
+  assertEquals(projection(db, "run-i").stage, "Implementing");
+  db.close();
+});
+
+test("an out-of-band-terminated member PR (derived_status='abandoned', base frozen) is NOT held in the live frontier", () => {
+  const db = viewDb();
+  addRun(db, "run-x", { status: "running", phase: "Running" });
+  // Base status frozen at 'converging' but the reconciler's derive edge reports 'abandoned' (resolved).
+  addPr(db, "pr-stale", "run-x", "converging", "abandoned");
+  assertEquals(projection(db, "run-x").stage, "Implementing");
+  db.close();
+});
+
+test("a DERIVE-ONLY terminated run (base status frozen at 'running', derived_status='failed') renders Done/failed, not wedged Implementing", () => {
+  const db = viewDb();
+  addRun(db, "run-t", { status: "running", phase: "Running", derived_status_override: "failed" });
+  const p = projection(db, "run-t");
+  assertEquals(p.stage, "Done");
+  assertEquals(p.stage_state, "failed");
+  // The effective status the pages filter on tracks the derive edge (so it drops to History).
+  assertEquals(p.status, "failed");
+  db.close();
+});
+
+test("park_label carries the actionable 'Parked on human node: <label>' text (only when parked); the pipeline stage is unaffected", () => {
+  const db = viewDb();
+  addRun(db, "run-park", { status: "running", phase: "Parked on human node: manual OTP publish", phase_node_id: "delivery-human-task__n3" });
+  const p = projection(db, "run-park");
+  assertEquals(p.park_label, "Parked on human node: manual OTP publish");
+  // A pre-PR parked frontier still pins the scalar activeField to the current bracket (Implementing).
+  assertEquals(p.stage, "Implementing");
+  // A non-park phase leaves park_label null.
+  addRun(db, "run-np", { status: "running", phase: "Running" });
+  assertEquals(projection(db, "run-np").park_label, null);
+  db.close();
+});
+
+// ── 4. PARITY vs TODAY'S PHASE (the acceptance parity) ────────────────────────────────────────────
+
+test("the derived stepper matches TODAY's plain `phase` text (deriveDeliveryPhase) for representative runs, retaining the actionable park label", () => {
+  const db = viewDb();
+  const humanLabels = { "delivery-human-task__n3": "manual OTP publish" };
+  // Each fixture is what `pollDeliveryGraphPhase` records today; assert the derived stepper equals the
+  // step that plain phase text conveyed, and the park label is preserved when parked.
+  const cases: Array<{
+    key: string;
+    state: ProcessInstanceState | null;
+    tasks: Array<{ elementId?: string }>;
+    expectStage: StepKey;
+    expectState: string | null;
+    parked: boolean;
+  }> = [
+    { key: "running", state: "ACTIVE", tasks: [], expectStage: "Implementing", expectState: null, parked: false },
+    { key: "parked", state: "ACTIVE", tasks: [{ elementId: "delivery-human-task__n3" }], expectStage: "Implementing", expectState: null, parked: true },
+    { key: "completed", state: "COMPLETED", tasks: [], expectStage: "Done", expectState: "ok", parked: false },
+    { key: "terminated", state: "TERMINATED", tasks: [], expectStage: "Done", expectState: "failed", parked: false },
+  ];
+  for (const c of cases) {
+    const proj = deriveDeliveryPhase(c.state, c.tasks, humanLabels);
+    addRun(db, c.key, { status: proj.status, phase: proj.phase, phase_node_id: proj.phase_node_id });
+    const p = projection(db, c.key);
+    assertEquals(p.stage, c.expectStage, `stage for today's phase "${proj.phase}"`);
+    assertEquals(p.stage_state, c.expectState, `state for today's phase "${proj.phase}"`);
+    assertEquals(p.park_label, c.parked ? proj.phase : null, `park_label for today's phase "${proj.phase}"`);
+  }
+  db.close();
+});
+
+// ── 5. ONE PROJECTION — the render half agrees with the canonical axis reducer ────────────────────
+
+test("the VIEW's (stage, state) equals reduceFrontier of the single derived branch (feature + delivery-graph collapse onto one axis)", () => {
+  const db = viewDb();
+  const settle = (status: string): string | null => (status === "done" ? "done" : status === "failed" || status === "abandoned" ? status : null);
+  addRun(db, "b-run", { status: "running", phase: "Running" });
+  addRun(db, "b-done", { status: "done", phase: "Completed" });
+  addRun(db, "b-failed", { status: "failed", phase: "Failed" });
+  for (const key of ["b-run", "b-done", "b-failed"]) {
+    const p = projection(db, key);
+    const status = key.slice(2);
+    const reduced = reduceFrontier([{ nodeId: key, step: p.stage as StepKey, terminal: settle(status) }]);
+    assertEquals(p.stage, reduced.step, `single-branch reduce step for ${key}`);
+    assertEquals(p.stage_state, reduced.state, `single-branch reduce state for ${key}`);
+  }
+  db.close();
+});
+
+// ── 6. PAGE BINDINGS ──────────────────────────────────────────────────────────────────────────────
+
+function pipelineColumnsOf(page: unknown): Array<Record<string, unknown>> {
+  const cols: Array<Record<string, unknown>> = [];
+  const walk = (node: unknown): void => {
+    if (Array.isArray(node)) return node.forEach(walk);
+    if (node && typeof node === "object") {
+      const o = node as Record<string, unknown>;
+      if (o.kind === "pipeline") cols.push(o);
+      for (const v of Object.values(o)) walk(v);
+    }
+  };
+  walk(page);
+  return cols;
+}
+
+function datasourceTables(page: unknown): string[] {
+  const tables: string[] = [];
+  const walk = (node: unknown): void => {
+    if (Array.isArray(node)) return node.forEach(walk);
+    if (node && typeof node === "object") {
+      const o = node as Record<string, unknown>;
+      if (o.kind === "datasource" && typeof o.table === "string") tables.push(o.table);
+      for (const v of Object.values(o)) walk(v);
+    }
+  };
+  walk(page);
+  return tables;
+}
+
+for (const pageName of ["delivery-graphs.page.json", "delivery-graph-detail.page.json", "overview.page.json"]) {
+  test(`${pageName} binds the derived delivery_graph_read_model VIEW and a pipeline stepper (not a plain phase cell on the raw table)`, () => {
+    const page = PAGE(pageName);
+    const tables = datasourceTables(page);
+    assert(tables.includes("delivery_graph_read_model"), `${pageName} must bind delivery_graph_read_model`);
+    assert(!tables.includes("delivery_graph_runs"), `${pageName} must NOT bind the raw delivery_graph_runs table for the run grid`);
+
+    const pipelines = pipelineColumnsOf(page);
+    assert(pipelines.length >= 1, `${pageName} must render a pipeline stepper for the delivery graph`);
+    const p = pipelines.find((c) => c.activeField === "stage");
+    assert(p !== undefined, `${pageName} pipeline must bind activeField "stage"`);
+    assertEquals(p.stateField, "stage_state");
+    // v1 does NOT populate the aggregate's notInPathField (§4b §287-291).
+    assert(p.notInPathField === undefined, `${pageName} S7 pipeline must not bind notInPathField (deferred with the set-valued render)`);
+    // The six canonical STAGE_KEYS brackets, seeded from the axis.
+    const stages = p.stages as Array<{ key: string }>;
+    assertEquals(stages.map((s) => s.key), ["Requested", "Implementing", "PR open", "Converging", "Merging", "Done"]);
+  });
+}

package/app/deliveryGraphReadModel.ts

@@ -0,0 +1,166 @@
+// app/deliveryGraphReadModel.ts — the delivery-graph progress projection onto the canonical step axis
+// (ADR 0006 §4b, S7). DECLARED ONCE and compiled to BOTH backends via Urban's ADR-0065 primitives
+// (`defineRollup` + `defineReadModel`, `@nanobpm/urban`), exactly like the feature/plan read models
+// (app/featureReadModel.ts, app/planReadModel.ts are the exemplars).
+//
+// WHAT S7 UNIFIES. Before §4b the delivery-graph surface rendered `delivery_graph_runs.phase` — a bare
+// text projection the user-task park poll (`pollDeliveryGraphPhase` → `deriveDeliveryPhase`) recomputes
+// ("Running" / "Parked on human node: <label>" / "Completed" / "Failed") — on a DIFFERENT renderer from
+// feature's `pipeline` stepper. S7 collapses feature + delivery-graph onto the ONE step axis
+// (app/stepAxis.ts) rendered by the ONE `pipeline` kind. This model supplies the delivery-graph half:
+// the `pipeline` column's `activeField` (`stage`, a `STAGE_KEYS` value) and `stateField` (`stage_state`)
+// derived from the run's lifecycle, with the actionable park text carried alongside on a companion
+// `park_label` field (so promoting the stepper does not drop the `Parked on human node: <label>` detail
+// the plain Phase cell showed today).
+//
+// PER-SHAPE CORRELATION (§4b §241-278, S7 rollout §558-605). A delivery-graph run has NO aggregate
+// `pr_key`; its downstream PRs attach via `pull_requests.root_request_key = delivery_graph_runs.run_key`
+// (`app/lineage.ts` `collectRootPrs`). So this model reads the run row and, via the
+// `delivery_graph_pr_counts` rollup keyed on `root_request_key`, whether any member PR is still in
+// flight — the correlated-PR signal that tempers a `running` run to `Converging` (matching the shipped
+// `deliveryOriginStage`, app/lineage.ts). This is NOT a `process_key` join: `pull_requests.process_key`
+// is reassigned downstream (convergence, then merge), so it is not the run's identity.
+//
+// LIFECYCLE-STAGE FIDELITY, STATELESS COARSE KEY (§4b §413-449). `delivery_graph_runs` stores no stage
+// column (only `phase`/park metadata, whose values like "Running" are NOT `STAGE_KEYS`), and at S7 a
+// running node with no open user task exposes only a generic `Running` with no node id. So the `stage`
+// is derived STATELESSLY from the run's current effective status + the member-PR-in-flight signal on
+// every read (nothing is held; the read model persists no stage key), mapped onto a CONFIGURED
+// `STAGE_KEYS` bracket — never a fabricated cell position or an unconfigured `activeField` label:
+//   - terminal `done`               → `Done`,  state `ok`     (settles outright; does not wait on PRs).
+//   - terminal `failed`/`abandoned` → `Done`,  state `failed` (the axis tail bracket).
+//   - `awaiting-approval` (reserved, pre-dispatch legacy rows) → `Requested` (the initial bracket).
+//   - `running` with a member PR still in flight → `Converging`.
+//   - `running` otherwise (dispatch begun, no PR frontier) → `Implementing` (the deterministic initial
+//     value for a freshly-running graph, §433).
+// At S7 a graph collapses to this ONE coarse run-level step: `delivery_graph_runs` stores a single
+// `phase` per run, not a per-branch topology, so the least-advanced-active frontier reduction
+// (app/stepAxis.ts `reduceFrontier`) is DEFINED but not yet computable from this source — the genuine
+// per-branch reduction is deferred to S8's element-instance read model. A single-track feature and a
+// single-step graph both reduce trivially to their one branch.
+
+import { and, caseWhen, col, countWhere, defineReadModel, defineRollup, type Expr, eq, fromTable, gt, isNotNull, lit, not, or, type ReadModel, type Rollup, rcol, when } from "@nanobpm/urban";
+import { TERMINAL_STATUSES } from "./deliveryStatuses.ts";
+import { PR_TRACKING_RELATION } from "./planRollups.ts";
+
+/** The slice-PR relation the member-PR rollup folds over: the auto-provisioned
+ * `pull_requests__tracking` derived VIEW (ADR-0065), NOT the raw `pull_requests` table — so a member PR
+ * that was terminated out of band reads its terminal-folded `derived_status` (`abandoned`) and is not
+ * held in the live frontier (§4b S7 rollout §558-562). Re-exported from app/planRollups.ts — the ONE
+ * canonical declaration of the tracking-relation name — so this model shares that single source rather
+ * than reintroducing a drift surface if the relation is ever renamed. */
+export { PR_TRACKING_RELATION };
+
+/** The delivery-graph member-PR rollup: one row per `root_request_key` with the single count the
+ * `Implementing`→`Converging` temper reads — how many attached PRs are still IN FLIGHT (their
+ * terminal-folded `derived_status` is NOT in {@link TERMINAL_STATUSES}; a NULL status is not terminal,
+ * so a DB desync counts as in flight rather than wrongly settling the run). Keyed on `root_request_key`
+ * so the read-model lookup joins `delivery_graph_runs.run_key = root_request_key` (the per-shape
+ * correlation contract). The `isNotNull(root_request_key)` guard keeps unrooted PRs (their own roots)
+ * out of every run's count. */
+export const deliveryGraphPrCounts: Rollup = defineRollup({
+  name: "delivery_graph_pr_counts",
+  source: fromTable(PR_TRACKING_RELATION),
+  groupBy: ["root_request_key"],
+  aggregates: {
+    prs_in_flight: countWhere(
+      and(
+        isNotNull(col("root_request_key")),
+        not(or(...TERMINAL_STATUSES.map((s) => eq(col("derived_status"), lit(s))))),
+      ),
+    ),
+  },
+});
+
+/** Every delivery-graph rollup, in managed-VIEW dependency order. The migration emits their VIEW DDL in
+ * this order; the parity guard iterates it. */
+export const DELIVERY_GRAPH_ROLLUPS: readonly Rollup[] = [deliveryGraphPrCounts];
+
+/** The base table the read model reads: the auto-provisioned `delivery_graph_runs__tracking` derived
+ * VIEW (ADR-0065), NOT the raw `delivery_graph_runs` table. It re-exports `delivery_graph_runs.*` plus a
+ * terminal-folded `derived_status` (an out-of-band-terminated run reads `failed` per the
+ * `instanceTracking` `onTerminated` edge, else the base `status` — which `pollDeliveryGraphPhase` owns
+ * the `COMPLETED → done` reconciliation for). The status-classifying derivation reads `derived_status`,
+ * so a terminated run renders `Done` instead of freezing at `Implementing`/`Converging`. */
+export const DELIVERY_GRAPH_READ_MODEL_BASE_TABLE = "delivery_graph_runs__tracking";
+
+/** The base alias the managed VIEW gives `delivery_graph_runs__tracking` — pinned so the emitted
+ * derived-column SQL (`dg."col"`) matches the migration exactly (the drift guard compares this alias). */
+export const DELIVERY_GRAPH_READ_MODEL_BASE_ALIAS = "dg";
+
+/** The rollup-lookup alias `rcol(...)` reads under — the `LEFT JOIN delivery_graph_pr_counts pc ON
+ * dg.run_key = pc.root_request_key` target. Pinned so the emitted SQL and the migration's JOIN agree. */
+export const PR_COUNTS_LOOKUP = "pc";
+
+/** The effective (terminal-folded) status column the derivation classifies on — the tracking VIEW's
+ * `derived_status`. Single source of truth for the name so the derivation can't drift from it. */
+export const EFFECTIVE_STATUS_COLUMN = "derived_status";
+
+const ds = col(EFFECTIVE_STATUS_COLUMN);
+
+/** Whether a member PR of the run is still in flight — `prs_in_flight > 0` on the rollup lookup (0 on a
+ * LEFT-JOIN miss, so a run with no attached PRs reads not-in-flight). Tempers a `running` run to
+ * `Converging`, matching the shipped `deliveryOriginStage` (app/lineage.ts). */
+const memberPrInFlight: Expr = gt(rcol(PR_COUNTS_LOOKUP, "prs_in_flight"), lit(0));
+
+/**
+ * The derived `stage` — a CONFIGURED `STAGE_KEYS` value (never a raw `phase` string), from the stateless
+ * coarse-key rule (see the module header). Terminal statuses settle the step outright (before the PR
+ * check), so `done` does not block on an open PR; a live `running` frontier with a member PR in flight
+ * reads `Converging`, else `Implementing` (the deterministic initial value for a freshly-running graph).
+ * `awaiting-approval` (reserved legacy pre-dispatch rows) maps to the initial `Requested` bracket.
+ */
+const stage: Expr = caseWhen(
+  [
+    when(eq(ds, lit("done")), lit("Done")),
+    when(or(eq(ds, lit("failed")), eq(ds, lit("abandoned"))), lit("Done")),
+    when(eq(ds, lit("awaiting-approval")), lit("Requested")),
+    when(memberPrInFlight, lit("Converging")),
+  ],
+  lit("Implementing"),
+);
+
+/**
+ * The active step's render state in the `pipeline` column's vocabulary (`ok`/`failed`/`blocked`/null):
+ * a `done` graph is a success terminal (`ok`), a `failed`/`abandoned` graph is a failed terminal
+ * (`failed`), else in progress (`null`). A delivery-graph run has no `blocked` terminal in its lifecycle
+ * union, so that tier never arises here. Reuses the canonical terminal tiers (app/stepAxis.ts).
+ */
+const stageState: Expr = caseWhen(
+  [
+    when(eq(ds, lit("done")), lit("ok")),
+    when(or(eq(ds, lit("failed")), eq(ds, lit("abandoned"))), lit("failed")),
+  ],
+  lit(null),
+);
+
+/** The keys of {@link deliveryGraphReadModel}'s DERIVED columns, in the order the migration emits them.
+ * Base columns are identity pass-throughs (listed in the migration directly); `park_label` is a
+ * hand-authored display column over the base `phase`/`phase_node_id` (no TS twin). */
+export const DELIVERY_GRAPH_READ_MODEL_DERIVED = ["stage", "stage_state"] as const;
+export type DeliveryGraphReadModelDerivedColumn = (typeof DELIVERY_GRAPH_READ_MODEL_DERIVED)[number];
+
+/**
+ * The declare-once `delivery_graph_read_model` derived columns. `selectBaseColumns: false` because the
+ * base columns are plain identity pass-throughs enumerated in the migration (so the static pages↔schema
+ * contract guard, which reads a VIEW's columns off an aliased select-list, sees them). Both the
+ * migration VIEW (`sqlSelectFor`, drift-guarded) and the runtime TS oracle (`fnFor`) are generated from
+ * THIS single declaration; the member-PR rollup lookup supplies the in-flight signal the CASE consumes.
+ */
+export const deliveryGraphReadModel: ReadModel = defineReadModel({
+  name: "delivery_graph_read_model",
+  baseTable: DELIVERY_GRAPH_READ_MODEL_BASE_TABLE,
+  selectBaseColumns: false,
+  lookups: [
+    {
+      as: PR_COUNTS_LOOKUP,
+      rollup: deliveryGraphPrCounts,
+      on: [{ base: "run_key", rollup: "root_request_key" }],
+      defaults: { prs_in_flight: 0 },
+    },
+  ],
+  derive: {
+    stage,
+    stage_state: stageState,
+  },
+});

package/app/stepAxis.test.ts

@@ -0,0 +1,142 @@
+// Unit coverage for the ONE canonical progress step axis (app/stepAxis.ts) — the single source of the
+// derived stepper's vocabulary, cell→step mapping, terminal-tier normalization, and the deterministic
+// parallel-frontier reduction (ADR 0006 §4b, issue #541 / S7).
+
+import { test } from "node:test";
+import { assert, assertEquals } from "#test-assert";
+import { STAGE_DONE_STATUSES, STAGE_KEYS } from "./stage.ts";
+import {
+  CELL_STEP,
+  DONE_TERMINAL,
+  type FrontierBranch,
+  INITIAL_STEP,
+  reduceFrontier,
+  STEP_KEYS,
+  stepOrdinal,
+  terminalTier,
+  TERMINAL_STEP,
+} from "./stepAxis.ts";
+
+test("STEP_KEYS is SEEDED from STAGE_KEYS — the axis cannot fork across surfaces", () => {
+  assertEquals([...STEP_KEYS], [...STAGE_KEYS]);
+  // The two lifecycle bookends are the head/tail of the shared axis.
+  assertEquals(INITIAL_STEP, STAGE_KEYS[0]);
+  assertEquals(INITIAL_STEP, "Requested");
+  assertEquals(TERMINAL_STEP, STAGE_KEYS[STAGE_KEYS.length - 1]);
+  assertEquals(TERMINAL_STEP, "Done");
+});
+
+test("the explicit cell→step mapping collapses every process cell onto an existing STAGE_KEYS bracket (no new axis entries)", () => {
+  // The three executable cells map to their lifecycle bracket; the interstitial wait/human/escalation
+  // cells HOLD at the host bracket rather than owning a distinct step.
+  assertEquals(CELL_STEP.implement, "Implementing");
+  assertEquals(CELL_STEP.converge, "Converging");
+  assertEquals(CELL_STEP.merge, "Merging");
+  assertEquals(CELL_STEP.wait, "Implementing");
+  assertEquals(CELL_STEP.human, "Converging");
+  assertEquals(CELL_STEP.escalation, "Converging");
+  // Every mapped bracket is a real axis key — v1 adds no stages, so the pipeline renderer is unchanged.
+  for (const step of Object.values(CELL_STEP)) {
+    assert(STEP_KEYS.includes(step), `cell step "${step}" is not a STAGE_KEYS member`);
+  }
+});
+
+test("stepOrdinal gives the axis total order the frontier reduction compares advancement by", () => {
+  assertEquals(stepOrdinal("Requested"), 0);
+  assertEquals(stepOrdinal("Implementing"), 1);
+  assertEquals(stepOrdinal("PR open"), 2);
+  assertEquals(stepOrdinal("Converging"), 3);
+  assertEquals(stepOrdinal("Merging"), 4);
+  assertEquals(stepOrdinal("Done"), 5);
+});
+
+test("terminalTier reuses the shipped stage_state tiers (converged/merged/done→ok, blocked distinct, failed/skipped/abandoned→failed, active→null)", () => {
+  assertEquals(terminalTier("merged"), "ok");
+  assertEquals(terminalTier("converged"), "ok");
+  assertEquals(terminalTier("done"), "ok");
+  assertEquals(terminalTier("blocked"), "blocked");
+  assertEquals(terminalTier("failed"), "failed");
+  assertEquals(terminalTier("skipped"), "failed");
+  assertEquals(terminalTier("abandoned"), "failed");
+  assertEquals(terminalTier("running"), null);
+  assertEquals(terminalTier("converging"), null);
+});
+
+test("terminalTier's partition is DERIVED from STAGE_DONE_STATUSES — every canonical terminal is tiered exactly once (drift guard)", () => {
+  // The stepAxis module already throws at load if the partition drifts from STAGE_DONE_STATUSES; assert
+  // the coupling here too so a reviewer sees the invariant. Every STAGE_DONE_STATUSES member gets a
+  // non-null tier, and the only status tiered OUTSIDE that canonical set is the delivery-graph `done`.
+  for (const status of STAGE_DONE_STATUSES) {
+    assert(terminalTier(status) !== null, `STAGE_DONE_STATUSES member "${status}" must be tiered by terminalTier`);
+  }
+  assertEquals(terminalTier(DONE_TERMINAL), "ok");
+  assert(!STAGE_DONE_STATUSES.includes(DONE_TERMINAL), "`done` is the S7 canonical success value, tiered on top of STAGE_DONE_STATUSES (not a member of it)");
+});
+
+// ── reduceFrontier — the deterministic parallel-frontier rollup (§4b §280-332) ────────────────────
+
+const branch = (nodeId: string, step: FrontierBranch["step"], terminal: string | null = null): FrontierBranch => ({ nodeId, step, terminal });
+
+test("a single branch reduces trivially to itself (the feature + S7 delivery-graph coarse case)", () => {
+  assertEquals(reduceFrontier([branch("n0", "Implementing")]), { step: "Implementing", state: null });
+  assertEquals(reduceFrontier([branch("n0", "Done", "done")]), { step: "Done", state: "ok" });
+  assertEquals(reduceFrontier([branch("n0", "Done", "failed")]), { step: "Done", state: "failed" });
+});
+
+test("all-active frontier reduces to the LEAST-ADVANCED active branch (never further than the slowest in-flight branch)", () => {
+  const r = reduceFrontier([branch("a", "Merging"), branch("b", "Implementing"), branch("c", "Converging")]);
+  assertEquals(r, { step: "Implementing", state: null });
+});
+
+test("all-active ties on step break deterministically by stable node id", () => {
+  const r = reduceFrontier([branch("z", "Converging"), branch("a", "Converging")]);
+  assertEquals(r, { step: "Converging", state: null });
+});
+
+test("MIXED with only SUCCESS terminals + active branches reduces to the least-advanced ACTIVE branch (terminal branches are past, not 'still blocked on')", () => {
+  const r = reduceFrontier([branch("done1", "Done", "merged"), branch("active1", "Converging"), branch("active2", "Merging")]);
+  assertEquals(r, { step: "Converging", state: null });
+});
+
+test("MIXED: a NON-SUCCESS terminal (failed) takes precedence over in-flight siblings — the aggregate renders that branch's step + failed state", () => {
+  const r = reduceFrontier([branch("active", "Implementing"), branch("bad", "Converging", "failed"), branch("done", "Done", "merged")]);
+  assertEquals(r, { step: "Converging", state: "failed" });
+});
+
+test("MIXED: a blocked terminal surfaces as the DISTINCT blocked render state (operator-actionable), not masked by an active sibling", () => {
+  const r = reduceFrontier([branch("active", "Merging"), branch("stuck", "Implementing", "blocked")]);
+  assertEquals(r, { step: "Implementing", state: "blocked" });
+});
+
+test("MULTIPLE non-success terminals tie-break by earliest terminal step, then stable node id", () => {
+  // Two failed branches at different steps → earliest step wins.
+  assertEquals(
+    reduceFrontier([branch("a", "Converging", "failed"), branch("b", "Implementing", "blocked"), branch("act", "Merging")]),
+    { step: "Implementing", state: "blocked" },
+  );
+  // Two non-success terminals at the SAME step → stable node id wins (and its own render state).
+  assertEquals(
+    reduceFrontier([branch("z", "Converging", "failed"), branch("a", "Converging", "blocked")]),
+    { step: "Converging", state: "blocked" },
+  );
+});
+
+test("ALL-TERMINAL, all success → done (the axis tail, ok)", () => {
+  const r = reduceFrontier([branch("a", "Converging", "converged"), branch("b", "Merging", "merged")]);
+  assertEquals(r, { step: "Done", state: "ok" });
+});
+
+test("ALL-TERMINAL with any non-success → earliest non-success terminal step (same tie-break)", () => {
+  const r = reduceFrontier([branch("a", "Merging", "merged"), branch("b", "Converging", "failed"), branch("c", "Implementing", "blocked")]);
+  assertEquals(r, { step: "Implementing", state: "blocked" });
+});
+
+test("reduceFrontier throws on an empty frontier — a unit always has at least its own branch", () => {
+  let threw = false;
+  try {
+    reduceFrontier([]);
+  } catch {
+    threw = true;
+  }
+  assert(threw, "expected reduceFrontier([]) to throw");
+});

package/app/stepAxis.ts

@@ -0,0 +1,217 @@
+// app/stepAxis.ts — the ONE canonical progress step axis for the derived stepper (ADR 0006 §4b, S7).
+//
+// §4b collapses the unit's three progress projections (feature `deriveStage`, epic write-time
+// `epic_phase`, delivery-graph `pollDeliveryGraphPhase`) onto ONE derivation over a single step axis,
+// rendered by the ONE `pipeline` renderer kind. This module owns the canonical definition of that
+// axis: the ordered steps, the explicit cell→step mapping, the terminal-tier normalization, and the
+// deterministic parallel-frontier reduction. Feature (`app/stage.ts` / `app/featureReadModel.ts`) and
+// delivery-graph (`app/deliveryGraphReadModel.ts`) both project onto it; there is no per-surface
+// re-declaration of the step vocabulary.
+//
+// SEEDED FROM `STAGE_KEYS`, OWNS THE MAPPING (§4b §217-232). `STAGE_KEYS` (app/stage.ts) is the closest
+// EXISTING projection of the axis but it is NOT literally a clean cell sequence — it mixes lifecycle
+// states (`Requested` / `PR open` / `Done`) with process cells (`implement` / `converge` / `merge`),
+// and hosts interstitial `wait` / `human` / `escalation` cells. So this module SEEDS `STEP_KEYS` from
+// `STAGE_KEYS` (the single source of truth for the six brackets) but adds the thing `STAGE_KEYS` lacks:
+// an explicit map of which cell entry/exit each step corresponds to, and how the interstitial cells
+// collapse into an existing bracket. v1 leaves the two existing axis consumers physically in place (the
+// exported `STAGE_KEYS` and the static `stages` array in `pages/feature.page.json`) and only SEEDS this
+// mapping from them — deriving/retiring those duplicates is a flagged follow-up, not S7.
+//
+// LIFECYCLE-STAGE FIDELITY ONLY (S7). Per §4b, S7 renders the coarse LIFECYCLE stage, not a per-cell
+// position: even feature is not per-cell today (`deriveStage` collapses a readiness-probe/timer park or
+// an active `implement-task` all to `Implementing`). True mid-cell / per-node resolution is the S8
+// element-instance source (#542, #473). The interstitial-cell mapping below therefore documents the
+// bracket each cell COLLAPSES into; it does not add per-cell steps.
+
+import { STAGE_DONE_STATUSES, STAGE_KEYS, type StageKey, type StageState } from "./stage.ts";
+
+/** The canonical ordered step axis — SEEDED from `STAGE_KEYS` (app/stage.ts), the single source of
+ * truth for the six pipeline brackets: Requested → Implementing → PR open → Converging → Merging →
+ * Done. This module owns the cell→step MAPPING onto these keys; the keys themselves stay sourced from
+ * `STAGE_KEYS` so the axis cannot fork across surfaces. */
+export const STEP_KEYS: readonly StageKey[] = STAGE_KEYS;
+export type StepKey = StageKey;
+
+/** The deterministic INITIAL step for a pre-run / dispatch-pending / first-observation unit — the head
+ * of the axis (`Requested`, `STAGE_KEYS[0]`). Pins the scalar `activeField` so it is never undefined on
+ * a first observation with no prior lifecycle key (§4b §431-449). */
+export const INITIAL_STEP: StepKey = STEP_KEYS[0];
+
+/** The TERMINAL step — the tail of the axis (`Done`). A terminal unit pins its `activeField` here
+ * outright (with an `ok`/`failed` render state) so it can never render an undefined/invalid active
+ * stage (§4b §436-438). */
+export const TERMINAL_STEP: StepKey = STEP_KEYS[STEP_KEYS.length - 1];
+
+/** The process-cell vocabulary of the composed unit (§2/S4): the three executable pipeline cells
+ * (`implement` / `converge` / `merge`) plus the interstitial `wait` / `human` / `escalation` cells that
+ * can be inserted around them. */
+export type ProcessCell = "implement" | "converge" | "merge" | "wait" | "human" | "escalation";
+
+/**
+ * The explicit **cell → step** mapping (§4b's first deliverable). Each executable cell ENTERS its
+ * bracket when the token arrives and EXITS it when the token advances to the next cell's bracket; the
+ * three lifecycle markers bracket the cell run — a token before `implement` reads `Requested`, raising
+ * the PR on `implement` exit enters `PR open`, and a merged/terminal token reads `Done`.
+ *
+ * The interstitial `wait` / `human` / `escalation` cells do **not** own a distinct step — they HOLD the
+ * frontier at the bracket of the cell they interrupt (a human gate mid-convergence reads `Converging`,
+ * a wait-gate before implementation reads `Implementing`), collapsing into an existing `STAGE_KEYS`
+ * bracket rather than extending the axis. This is why the `pipeline` renderer needs no new stages for
+ * v1: every cell maps onto one of the six existing keys.
+ */
+export const CELL_STEP: Readonly<Record<ProcessCell, StepKey>> = {
+  implement: "Implementing",
+  converge: "Converging",
+  merge: "Merging",
+  // Interstitial cells collapse into the host bracket (hold, do not advance).
+  wait: "Implementing",
+  human: "Converging",
+  escalation: "Converging",
+};
+
+/** The zero-based ordinal of a step on the axis — the total order the frontier reduction compares
+ * "advancement" by. `-1` for an unknown key (defensive; every derived step is a `STEP_KEYS` member). */
+export function stepOrdinal(step: StepKey): number {
+  return STEP_KEYS.indexOf(step);
+}
+
+/** The renderer's terminal render-state tiers, reusing the SHIPPED `featureReadModel` `stage_state`
+ * basis (`STAGE_DONE_STATUSES` + the `stage_state` CASE, app/featureReadModel.ts) rather than inventing
+ * a second mapping (derivation-over-duplication, §4b §296-308):
+ *   - `ok`      — a SUCCESS terminal: `merged` / `converged` / the new canonical `done`.
+ *   - `blocked` — the renderer's DISTINCT operator-actionable `blocked` terminal (never folded away).
+ *   - `failed`  — a FAILED terminal: `failed` / `skipped` / `abandoned`.
+ *   - `null`    — not terminal (in progress).
+ * Note this is the PER-CELL / per-PR tier: `converged` is a success terminal here. The EPIC rollup's
+ * shape-aware predicate (`converged` is resolved-not-landed) is applied by the caller, not here. */
+export type TerminalTier = "ok" | "failed" | "blocked";
+
+/** The delivery-graph canonical SUCCESS terminal (app/deliveryGraphReadModel.ts). `STAGE_DONE_STATUSES`
+ * predates the S7 axis and does NOT include it, so it is the one status tiered ON TOP of the shared
+ * feature basis below (special-cased per the ADR §4b `done` value). */
+export const DONE_TERMINAL = "done";
+
+/** The per-cell terminal PARTITION — the SAME basis as featureReadModel's `stage_state` CASE
+ * (app/featureReadModel.ts: `merged`/`converged`→ok, `blocked`→blocked, `failed`/`skipped`/`abandoned`→
+ * failed). It is NOT a second hand-kept copy: every member is drawn from the shipped
+ * `STAGE_DONE_STATUSES`, and the exhaustiveness guard below fails at module load if this partition ever
+ * stops covering that canonical set EXACTLY — so a terminal status added to `STAGE_DONE_STATUSES` cannot
+ * silently fall through untiered (drift becomes a hard error, not a wrong render). */
+const SUCCESS_TERMINALS: readonly string[] = ["merged", "converged"];
+const BLOCKED_TERMINAL = "blocked";
+const FAILED_TERMINALS: readonly string[] = ["failed", "skipped", "abandoned"];
+
+// Structural coupling to the single source of truth: the partition must tier EXACTLY the members of
+// STAGE_DONE_STATUSES (the delivery-graph `done` value is tiered separately, so it is excluded here).
+const _tiered = new Set<string>([...SUCCESS_TERMINALS, BLOCKED_TERMINAL, ...FAILED_TERMINALS]);
+const _canonical = new Set<string>(STAGE_DONE_STATUSES);
+if (_tiered.size !== _canonical.size || [..._canonical].some((s) => !_tiered.has(s))) {
+  throw new Error(
+    "stepAxis terminalTier partition drifted from STAGE_DONE_STATUSES — every terminal status must be " +
+      `tiered exactly once. tiered=[${[..._tiered].sort().join(",")}] canonical=[${[..._canonical].sort().join(",")}]`,
+  );
+}
+
+export function terminalTier(status: string): TerminalTier | null {
+  if (status === DONE_TERMINAL || SUCCESS_TERMINALS.includes(status)) return "ok";
+  if (status === BLOCKED_TERMINAL) return "blocked";
+  if (FAILED_TERMINALS.includes(status)) return "failed";
+  return null;
+}
+
+/** A `TerminalTier` is a NON-SUCCESS terminal (`failed` / `blocked`) iff it is operator-actionable —
+ * the thing an in-flight sibling must not mask. `ok` (success) is the only success terminal. */
+export function isNonSuccessTerminal(tier: TerminalTier): boolean {
+  return tier === "failed" || tier === "blocked";
+}
+
+/** Map a terminal tier onto the `pipeline` column's `stateField` vocabulary (`ok`/`failed`/`blocked`).
+ * The raw canonical `done` never reaches the renderer verbatim (any other string silently degrades to
+ * in-progress), so a success terminal renders as `ok`. Total over the three tiers. */
+export function tierRenderState(tier: TerminalTier): StageState {
+  return tier;
+}
+
+/** One branch of an aggregate's active frontier, projected onto the canonical axis. `terminal` is the
+ * branch's canonical terminal status when it has settled (`merged`/`converged`/`done`/`blocked`/
+ * `failed`/`skipped`/`abandoned`), or `null` while the branch is still active at `step`. `nodeId` is
+ * the stable identity used as the deterministic tie-break. */
+export interface FrontierBranch {
+  nodeId: string;
+  step: StepKey;
+  terminal: string | null;
+}
+
+/** The reduced scalar the `pipeline` column binds: one `STAGE_KEYS` step plus its render state. */
+export interface ReducedFrontier {
+  step: StepKey;
+  state: StageState;
+}
+
+/** Deterministic tie-break: earliest step ordinal, then stable `nodeId`. */
+function earliest(a: FrontierBranch, b: FrontierBranch): FrontierBranch {
+  const da = stepOrdinal(a.step);
+  const db = stepOrdinal(b.step);
+  if (da !== db) return da < db ? a : b;
+  return a.nodeId <= b.nodeId ? a : b;
+}
+
+/**
+ * Reduce a parallel active frontier to ONE deterministic step for the scalar `pipeline` `activeField`
+ * (§4b §280-332). The `pipeline` column binds a single scalar, but an N-node/parallel DAG (epic waves,
+ * delivery graphs) can occupy incomparable cells at once, so the frontier is reduced deterministically:
+ *
+ *   - A **non-success terminal** (`failed` / `blocked`) takes PRECEDENCE in every case — it is an
+ *     operator-actionable signal an in-flight sibling must not mask. Among multiple non-success
+ *     terminals the tie-break is earliest terminal step, then stable node id; the aggregate renders at
+ *     that branch's step with that terminal's render state (`failed` / `blocked`).
+ *   - Otherwise, if any branch is still ACTIVE, reduce to the **least-advanced active branch** (the
+ *     "still blocked on" read) with an in-progress state — the aggregate never renders further along
+ *     than its slowest in-flight branch. Terminal (success) branches are past, not "still blocked on".
+ *   - Otherwise every branch is a SUCCESS terminal → `done` (the axis tail, `ok`).
+ *
+ * The shape-aware epic success predicate (`converged` is resolved-not-landed for an epic rollup, not a
+ * success terminal) is applied by the CALLER when it classifies each branch's `terminal`; this reducer
+ * treats whatever terminal it is handed per the per-cell tier. A single-branch unit (feature, and a
+ * delivery-graph at S7's coarse run-level fidelity) reduces trivially to that branch.
+ *
+ * Throws on an empty frontier — a unit always has at least its own (initial) branch; an empty input is
+ * a caller bug, not a renderable state.
+ */
+export function reduceFrontier(branches: readonly FrontierBranch[]): ReducedFrontier {
+  if (branches.length === 0) {
+    throw new Error("reduceFrontier: empty frontier — a unit always has at least one branch");
+  }
+
+  const nonSuccess: FrontierBranch[] = [];
+  const active: FrontierBranch[] = [];
+  for (const b of branches) {
+    if (b.terminal === null) {
+      active.push(b);
+      continue;
+    }
+    const tier = terminalTier(b.terminal);
+    // An unrecognised terminal degrades to a failed-tier signal (defensive; the caller passes canonical
+    // union terminals) so it is never silently masked by an in-flight sibling.
+    if (tier === null || isNonSuccessTerminal(tier)) nonSuccess.push(b);
+  }
+
+  if (nonSuccess.length > 0) {
+    const pick = nonSuccess.reduce(earliest);
+    const tier = terminalTier(pick.terminal ?? "") ?? "failed";
+    return { step: pick.step, state: tierRenderState(tier) };
+  }
+
+  if (active.length > 0) {
+    const pick = active.reduce(earliest);
+    return { step: pick.step, state: null };
+  }
+
+  // All branches are success terminals → the shared success bucket (`done`).
+  return { step: TERMINAL_STEP, state: "ok" };
+}
+
+/** Re-export the shipped terminal-status set the tier basis draws on, so a consumer can reference the
+ * single source without a second import of app/featureReadModel.ts. */
+export { STAGE_DONE_STATUSES };

package/db/migrations/087_delivery_graph_read_model.sql

@@ -0,0 +1,75 @@
+-- Delivery-graph read model: DECLARE ONCE, compile to BOTH backends (ADR-0065, nano-ide#452), for the
+-- ONE derived stepper (ADR 0006 §4b, issue #541 / S7).
+--
+-- Before §4b the delivery-graph surfaces rendered `delivery_graph_runs.phase` — a bare text projection
+-- the user-task park poll (`pollDeliveryGraphPhase`) recomputes — on a DIFFERENT renderer from
+-- feature's `pipeline` stepper. S7 collapses feature + delivery-graph onto the ONE canonical step axis
+-- (app/stepAxis.ts, seeded from `STAGE_KEYS`) rendered by the ONE `pipeline` kind. This migration adds
+-- the delivery-graph half: a `delivery_graph_read_model` VIEW that maps the run's lifecycle onto a
+-- CONFIGURED `STAGE_KEYS` bracket (`stage`) with a render state (`stage_state`), plus a companion
+-- `park_label` display column carrying the actionable "Parked on human node: <label>" text so promoting
+-- the stepper does not drop the detail the plain Phase cell showed.
+--
+-- Every DERIVED column below is emitted VERBATIM from the ONE declaration in
+-- app/deliveryGraphReadModel.ts — the member-PR rollup DDL from `deliveryGraphPrCounts.viewDdl()`, and
+-- `stage`/`stage_state` from `deliveryGraphReadModel.sqlSelectFor(col, { baseAlias: "dg" })` — which
+-- ALSO drive the runtime TS via `reduce`/`fnFor`. The two lowerings fall out of the same closed-DSL AST
+-- and cannot diverge; a drift guard (app/deliveryGraphReadModel.test.ts) fails if this file stops
+-- matching the declaration, and `assertRollupParity`/`assertReadModelParity` prove the SQL and TS
+-- lowerings agree.
+--
+-- PER-SHAPE CORRELATION. A delivery-graph run has no aggregate `pr_key`; its downstream PRs attach via
+-- `pull_requests.root_request_key = delivery_graph_runs.run_key`. The `delivery_graph_pr_counts` rollup
+-- folds the member PRs (through `pull_requests__tracking.derived_status`, so an out-of-band-terminated
+-- PR is not held in flight) grouped by `root_request_key`, and the read model LEFT JOINs it on
+-- `dg.run_key = pc.root_request_key`. `prs_in_flight > 0` tempers a `running` run to `Converging`,
+-- matching the shipped `deliveryOriginStage` (app/lineage.ts) — NOT a `process_key` join (that key is
+-- reassigned to the downstream convergence/merge instances).
+--
+-- SEMANTICS. The status-classifying `stage`/`stage_state` read the terminal-folded `derived_status` off
+-- the auto-provisioned `delivery_graph_runs__tracking` derived VIEW (ADR-0065), so a cancelled run
+-- renders `Done`/`failed` instead of freezing at `Implementing`/`Converging`. Base columns stay aliased
+-- identity pass-throughs (so the static pages↔schema contract guard sees the VIEW's columns), sourced
+-- off `delivery_graph_runs__tracking`'s re-export of the base `delivery_graph_runs.*`; `status` is the
+-- effective `COALESCE(derived_status, status)` so the pages' Active/History status filter tracks a
+-- terminated run. `park_label` is a hand-authored DISPLAY column (D3 — display formatting is out of the
+-- framework AST, so it carries no TS twin): the run's `phase` when it is parked on a human node
+-- (`phase_node_id` set), else NULL.
+--
+-- Forward-only VIEW definition (DROP then CREATE). `delivery_graph_runs__tracking` is the managed VIEW
+-- urban provisions at mount; SQLite does not validate a view body at CREATE time, so this migration
+-- (which runs before that mount) is created fine and resolves once the managed VIEW exists. The runner
+-- wraps each file in its own transaction, so this file must NOT contain BEGIN/COMMIT. Numbered after 085.
+
+DROP VIEW IF EXISTS delivery_graph_read_model;
+DROP VIEW IF EXISTS delivery_graph_pr_counts;
+
+CREATE VIEW IF NOT EXISTS "delivery_graph_pr_counts" AS
+SELECT
+  "__urban_rollup_src"."root_request_key" AS "root_request_key",
+  SUM(CASE WHEN COALESCE(((NOT COALESCE(("__urban_rollup_src"."root_request_key" IS NULL), 0)) AND (NOT COALESCE(COALESCE((COALESCE(("__urban_rollup_src"."derived_status" = 'converged'), 0) OR COALESCE(("__urban_rollup_src"."derived_status" = 'merged'), 0) OR COALESCE(("__urban_rollup_src"."derived_status" = 'abandoned'), 0)), 0), 0))), 0) THEN 1 ELSE 0 END) AS "prs_in_flight"
+FROM "pull_requests__tracking" "__urban_rollup_src"
+GROUP BY "__urban_rollup_src"."root_request_key";
+
+CREATE VIEW delivery_graph_read_model AS
+SELECT
+  dg.run_key AS run_key,
+  COALESCE(dg.derived_status, dg.status) AS status,
+  dg.process_key AS process_key,
+  dg.process_definition_id AS process_definition_id,
+  dg.digest AS digest,
+  dg.side_effecting AS side_effecting,
+  dg.node_count AS node_count,
+  dg.human_node_count AS human_node_count,
+  dg.side_effect_count AS side_effect_count,
+  dg.title AS title,
+  dg.phase AS phase,
+  dg.phase_node_id AS phase_node_id,
+  dg.human_labels AS human_labels,
+  dg.created_at AS created_at,
+  dg.updated_at AS updated_at,
+  CASE WHEN COALESCE(("dg"."derived_status" = 'done'), 0) THEN 'Done' WHEN COALESCE((COALESCE(("dg"."derived_status" = 'failed'), 0) OR COALESCE(("dg"."derived_status" = 'abandoned'), 0)), 0) THEN 'Done' WHEN COALESCE(("dg"."derived_status" = 'awaiting-approval'), 0) THEN 'Requested' WHEN COALESCE((COALESCE("pc"."prs_in_flight", 0) > 0), 0) THEN 'Converging' ELSE 'Implementing' END AS stage,
+  CASE WHEN COALESCE(("dg"."derived_status" = 'done'), 0) THEN 'ok' WHEN COALESCE((COALESCE(("dg"."derived_status" = 'failed'), 0) OR COALESCE(("dg"."derived_status" = 'abandoned'), 0)), 0) THEN 'failed' ELSE NULL END AS stage_state,
+  CASE WHEN dg.phase_node_id IS NOT NULL THEN dg.phase ELSE NULL END AS park_label
+FROM delivery_graph_runs__tracking dg
+LEFT JOIN delivery_graph_pr_counts pc ON dg.run_key = pc.root_request_key;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.143.0",
+  "version": "0.144.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/delivery-graph-detail.page.json

@@ -85,14 +85,30 @@
         "data": {
           "kind": "datasource",
           "source": "app",
-          "table": "delivery_graph_runs",
+          "table": "delivery_graph_read_model",
           "orderBy": { "field": "updated_at", "dir": "desc" },
           "filter": [{ "field": "run_key", "eqParam": true }]
         },
         "columns": [
           { "field": "title", "template": "{{title}}", "header": "Graph", "subtitleField": "run_key", "truncate": true, "width": "30%" },
           { "field": "status", "header": "Status", "link": { "kind": "processExplorer", "keyField": "process_key" } },
-          { "field": "phase", "header": "Phase", "truncate": true, "width": "30%" },
+          {
+            "field": "stage",
+            "header": "Pipeline",
+            "kind": "pipeline",
+            "stages": [
+              { "key": "Requested", "label": "Requested" },
+              { "key": "Implementing", "label": "Implementing" },
+              { "key": "PR open", "label": "PR open" },
+              { "key": "Converging", "label": "Converging" },
+              { "key": "Merging", "label": "Merging" },
+              { "key": "Done", "label": "Done" }
+            ],
+            "activeField": "stage",
+            "stateField": "stage_state",
+            "locus": { "field": "process_key", "link": { "kind": "processExplorer", "keyField": "process_key" } }
+          },
+          { "field": "park_label", "header": "Parked", "truncate": true, "width": "30%" },
           { "field": "node_count", "header": "Nodes" },
           { "field": "human_node_count", "header": "Human" },
           { "field": "side_effect_count", "header": "Side effects" },

package/pages/delivery-graphs.page.json

@@ -118,7 +118,7 @@
         "data": {
           "kind": "datasource",
           "source": "app",
-          "table": "delivery_graph_runs",
+          "table": "delivery_graph_read_model",
           "orderBy": { "field": "updated_at", "dir": "desc" },
           "filter": [{ "field": "status", "in": ["awaiting-approval", "running"] }]
         },
@@ -128,15 +128,32 @@
           { "label": "All", "filter": [] }
         ],
         "columns": [
-          { "field": "title", "template": "{{title}}", "header": "Graph", "subtitleField": "run_key", "truncate": true, "width": "20%", "link": { "kind": "page", "page": "delivery-graph-detail", "keyField": "run_key" } },
-          { "field": "status", "header": "Status", "truncate": true, "width": "12%", "link": { "kind": "processExplorer", "keyField": "process_key" } },
-          { "field": "process_key", "header": "Instance", "width": "9%", "truncate": true, "link": { "kind": "processExplorer", "keyField": "process_key" } },
-          { "field": "phase", "header": "Phase", "truncate": true, "width": "15%" },
+          { "field": "title", "template": "{{title}}", "header": "Graph", "subtitleField": "run_key", "truncate": true, "width": "18%", "link": { "kind": "page", "page": "delivery-graph-detail", "keyField": "run_key" } },
+          { "field": "status", "header": "Status", "truncate": true, "width": "10%", "link": { "kind": "processExplorer", "keyField": "process_key" } },
+          { "field": "process_key", "header": "Instance", "width": "8%", "truncate": true, "link": { "kind": "processExplorer", "keyField": "process_key" } },
+          {
+            "field": "stage",
+            "header": "Pipeline",
+            "kind": "pipeline",
+            "width": "18%",
+            "stages": [
+              { "key": "Requested", "label": "Requested" },
+              { "key": "Implementing", "label": "Implementing" },
+              { "key": "PR open", "label": "PR open" },
+              { "key": "Converging", "label": "Converging" },
+              { "key": "Merging", "label": "Merging" },
+              { "key": "Done", "label": "Done" }
+            ],
+            "activeField": "stage",
+            "stateField": "stage_state",
+            "locus": { "field": "process_key", "link": { "kind": "processExplorer", "keyField": "process_key" } }
+          },
+          { "field": "park_label", "header": "Parked", "truncate": true, "width": "12%" },
           { "field": "node_count", "header": "Nodes", "width": "5%" },
           { "field": "human_node_count", "header": "Human", "width": "5%" },
-          { "field": "side_effect_count", "header": "Effects", "width": "7%" },
-          { "field": "created_at", "header": "Dispatched", "width": "11%", "truncate": true, "format": "datetime" },
-          { "field": "updated_at", "header": "Updated", "width": "11%", "truncate": true, "format": "datetime" }
+          { "field": "side_effect_count", "header": "Effects", "width": "6%" },
+          { "field": "created_at", "header": "Dispatched", "width": "7%", "truncate": true, "format": "datetime" },
+          { "field": "updated_at", "header": "Updated", "width": "6%", "truncate": true, "format": "datetime" }
         ],
         "detail": {
           "fields": [

package/pages/overview.page.json

@@ -207,14 +207,30 @@
         "data": {
           "kind": "datasource",
           "source": "app",
-          "table": "delivery_graph_runs",
+          "table": "delivery_graph_read_model",
           "orderBy": { "field": "updated_at", "dir": "desc" },
           "filter": [{ "field": "status", "in": ["awaiting-approval", "running"] }]
         },
         "columns": [
           { "field": "title", "template": "{{title}}", "header": "Item", "subtitleField": "run_key", "truncate": true, "width": "30%", "link": { "kind": "page", "page": "delivery-graph-detail", "keyField": "run_key" } },
           { "field": "status", "header": "Status", "link": { "kind": "processExplorer", "keyField": "process_key" } },
-          { "field": "phase", "header": "Phase", "truncate": true, "width": "28%" },
+          {
+            "field": "stage",
+            "header": "Pipeline",
+            "kind": "pipeline",
+            "stages": [
+              { "key": "Requested", "label": "Requested" },
+              { "key": "Implementing", "label": "Implementing" },
+              { "key": "PR open", "label": "PR open" },
+              { "key": "Converging", "label": "Converging" },
+              { "key": "Merging", "label": "Merging" },
+              { "key": "Done", "label": "Done" }
+            ],
+            "activeField": "stage",
+            "stateField": "stage_state",
+            "locus": { "field": "process_key", "link": { "kind": "processExplorer", "keyField": "process_key" } }
+          },
+          { "field": "park_label", "header": "Parked", "truncate": true, "width": "28%" },
           { "field": "updated_at", "header": "Updated", "width": "9rem", "format": "datetime" }
         ],
         "detail": {

package/scripts/pages-contract.test.ts

@@ -333,8 +333,10 @@ test("issue #205: overview is the landing page and first nav item", async () =>
     plan_read_model: { field: "list_bucket", in: ["active"] },
     feature_runs: { field: "status", in: ["running", "escalated", "awaiting_operator"] },
     // The 4th dispatch surface (issue #386) — active delivery graphs. Both in-flight statuses
-    // (`awaiting-approval` parked at the gate, `running` dispatched) show here.
-    delivery_graph_runs: { field: "status", in: ["awaiting-approval", "running"] },
+    // (`awaiting-approval` parked at the gate, `running` dispatched) show here. Binds the derived
+    // `delivery_graph_read_model` VIEW (S7 / #541 — the single source of truth for the pipeline
+    // projection it also renders), which re-exports every run column plus the effective `status`.
+    delivery_graph_read_model: { field: "status", in: ["awaiting-approval", "running"] },
   };
   const grids = (overview.nodes ?? []).filter((n: Json) => n.type === "dataGrid");
   for (const [table, { field, in: values }] of Object.entries(expected)) {
@@ -361,19 +363,21 @@ test("issue #386: the human-facing Delivery Graphs surface is wired (nav tab, pa
   assert(tab, "pages/_nav.json must carry a `Delivery Graphs` nav tab → the delivery-graphs page");
 
   // 2) The page carries the compose → preview → dispatch App View (issue #441 — the rendered preview
-  //    that consumes the compile output), plus an in-flight grid over the delivery_graph_runs aggregate
-  //    that links to the per-graph detail page. The rich preview (mermaid diagram + humanNodes[] +
-  //    sideEffects[] + inline errors) can't render in a bare `actionForm` (its response is discarded),
-  //    so the surface is an `appView` embed over the SAME compile/dispatch doors.
+  //    that consumes the compile output), plus an in-flight grid over the delivery-graph run data (the
+  //    derived `delivery_graph_read_model` VIEW, S7 / #541 — which re-exports every `delivery_graph_runs`
+  //    column plus the pipeline projection) that links to the per-graph detail page. The rich preview
+  //    (mermaid diagram + humanNodes[] + sideEffects[] + inline errors) can't render in a bare
+  //    `actionForm` (its response is discarded), so the surface is an `appView` embed over the SAME
+  //    compile/dispatch doors.
   const page = JSON.parse(readFileSync(`${ROOT}pages/delivery-graphs.page.json`, "utf8"));
   const compose = (page.nodes ?? []).find(
     (n: Json) => n.type === "appView" && typeof n.props?.embed === "string" && n.props.embed.includes("delivery-graphs/embed.html"),
   );
   assert(compose, "delivery-graphs page must have an appView embedding ./delivery-graphs/embed.html (the compose → preview → dispatch view, #441)");
   const grid = (page.nodes ?? []).find(
-    (n: Json) => n.type === "dataGrid" && n.props?.data?.table === "delivery_graph_runs",
+    (n: Json) => n.type === "dataGrid" && n.props?.data?.table === "delivery_graph_read_model",
   );
-  assert(grid, "delivery-graphs page must have an in-flight grid over delivery_graph_runs");
+  assert(grid, "delivery-graphs page must have an in-flight grid over the derived delivery_graph_read_model VIEW");
   const linkCol = (grid.props?.columns ?? []).find((c: Json) => c.link?.page === "delivery-graph-detail");
   assert(
     linkCol && linkCol.link?.keyField === "run_key",
@@ -383,9 +387,9 @@ test("issue #386: the human-facing Delivery Graphs surface is wired (nav tab, pa
   // 3) The per-graph detail page reads the run aggregate scoped to the route param (run_key).
   const detail = JSON.parse(readFileSync(`${ROOT}pages/delivery-graph-detail.page.json`, "utf8"));
   const runGrid = (detail.nodes ?? []).find(
-    (n: Json) => n.type === "dataGrid" && n.props?.data?.table === "delivery_graph_runs",
+    (n: Json) => n.type === "dataGrid" && n.props?.data?.table === "delivery_graph_read_model",
   );
-  assert(runGrid, "delivery-graph-detail must bind a grid to delivery_graph_runs");
+  assert(runGrid, "delivery-graph-detail must bind a grid to the derived delivery_graph_read_model VIEW");
   assert(
     (runGrid.props?.data?.filter ?? []).some((fl: Json) => fl.field === "run_key" && fl.eqParam === true),
     "delivery-graph-detail must scope its run grid to the route param (run_key eqParam)",
@@ -399,7 +403,7 @@ test("issue #386: the human-facing Delivery Graphs surface is wired (nav tab, pa
     "overview subtitle must no longer say 'three dispatch surfaces' (a delivery graph is a 4th)",
   );
   const ovGrid = (overview.nodes ?? []).find(
-    (n: Json) => n.type === "dataGrid" && n.props?.data?.table === "delivery_graph_runs",
+    (n: Json) => n.type === "dataGrid" && n.props?.data?.table === "delivery_graph_read_model",
   );
   const ovLink = (ovGrid?.props?.columns ?? []).find((c: Json) => c.link?.page === "delivery-graph-detail");
   assert(