@nanobpm/nano-workforce 0.143.0 → 0.145.0

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.145.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",
@@ -64,7 +64,7 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.11",
-    "@nanobpm/urban-testkit": "^0.13.1",
+    "@nanobpm/urban-testkit": "^0.14.0",
     "@nanobpm/workflow": "^0.14.0",
     "@semantic-release/changelog": "^7.0.0",
     "@semantic-release/git": "^11.0.0",

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(

package/workers/record-plan/worker.ts

@@ -17,7 +17,6 @@
 // in that case (the edges were invalid).
 import type { AppJobHandler } from "@nanobpm/urban";
 import { type CapabilityNeed, parseCapabilityNeeds } from "../../app/capabilityNeed.ts";
-import { deriveEpicPhase } from "../../app/epicPhase.ts";
 import { plans, planTaskDeps, planTaskNeeds, planTasks } from "../../app/plan.ts";
 import { computeWaves, WaveError, type WaveTask } from "../../app/waves.ts";
 import type { WorkerInputs } from "../../nano-generated/worker-io.d.ts";
@@ -147,11 +146,6 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
     // denormalises it onto the `plans` row.
     updated_at: ts,
   };
-  // Domain-phase projection (#261): recording the plan hands the epic to the `review-plan` agent,
-  // so it enters the Reviewing phase (derived structurally from this worker's BPMN element id).
-  // Guard against a null derivation (element id absent) clobbering the genesis phase.
-  const epicPhase = deriveEpicPhase(job.elementId);
-  if (epicPhase) patch.epic_phase = epicPhase;
   if (tasks.length === 0) patch.outcome = note ? str(note) : "planner emitted no tasks";
   await plans(app.data).update(planKey, patch);
 

package/workers/record-results/worker.ts

@@ -13,7 +13,6 @@
 
 import type { AppJobHandler } from "@nanobpm/urban";
 import { BpmnError } from "@nanobpm/urban";
-import { deriveEpicPhase } from "../../app/epicPhase.ts";
 import { plans, planTasks } from "../../app/plan.ts";
 import type { WorkerInputs } from "../../nano-generated/worker-io.d.ts";
 
@@ -50,16 +49,16 @@ const handler: AppJobHandler<In> = async (job, app) => {
     throw new BpmnError("NO_WORK_DISPATCHED", `${planKey}: ${outcome}`);
   }
 
-  // Domain-phase projection (#261): the finalizer landed with opened PRs — the epic reaches its
-  // terminal "Fleet dispatched" phase (derived structurally from this worker's BPMN element id).
-  // The failed/no-work path above leaves epic_phase untouched: its terminal signal is status +
-  // outcome, and stamping "Dispatched" against a failed epic would misread. A null derivation
-  // (element id absent) must not clobber the last implementing phase.
-  const epicPhase = deriveEpicPhase(job.elementId);
+  // The epic's terminal "Fleet dispatched" phase is no longer stamped here (S8, #542). While this
+  // finalizer's token is ACTIVE the epic reads `Finalizing` from the live element-instance model
+  // (`pollEpicPhase` → `deriveEpicPhaseLive`); the terminal `Dispatched` is then derived from this
+  // `done` status by `pollEpicPhase` (`deriveTerminalEpicPhase`) — a completion marker with no live
+  // token to read, so it is taken from the durable terminal status, not a fleeting ACTIVE token. The
+  // failed/no-work path above likewise stamps no phase — its terminal signal is status + outcome, and
+  // a `failed` epic is deliberately never labelled Dispatched.
   await plans(app.data).update(planKey, {
     status: "done",
     outcome: `${opened} PR(s) dispatched to convergence`,
-    ...(epicPhase ? { epic_phase: epicPhase } : {}),
     updated_at: ts,
   });
 

package/workers/record-wave/worker.test.ts

@@ -145,8 +145,9 @@ test("record-wave retries the same wave when a task is still pending", async ()
   // Wave progress (current_wave/wave_label) was retired as a stored projection (epic #412) — derived
   // from `plan_tasks` by the plan_wave_label VIEW — so record-wave no longer writes it.
   assertEquals("current_wave" in (planUpdates[0].patch as Record<string, unknown>), false);
-  // Domain-phase projection (#261): more waves remain, so the epic stays Implementing (wave n/t).
-  assertEquals((planUpdates[0].patch as Record<string, unknown>).epic_phase, "Implementing (wave 2/2)");
+  // Domain-phase projection is no longer stamped by this worker (S8, #542) — the epic phase is a pure
+  // read-model derivation off the live element-instance model (`pollEpicPhase`, app/service.ts).
+  assertEquals("epic_phase" in (planUpdates[0].patch as Record<string, unknown>), false);
 });
 
 test("record-wave pins current_wave to the last index and clears gate_wave on the final wave", async () => {
@@ -178,9 +179,9 @@ test("record-wave pins current_wave to the last index and clears gate_wave on th
   assertEquals((planUpdates[0].patch as Record<string, unknown>).gate_wave, null);
   assertEquals("current_wave" in (planUpdates[0].patch as Record<string, unknown>), false);
   assertEquals("wave_label" in (planUpdates[0].patch as Record<string, unknown>), false);
-  // Domain-phase projection (#261): the final wave landed with no successor and no trial merge, so
-  // the epic enters Finalizing (record-results then advances to the Dispatched terminal).
-  assertEquals((planUpdates[0].patch as Record<string, unknown>).epic_phase, "Finalizing");
+  // Domain-phase projection is no longer stamped by this worker (S8, #542) — the epic phase is a pure
+  // read-model derivation off the live element-instance model (`pollEpicPhase`, app/service.ts).
+  assertEquals("epic_phase" in (planUpdates[0].patch as Record<string, unknown>), false);
 });
 
 test("record-wave writes no wave-progress columns for a taskless plan (waveCount 0)", async () => {