@nanobpm/nano-workforce 0.120.2 → 0.122.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [0.122.0](https://github.com/nanobpm/nano-workforce/compare/v0.121.0...v0.122.0) (2026-08-22)
+
+
+### Features
+
+* retire worker-maintained projection write-paths for SQL VIEWs ([#412](https://github.com/nanobpm/nano-workforce/issues/412)) ([#446](https://github.com/nanobpm/nano-workforce/issues/446)) ([d3ac2d9](https://github.com/nanobpm/nano-workforce/commit/d3ac2d91dee8180f83f22bdcb04a167e83b3bde5)), closes [436/#437](https://github.com/nanobpm/nano-workforce/issues/437) [#438](https://github.com/nanobpm/nano-workforce/issues/438) [#436](https://github.com/nanobpm/nano-workforce/issues/436) [#437](https://github.com/nanobpm/nano-workforce/issues/437)
+
+# [0.121.0](https://github.com/nanobpm/nano-workforce/compare/v0.120.2...v0.121.0) (2026-08-22)
+
+
+### Features
+
+* **delivery-graphs:** surface the compile preview in the console (compose → preview → dispatch) ([#445](https://github.com/nanobpm/nano-workforce/issues/445)) ([eb8bc7a](https://github.com/nanobpm/nano-workforce/commit/eb8bc7a609f894ddf83248bf356ab18864f63b62)), closes [#279](https://github.com/nanobpm/nano-workforce/issues/279) [#441](https://github.com/nanobpm/nano-workforce/issues/441)
+
 ## [0.120.2](https://github.com/nanobpm/nano-workforce/compare/v0.120.1...v0.120.2) (2026-08-22)
 
 

package/app/delivery.test.ts

@@ -1,16 +1,18 @@
 // Read-model derivation test for the epic delivery signal (issue #171). `deriveDelivery` is the
-// single source of truth for the denormalised `plans.delivery` / `plans.delivery_label` columns the
-// poller projects. It must cleanly distinguish an epic whose fan-out is `done` but whose slices are
-// still CONVERGING from one where every slice PR has LANDED, and count abandoned/converged PRs as
-// resolved-not-landed (never `landed`).
+// single source of truth the `plan_delivery` VIEW (061) encodes and the pollers derive at READ TIME
+// (epic #412 retired the stored `plans.delivery` / `plans.delivery_label` columns). It must cleanly
+// distinguish an epic whose fan-out is `done` but whose slices are still CONVERGING from one where
+// every slice PR has LANDED, and count abandoned/converged PRs as resolved-not-landed (never
+// `landed`). `pollPlanBucket` (app/service.ts) is the reader that applies the delivery-aware
+// `list_bucket`/`ack_open` correction from that signal.
 import { test } from "node:test";
 import { assert, assertEquals } from "#test-assert";
 import type { DataLayer } from "@nanobpm/urban";
 import { deriveDelivery, TERMINAL_STATUSES } from "./delivery.ts";
-import { pollDelivery } from "./service.ts";
+import { pollPlanBucket } from "./service.ts";
 
 // A tiny in-memory record gateway (all/find/update/insert), mirroring the fake-app style used
-// across the app tests (see app/taskDelta.test.ts), enough to exercise the `pollDelivery` projection.
+// across the app tests (see app/taskDelta.test.ts), enough to exercise the `pollPlanBucket` pass.
 function memData(): { data: DataLayer; stores: Record<string, any[]> } {
   const stores: Record<string, any[]> = {};
   function tbl(name: string, pk = "id") {
@@ -106,28 +108,32 @@ test("every non-terminal status counts as in flight", () => {
   }
 });
 
-test("pollDelivery: a dangling pr_key (missing PR row) counts as in-flight, never false-landed", async () => {
+test("pollPlanBucket: a still-converging done epic suppresses the Dismiss flag (ack_open=0) and stays Active", async () => {
   const { data, stores } = memData();
+  // A `done` epic the delivery-free gateway left as a Dismiss candidate (ack_open=1); pollPlanBucket
+  // derives `converging` at read time and clears it.
   stores.plans = [
-    { plan_key: "epic-1", status: "done", delivery: null, delivery_label: null },
+    { plan_key: "epic-1", status: "done", acknowledged_at: null, list_bucket: "active", ack_open: 1 },
   ];
   stores.plan_tasks = [
     { id: 1, plan_key: "epic-1", pr_key: "o/r#1" },
-    { id: 2, plan_key: "epic-1", pr_key: "o/r#2" }, // no matching pull_requests row (DB desync)
+    { id: 2, plan_key: "epic-1", pr_key: "o/r#2" },
+  ];
+  stores.pull_requests = [
+    { pr_key: "o/r#1", status: "merged" },
+    { pr_key: "o/r#2", status: "converging" },
   ];
-  stores.pull_requests = [{ pr_key: "o/r#1", status: "merged" }];
 
-  await pollDelivery(data);
+  await pollPlanBucket(data);
 
-  // Without the dangling PR being treated as in-flight, this would wrongly become `landed` (1/1).
-  assertEquals(stores.plans[0].delivery, "converging");
-  assertEquals(stores.plans[0].delivery_label, "1/2 slices merged, 1 converging");
+  assertEquals(stores.plans[0].list_bucket, "active");
+  assertEquals(stores.plans[0].ack_open, 0, "converging epic must not offer Dismiss");
 });
 
-test("pollDelivery: all slice PR rows present and merged -> landed", async () => {
+test("pollPlanBucket: a fully landed done epic opens the Dismiss flag (ack_open=1), still Active", async () => {
   const { data, stores } = memData();
   stores.plans = [
-    { plan_key: "epic-2", status: "done", delivery: null, delivery_label: null },
+    { plan_key: "epic-2", status: "done", acknowledged_at: null, list_bucket: "active", ack_open: 0 },
   ];
   stores.plan_tasks = [
     { id: 1, plan_key: "epic-2", pr_key: "o/r#10" },
@@ -138,38 +144,65 @@ test("pollDelivery: all slice PR rows present and merged -> landed", async () =>
     { pr_key: "o/r#11", status: "merged" },
   ];
 
-  await pollDelivery(data);
+  await pollPlanBucket(data);
+
+  assertEquals(stores.plans[0].list_bucket, "active");
+  assertEquals(stores.plans[0].ack_open, 1);
+});
+
+test("pollPlanBucket: a dangling pr_key keeps the epic converging (ack_open stays 0)", async () => {
+  const { data, stores } = memData();
+  stores.plans = [
+    { plan_key: "epic-3", status: "done", acknowledged_at: null, list_bucket: "active", ack_open: 1 },
+  ];
+  stores.plan_tasks = [
+    { id: 1, plan_key: "epic-3", pr_key: "o/r#1" },
+    { id: 2, plan_key: "epic-3", pr_key: "o/r#2" }, // no matching pull_requests row (DB desync)
+  ];
+  stores.pull_requests = [{ pr_key: "o/r#1", status: "merged" }];
+
+  await pollPlanBucket(data);
 
-  assertEquals(stores.plans[0].delivery, "landed");
-  assertEquals(stores.plans[0].delivery_label, "2/2 slices merged");
+  // Without the dangling PR counting as in-flight this would wrongly land → open Dismiss.
+  assertEquals(stores.plans[0].ack_open, 0);
 });
 
-test("pollDelivery: a non-done plan is skipped and any stale projection is cleared", async () => {
+test("pollPlanBucket: an acknowledged landed epic buckets to History", async () => {
   const { data, stores } = memData();
   stores.plans = [
-    // Regressed out of `done` while carrying a stale `converging` projection.
-    { plan_key: "epic-3", status: "in_progress", delivery: "converging", delivery_label: "1/2 slices merged, 1 converging" },
+    {
+      plan_key: "epic-4",
+      status: "done",
+      acknowledged_at: "2024-01-01T00:00:00Z",
+      list_bucket: "active",
+      ack_open: 1,
+    },
   ];
-  // A task join here would be wasted work for a non-done plan; assert it is never consulted.
-  let taskLookups = 0;
-  stores.plan_tasks = [{ id: 1, plan_key: "epic-3", pr_key: "o/r#20" }];
+  stores.plan_tasks = [{ id: 1, plan_key: "epic-4", pr_key: "o/r#20" }];
   stores.pull_requests = [{ pr_key: "o/r#20", status: "merged" }];
-  const origTable = (data as any).table.bind(data);
-  (data as any).table = (n: string, pk?: string) => {
-    const t = origTable(n, pk);
-    if (n === "plan_tasks") {
-      const origFind = t.find.bind(t);
-      t.find = async (where: any) => {
-        taskLookups++;
-        return origFind(where);
-      };
-    }
-    return t;
-  };
-
-  await pollDelivery(data);
-
-  assertEquals(stores.plans[0].delivery, null);
-  assertEquals(stores.plans[0].delivery_label, null);
-  assertEquals(taskLookups, 0);
+
+  await pollPlanBucket(data);
+
+  assertEquals(stores.plans[0].list_bucket, "history");
+  assertEquals(stores.plans[0].ack_open, 0);
+});
+
+test("pollPlanBucket: a steady-state pass rewrites nothing (idempotent)", async () => {
+  const { data, stores } = memData();
+  stores.plans = [
+    {
+      plan_key: "epic-5",
+      status: "done",
+      acknowledged_at: null,
+      list_bucket: "active",
+      ack_open: 1,
+      updated_at: "2020-01-01T00:00:00.000Z",
+    },
+  ];
+  stores.plan_tasks = [{ id: 1, plan_key: "epic-5", pr_key: "o/r#30" }];
+  stores.pull_requests = [{ pr_key: "o/r#30", status: "merged" }]; // landed → ack_open already 1
+
+  await pollPlanBucket(data);
+
+  assertEquals(stores.plans[0].updated_at, "2020-01-01T00:00:00.000Z", "no-op pass must not re-stamp");
 });

package/app/lineage.test.ts

@@ -207,20 +207,17 @@ test("pollLineage: projects feature, epic, and self-rooted threads onto lineage_
 
   const feat = threads.find((t) => t.root_request_key === "o/r#1");
   assert(feat, "feature thread present");
-  assertEquals(feat?.kind, "feature");
   assertEquals(feat?.stage, "converging");
   assertEquals(feat?.stage_label, "Converging (round 2)");
   assertEquals(feat?.active, 1);
   assertEquals(JSON.parse(feat?.pr_keys ?? "[]"), ["o/r#100"]);
 
   const epic = threads.find((t) => t.root_request_key === "o/r#2");
-  assertEquals(epic?.kind, "epic");
   assertEquals(epic?.stage, "converging");
   assertEquals(epic?.pr_count, 2);
   assertEquals(epic?.active, 1);
 
   const human = threads.find((t) => t.root_request_key === "o/r#300");
-  assertEquals(human?.kind, "pr");
   assertEquals(human?.stage, "merged");
   assertEquals(human?.active, 0);
 
@@ -257,7 +254,6 @@ test("pollLineage: a self-rooted PR row (root_request_key === pr_key) projects e
   const threads: LineageThreadRow[] = stores.lineage_threads;
   assertEquals(threads.length, 1, "one self-rooted thread");
   assertEquals(threads[0].root_request_key, "o/r#42", "thread key equals the PR row's root_request_key so the page join drills down");
-  assertEquals(threads[0].kind, "pr");
   assertEquals(JSON.parse(threads[0].pr_keys ?? "[]"), ["o/r#42"]);
   assertEquals(threads[0].pr_count, 1);
 });
@@ -286,7 +282,6 @@ test("pollLineage: an orphaned non-null root (origin row gone) keys the thread o
     "o/r#7",
     "thread key equals the stored root_request_key so the page join drills down, not the pr_key",
   );
-  assertEquals(threads[0].kind, "pr");
   assertEquals(JSON.parse(threads[0].pr_keys ?? "[]").sort(), ["o/r#71", "o/r#72"]);
   assertEquals(threads[0].pr_count, 2);
 });

package/app/lineage.ts

@@ -311,7 +311,10 @@ interface PrRow {
 
 const prRows = (data: DataLayer) => data.table<PrRow>("pull_requests", "pr_key");
 
-/** The denormalised read-table row `pollLineage` projects, one per root. */
+/** The `lineage_thread_view` VIEW row (migration 064) — the read shape the Lineage page binds. The
+ *  view PASSES THROUGH the procedural frontier columns from `lineage_threads` and DERIVES the
+ *  view-expressible identity columns (`kind`, `issue_url`, and an epic/feature thread's `title`) from
+ *  the `plans`/`feature_runs` origin joins. */
 export interface LineageThreadRow {
   root_request_key: string;
   kind: string;
@@ -327,8 +330,27 @@ export interface LineageThreadRow {
   updated_at: string;
 }
 
+/** The denormalised BASE `lineage_threads` row `pollLineage` writes. The `kind` / `issue_url` columns
+ *  were RETIRED (epic #412): the `lineage_thread_view` VIEW (064) DERIVES both from the
+ *  `plans`/`feature_runs` origin joins, so the poller no longer denormalises them — this write shape
+ *  is `LineageThreadRow` minus those two view-derived columns. `title` stays: it is a procedural
+ *  representative-PR pick for a self-rooted PR thread (the view falls back to `lt.title` for `kind`
+ *  = 'pr'). */
+interface LineageThreadWriteRow {
+  root_request_key: string;
+  title: string | null;
+  stage: string;
+  stage_label: string | null;
+  process_key: string | null;
+  pr_keys: string | null;
+  pr_count: number;
+  active: number;
+  created_at: string;
+  updated_at: string;
+}
+
 const lineageThreads = (data: DataLayer) =>
-  data.table<LineageThreadRow>("lineage_threads", "root_request_key");
+  data.table<LineageThreadWriteRow>("lineage_threads", "root_request_key");
 
 /** Read-only handle on the `lineage_thread_view` VIEW (migration 064) the Lineage page now binds.
  *  Same shape as `LineageThreadRow`: the view PASSES THROUGH the procedural frontier columns from
@@ -537,9 +559,7 @@ export async function pollLineage(data: DataLayer): Promise<void> {
       const existing = await table.get(thread.rootRequestKey);
       if (
         existing &&
-        existing.kind === thread.kind &&
         existing.title === thread.title &&
-        existing.issue_url === thread.issueUrl &&
         existing.stage === thread.stage &&
         existing.stage_label === thread.stageLabel &&
         existing.process_key === thread.processKey &&
@@ -552,9 +572,7 @@ export async function pollLineage(data: DataLayer): Promise<void> {
       const ts = now();
       if (existing) {
         await table.update(thread.rootRequestKey, {
-          kind: thread.kind,
           title: thread.title,
-          issue_url: thread.issueUrl,
           stage: thread.stage,
           stage_label: thread.stageLabel,
           process_key: thread.processKey,
@@ -566,9 +584,7 @@ export async function pollLineage(data: DataLayer): Promise<void> {
       } else {
         await table.insert({
           root_request_key: thread.rootRequestKey,
-          kind: thread.kind,
           title: thread.title,
-          issue_url: thread.issueUrl,
           stage: thread.stage,
           stage_label: thread.stageLabel,
           process_key: thread.processKey,

package/app/mergesPerDay.test.ts

@@ -1,16 +1,14 @@
-// Read-model derivation + projection test for the merged-per-day throughput chart (issue #344).
+// Read-model derivation test for the merged-per-day throughput chart (issue #344).
 //
-// `deriveMergesPerDay` is the single source of truth behind the denormalised `merges_per_day` table
-// the Velocity page reads. It must: count DISTINCT PRs per calendar day (a PR with several `merged`
-// audit rows on one day — an `already-merged` short-circuit or a retry — counts once); ignore
-// `queued`/`blocked` attempts entirely; order days ascending; carry a running burn-up `cumulative`;
-// and scale each day's `bar` against the busiest day. `pollMergesPerDay` must project that onto the
-// read table idempotently — a steady-state re-run writes nothing, and a day dropped from the audit is
-// pruned.
+// `deriveMergesPerDay` is the single source of truth the `merges_per_day_view` VIEW (062) mirrors —
+// the worker-maintained `merges_per_day` table + its `pollMergesPerDay` write-path were RETIRED (epic
+// #412). It must: count DISTINCT PRs per calendar day (a PR with several `merged` audit rows on one
+// day — an `already-merged` short-circuit or a retry — counts once); ignore `queued`/`blocked`
+// attempts entirely; order days ascending; carry a running burn-up `cumulative`; and scale each day's
+// `bar` against the busiest day.
 import { test } from "node:test";
 import { assert, assertEquals } from "#test-assert";
-import type { DataLayer } from "@nanobpm/urban";
-import { deriveMergesPerDay, type MergeAuditRow, pollMergesPerDay } from "./mergesPerDay.ts";
+import { deriveMergesPerDay, type MergeAuditRow } from "./mergesPerDay.ts";
 
 // The bucketing is now LOCAL-calendar-day (issue #361: use the viewer's timezone, not UTC). The
 // derivation buckets in an explicit IANA `timeZone` argument (via `Intl.DateTimeFormat`), so these
@@ -19,49 +17,6 @@ import { deriveMergesPerDay, type MergeAuditRow, pollMergesPerDay } from "./merg
 // reorder unrelated date-handling tests. The UTC-based assertions pass `"UTC"`; the
 // timezone-specific ones pass the zone they exercise.
 
-// A tiny in-memory record gateway (all/find/insert/update/delete), mirroring the fake-app style used
-// across the app tests (see app/delivery.test.ts), enough to exercise the `pollMergesPerDay`
-// projection.
-function memData(): { data: DataLayer; stores: Record<string, any[]>; writes: () => number } {
-  const stores: Record<string, any[]> = {};
-  let writes = 0;
-  function tbl(name: string, pk = "id") {
-    const rows = (stores[name] ??= [] as any[]);
-    return {
-      async all() {
-        return rows.slice();
-      },
-      async get(id: any) {
-        return rows.find((r) => r[pk] === id);
-      },
-      async find(where: any = {}) {
-        return rows.filter((r) => Object.entries(where).every(([k, v]) => r[k] === v));
-      },
-      async insert(row: any) {
-        writes++;
-        rows.push({ ...row });
-        return row[pk];
-      },
-      async update(id: any, patch: any) {
-        writes++;
-        const r = rows.find((row) => row[pk] === id);
-        if (r) Object.assign(r, patch);
-        return 1;
-      },
-      async delete(id: any) {
-        const i = rows.findIndex((row) => row[pk] === id);
-        if (i >= 0) {
-          writes++;
-          rows.splice(i, 1);
-        }
-        return 1;
-      },
-    };
-  }
-  const data = { table: (n: string, pk?: string) => tbl(n, pk) } as any as DataLayer;
-  return { data, stores, writes: () => writes };
-}
-
 const merged = (pr_key: string, at: string): MergeAuditRow => ({ pr_key, outcome: "merged", at });
 
 test("counts DISTINCT merged PRs per calendar day", () => {
@@ -216,42 +171,3 @@ test("an invalid IANA timeZone falls back to the host zone instead of throwing (
   assertEquals(days[0].merged, 1);
   assert(/^\d{4}-\d{2}-\d{2}$/.test(days[0].day));
 });
-
-test("pollMergesPerDay projects the aggregate onto merges_per_day", async () => {
-  const { data, stores } = memData();
-  stores.merges = [
-    { id: 1, pr_key: "o/r#1", outcome: "merged", at: "2026-01-01T09:00:00Z" },
-    { id: 2, pr_key: "o/r#1", outcome: "merged", at: "2026-01-01T09:05:00Z" }, // dup same day
-    { id: 3, pr_key: "o/r#2", outcome: "merged", at: "2026-01-02T09:00:00Z" },
-    { id: 4, pr_key: "o/r#3", outcome: "queued", at: "2026-01-02T09:10:00Z" }, // ignored
-  ];
-  await pollMergesPerDay(data, "UTC");
-  const rows = (stores.merges_per_day ?? []).slice().sort((x, y) => x.day.localeCompare(y.day));
-  assertEquals(rows.map((r) => [r.day, r.merged, r.cumulative]), [
-    ["2026-01-01", 1, 1],
-    ["2026-01-02", 1, 2],
-  ]);
-  for (const r of rows) assert(typeof r.updated_at === "string" && r.updated_at.length > 0);
-});
-
-test("pollMergesPerDay is idempotent — a steady-state re-run writes nothing", async () => {
-  const { data, stores, writes } = memData();
-  stores.merges = [{ id: 1, pr_key: "o/r#1", outcome: "merged", at: "2026-01-01T09:00:00Z" }];
-  await pollMergesPerDay(data, "UTC");
-  const afterFirst = writes();
-  assert(afterFirst > 0, "the first pass must project at least one row");
-  await pollMergesPerDay(data, "UTC");
-  assertEquals(writes(), afterFirst, "a steady-state re-run must not write");
-});
-
-test("pollMergesPerDay prunes a day that no longer derives from the audit", async () => {
-  const { data, stores } = memData();
-  stores.merges_per_day = [
-    { day: "2025-12-31", merged: 3, cumulative: 3, bar: "███", updated_at: "old" },
-  ];
-  stores.merges = [{ id: 1, pr_key: "o/r#1", outcome: "merged", at: "2026-01-01T09:00:00Z" }];
-  await pollMergesPerDay(data, "UTC");
-  const days = (stores.merges_per_day ?? []).map((r: any) => r.day);
-  assert(!days.includes("2025-12-31"), "a stale day must be pruned");
-  assert(days.includes("2026-01-01"), "the derived day must be present");
-});

package/app/mergesPerDay.ts

@@ -14,23 +14,18 @@
 //   SELECT date(at, 'localtime') AS day, COUNT(DISTINCT pr_key) AS merged
 //   FROM merges WHERE outcome = 'merged' GROUP BY date(at, 'localtime');
 //
-// Two halves, mirroring the `deriveDelivery`/`pollDelivery` and `deriveLineage`/`pollLineage`
-// convention:
+// The `deriveMergesPerDay` PURE function (issue #344), formerly the derive-half of the
+// `deriveMergesPerDay`/`pollMergesPerDay` split. The merges-per-day read model is now a DERIVED SQL
+// VIEW (`merges_per_day_view`, 062) — the worker-maintained `merges_per_day` table and its
+// `pollMergesPerDay` write-path were RETIRED (epic #412). This pure derivation stays: it is the
+// single source of truth the view's SQL mirrors, and is still exercised by its unit tests +
+// the view's read-model guard.
 //   • `deriveMergesPerDay` — a PURE function: merge audit rows → one ordered `MergeDay` per calendar
 //     day (merged count, burn-up cumulative, a proportional bar string). No I/O, fully tested. Counts
 //     `COUNT(DISTINCT pr_key)` — a PR with several `merged` rows on one day (an `already-merged`
 //     short-circuit or retry) counts once — and ignores `queued`/`blocked` rows entirely.
-//   • `pollMergesPerDay` — the gateway glue: read the `merges` rows and project them onto the
-//     `merges_per_day` read table (051_merges_per_day.sql) the schema-driven Velocity page binds. A
-//     denormalised flat table because Urban's datasource cannot read a SQL VIEW (gateway.ts
-//     `schema()` whitelists `type='table'` only — same reason `lineage_threads`/`plans.delivery` are
-//     flat tables). Writes only when a day's projection actually changes, so a steady-state pass is a
-//     no-op.
-import type { DataLayer } from "@nanobpm/urban";
 
-const now = () => new Date().toISOString();
-
-/** The subset of a `merges` audit row (004_merge.sql) the projection reads. */
+/** The subset of a `merges` audit row (004_merge.sql) the derivation reads. */
 export interface MergeAuditRow {
   pr_key: string;
   outcome: string;
@@ -166,51 +161,3 @@ export function deriveMergesPerDay(rows: readonly MergeAuditRow[], timeZone?: st
   }
   return out;
 }
-
-/** The denormalised read-table row `pollMergesPerDay` projects, one per calendar day. */
-interface MergesPerDayRow extends MergeDay {
-  updated_at: string;
-}
-
-const mergesPerDay = (data: DataLayer) => data.table<MergesPerDayRow>("merges_per_day", "day");
-const mergesAudit = (data: DataLayer) => data.table<MergeAuditRow>("merges", "id");
-
-/** Idempotent read-model pass: recompute merged-per-day from the `merges` audit table and denormalise
- * it onto the `merges_per_day` read table the Velocity page reads. Additive/derived only — never
- * touches `merges`. Upserts a day only when its projection actually changes (so a steady-state pass is
- * a no-op) and prunes any stale day row that no longer derives (defensive — days are append-only in
- * practice, but a purge/rewrite of the audit must not leave a phantom). Buckets in `timeZone` (an
- * IANA zone) when given; the production caller omits it to use the host's resolved zone. */
-export async function pollMergesPerDay(data: DataLayer, timeZone?: string): Promise<void> {
-  try {
-    // Only `outcome === "merged"` rows contribute to the aggregate, so filter at the read rather than
-    // scanning queued/blocked rows as the audit grows (deriveMergesPerDay ignores non-merged rows too).
-    const audit = await mergesAudit(data).find({ outcome: "merged" });
-    const want = deriveMergesPerDay(audit, timeZone);
-    const wantByDay = new Map(want.map((d) => [d.day, d]));
-
-    const existing = await mergesPerDay(data).all();
-    const existingByDay = new Map(existing.map((r) => [r.day, r]));
-
-    for (const d of want) {
-      const cur = existingByDay.get(d.day);
-      if (!cur) {
-        await mergesPerDay(data).insert({ ...d, updated_at: now() });
-      } else if (cur.merged !== d.merged || cur.cumulative !== d.cumulative || cur.bar !== d.bar) {
-        await mergesPerDay(data).update(d.day, {
-          merged: d.merged,
-          cumulative: d.cumulative,
-          bar: d.bar,
-          updated_at: now(),
-        });
-      }
-    }
-
-    // Prune any projected day that no longer derives from the audit trail.
-    for (const r of existing) {
-      if (!wantByDay.has(r.day)) await mergesPerDay(data).delete(r.day);
-    }
-  } catch (err) {
-    console.error(`[poller] merges-per-day: ${err}`);
-  }
-}

package/app/plan.ts

@@ -74,18 +74,11 @@ export interface Plan {
   // Wave-merge barrier (007_wave_gate.sql): the wave index whose PRs the plan is currently
   // waiting to see MERGED before dispatching the next wave, or null when not parked at the barrier.
   gate_wave: number | null;
-  // Operator-visibility wave progress (022_plan_wave_progress.sql, #137): denormalised so the
-  // epics-index can show wave X/N at a glance. `wave_count` is the total waves (N); `current_wave`
-  // is the 0-based index of the wave the fleet is actively implementing (advanced by select-wave,
-  // pinned to wave_count-1 on completion). Display-only — never gates control flow. NULL until the
-  // plan is dispatched with tasks.
-  wave_count: number | null;
-  current_wave: number | null;
-  // Pre-formatted 1-based "X/N" progress string for the epics-index at-a-glance column
-  // (022_plan_wave_progress.sql, #137). The dataGrid has no per-cell templating (nano-ide#214),
-  // so this is projected alongside the numeric columns by the same worker writes. NULL until
-  // dispatched with tasks.
-  wave_label: string | null;
+  // Operator-visibility wave progress is now a DERIVED read model (epic #412): the `wave_count` /
+  // `current_wave` / `wave_label` columns (022_plan_wave_progress.sql) were RETIRED — the pages read
+  // them from the `plan_wave_label` / `plan_read_model` SQL VIEWs (060/061), and `pollWaitGate`
+  // derives "has the epic fanned out?" at read time from `plan_tasks`. There is no write-path and no
+  // stored column any more, so nothing on `plans` denormalises wave progress.
   // Per-plan capability token for the coordination blackboard (009_plan_blackboard.sql, #51).
   // Minted at plan start; baked into the blackboard URL handed to implementer agents. NULL for
   // plans created before the blackboard shipped.
@@ -96,13 +89,12 @@ export interface Plan {
   // admission); the column stays NULLABLE ONLY to grandfather pre-ADR-0003 / in-flight rows that
   // carry NULL — those must remain readable, so do NOT add a NOT NULL migration.
   base_branch: string | null;
-  // Derived epic delivery signal (029_plan_delivery.sql, #171): separates "fan-out dispatched to
-  // convergence" (status=done) from "all slice PRs actually merged". Recomputed idempotently by the
-  // poller's `pollDelivery` pass by joining each plan_tasks.pr_key → pull_requests.status — never
-  // written by the plan lifecycle. `delivery` is 'converging' | 'landed' | NULL (see deriveDelivery
-  // in app/service.ts); `delivery_label` is the human rollup for the epic detail view. Display-only.
-  delivery: string | null;
-  delivery_label: string | null;
+  // The derived epic delivery signal (029_plan_delivery.sql) was RETIRED as a stored column (epic
+  // #412): `delivery` / `delivery_label` are now a DERIVED SQL VIEW (`plan_delivery` /
+  // `plan_read_model`, 061), computed from the SAME pure `deriveDelivery`/`TERMINAL_STATUSES`
+  // (app/delivery.ts). The pages read them off the view; the pollers that still need the signal
+  // (`pollPlanBucket` for list_bucket/ack_open, `pollPromotion` for `isPromotable`) recompute it at
+  // read time via `deriveDelivery`. There is no stored column and no write-path any more.
   // Derived epic domain phase (038_plan_epic_phase.sql, #261): the epic's own lifecycle phase —
   // Planning / Reviewing / Implementing (wave n/t) / Trial merging / Finalizing / Dispatched —
   // projected at write time from plan-fanout.bpmn's named activities (app/epicPhase.ts), so the epic
@@ -199,12 +191,12 @@ export const plans = (data: DataLayer) => {
       }
       if (prop === "update") {
         return async (id: unknown, patch: Partial<Plan>) => {
-          // Only re-read + reproject when the patch changes a projection input (status / delivery /
+          // Only re-read + reproject when the patch changes a projection input (status /
           // acknowledged_at) or writes a derived column directly. A projection-irrelevant patch (e.g.
-          // an `updated_at`- or `wave_label`-only write — including the direct `data.table` writes in
+          // an `updated_at`-only write — including the direct `data.table` writes in
           // e.g. `app/retro.ts` that stamp `retro_started_at`) leaves the stored projection correct, so
           // skip the extra `get` roundtrip and delegate straight. Any bucket-relevant write
-          // (status/delivery/acknowledged_at or a derived column) MUST go through this gateway to stay
+          // (status/acknowledged_at or a derived column) MUST go through this gateway to stay
           // reprojected.
           if (!patchAffectsPlanProjection(patch)) return target.update(id, patch);
           const existing = await target.get(id);
@@ -223,7 +215,7 @@ export const plans = (data: DataLayer) => {
 /** The `plans` fields the bucket projection READS: a patch touching none of these (and none it
  * writes) cannot change `list_bucket`/`ack_open`, so the gateway skips the read-back+reproject. Kept
  * adjacent to {@link projectPlanBucket} so the two stay in lockstep. */
-const PLAN_PROJECTION_INPUT_KEYS: readonly (keyof Plan)[] = ["status", "delivery", "acknowledged_at"];
+const PLAN_PROJECTION_INPUT_KEYS: readonly (keyof Plan)[] = ["status", "acknowledged_at"];
 
 /** The `plans` fields the bucket projection WRITES. Included in the reproject trigger so a caller who
  * writes a derived column directly (e.g. `list_bucket`/`ack_open`) can never bypass derivation: the
@@ -241,15 +233,21 @@ function patchAffectsPlanProjection(patch: Partial<Plan>): boolean {
 
 /** Compute the write-time bucket projection columns for a merged `plans` row. Centralised so the
  * gateway is the ONE place `deriveEpicBucket` / `epicIsAcknowledgeable` are applied — the page, SQL,
- * pollers and workers never re-derive the mapping (AGENTS.md "derivation over duplication"). */
+ * pollers and workers never re-derive the mapping (AGENTS.md "derivation over duplication").
+ *
+ * The `delivery` signal was retired as a stored column (epic #412), so the write-time projection can
+ * no longer read it — it derives the bucket with `delivery` treated as UNKNOWN (null). This is
+ * provably safe for `list_bucket`: `deriveEpicBucket` returns the same bucket with `delivery=null` as
+ * with the real signal for every reachable `(status, acknowledged_at)` state. `ack_open` is only a
+ * *candidate* here (any unacknowledged `done` epic); the delivery-aware correction — clearing it
+ * while an epic is still `converging` — is applied at read time by `pollPlanBucket` (app/service.ts),
+ * which recomputes `delivery` via `deriveDelivery`. */
 function projectPlanBucket(row: Partial<Plan>): Partial<Plan> {
   if (!row.status) return {};
   return {
-    list_bucket: deriveEpicBucket(row.status, row.delivery ?? null, row.acknowledged_at ?? null),
+    list_bucket: deriveEpicBucket(row.status, null, row.acknowledged_at ?? null),
     ack_open:
-      epicIsAcknowledgeable(row.status, row.delivery ?? null) && (row.acknowledged_at ?? null) === null
-        ? 1
-        : 0,
+      epicIsAcknowledgeable(row.status, null) && (row.acknowledged_at ?? null) === null ? 1 : 0,
   };
 }