@nanobpm/nano-workforce 0.121.0 → 0.123.0

package/operations/acknowledgeEpic.test.ts

@@ -1,20 +1,32 @@
 // Tests for the POST /app/api/actions/acknowledge-epic operation `acknowledgeEpic` (issue #298).
-// The nwf UI's "Dismiss" affordance for a RESOLVED epic — landed (`delivery=landed`) or
-// resolved-not-landed (`delivery=null`); only still-`converging` epics are rejected. It stamps
-// `acknowledged_at` via the plans gateway, which recomputes `list_bucket` to 'history' (and
-// `ack_open` to 0), dropping the resolved epic from Active into History. Unlike acknowledge-blocked
-// it completes NO user task (a resolved epic is not parked). The epic twin of acknowledge-done.
+// The nwf UI's "Dismiss" affordance for a RESOLVED epic — landed (delivery=landed) or
+// resolved-not-landed (delivery=null); only still-`converging` epics are rejected. It stamps
+// `acknowledged_at`, which the `plan_read_model` VIEW (074, issue #439) derives into `list_bucket` =
+// 'history' and `ack_open` = 0, dropping the resolved epic from Active into History. Unlike
+// acknowledge-blocked it completes NO user task (a resolved epic is not parked). The epic twin of
+// acknowledge-done.
+//
+// Since epic #412 retired the stored `plans.delivery` column, the op derives the delivery signal at
+// READ TIME (`derivePlanDelivery` → the pure `deriveDelivery`) by joining the epic's slice
+// `plan_tasks.pr_key` → `pull_requests.status`. So these tests seed `plan_tasks` + `pull_requests`
+// (not a `plans.delivery` column) to model a landed / converging / resolved-not-landed epic. Because
+// `list_bucket`/`ack_open` are now a VIEW (no stored column), the tests assert the operation's real
+// write — the `acknowledged_at` stamp and the 200/409 gate — and cross-check the resulting bucket
+// through the pure `deriveEpicBucket` / `epicIsAcknowledgeable` oracles the VIEW mirrors.
 import { test } from "node:test";
 import { assertEquals } from "#test-assert";
 import type { AppApi } from "@nanobpm/urban";
-import { plans } from "../app/plan.ts";
+import { deriveEpicBucket, epicIsAcknowledgeable } from "../app/delivery.ts";
 import { noopLog } from "../test/log.ts";
 import handler from "./acknowledgeEpic.ts";
 
-// An in-memory data layer wired through the REAL plans gateway proxy, so the test exercises the
-// gateway's list_bucket/ack_open projection exactly as production does.
-function memApp(seed: any[]): { app: AppApi; rows: any[] } {
-  const stores: Record<string, any[]> = { plans: seed };
+// An in-memory data layer wired through the `plans` gateway (now a plain record table). `extra` seeds
+// the join surfaces (`plan_tasks` / `pull_requests`) the read-time delivery derivation reads.
+function memApp(
+  seed: any[],
+  extra: Record<string, any[]> = {},
+): { app: AppApi; rows: any[] } {
+  const stores: Record<string, any[]> = { plans: seed, ...extra };
   function tbl(name: string, pk = "id") {
     const rows = (stores[name] ??= [] as any[]);
     const match = (r: any, where: any) => Object.entries(where).every(([k, v]) => r[k] === v);
@@ -50,53 +62,78 @@ async function call(app: AppApi, body: unknown) {
   return (await handler({ req: {} as any, params: {}, query: {}, body } as any, app)) as any;
 }
 
-test("acknowledge-epic: stamps acknowledged_at and flips list_bucket to 'history' on a landed epic", async () => {
-  const { app, rows } = memApp([{ plan_key: "o/r#1", status: "done", delivery: "landed", acknowledged_at: null }]);
-  // Seed the projection as the gateway would have on the last write (landed, unacknowledged → active).
-  await plans(app.data).update("o/r#1", { delivery: "landed" });
-  assertEquals(rows[0].list_bucket, "active");
-  assertEquals(rows[0].ack_open, 1);
+test("acknowledge-epic: stamps acknowledged_at and (via the VIEW) buckets a landed epic into History", async () => {
+  const { app, rows } = memApp(
+    [{ plan_key: "o/r#1", status: "done", acknowledged_at: null }],
+    {
+      plan_tasks: [{ id: 1, plan_key: "o/r#1", pr_key: "o/r#100" }],
+      pull_requests: [{ pr_key: "o/r#100", status: "merged" }], // landed
+    },
+  );
+  // Before dismissal a landed-but-unacknowledged epic reads as Active with Dismiss open through the VIEW.
+  assertEquals(deriveEpicBucket("done", "landed", rows[0].acknowledged_at), "active");
+  assertEquals(epicIsAcknowledgeable("done", "landed"), true);
 
   const res = await call(app, { plan_key: "o/r#1" });
 
   assertEquals(res.status, 200);
   assertEquals(res.body.ok, true);
   assertEquals(typeof rows[0].acknowledged_at, "string");
-  assertEquals(rows[0].list_bucket, "history");
-  assertEquals(rows[0].ack_open, 0);
+  // The op's only write is the stamp; the VIEW derives 'history' + ack_open 0 from the acknowledged row.
+  assertEquals(deriveEpicBucket("done", "landed", rows[0].acknowledged_at), "history");
 });
 
 test("acknowledge-epic: a still-converging epic is rejected (409) and stays Active", async () => {
-  const { app, rows } = memApp([{ plan_key: "o/r#2", status: "done", delivery: "converging", acknowledged_at: null }]);
-  await plans(app.data).update("o/r#2", { delivery: "converging" });
+  const { app, rows } = memApp(
+    [{ plan_key: "o/r#2", status: "done", acknowledged_at: null }],
+    {
+      plan_tasks: [
+        { id: 1, plan_key: "o/r#2", pr_key: "o/r#200" },
+        { id: 2, plan_key: "o/r#2", pr_key: "o/r#201" },
+      ],
+      pull_requests: [
+        { pr_key: "o/r#200", status: "merged" },
+        { pr_key: "o/r#201", status: "converging" }, // still in flight → converging
+      ],
+    },
+  );
 
   const res = await call(app, { plan_key: "o/r#2" });
 
   assertEquals(res.status, 409);
   assertEquals(res.body.ok, false);
-  // Untouched: no premature acknowledged_at, still Active.
+  // Untouched: no premature acknowledged_at; still Active through the VIEW (converging → active).
   assertEquals(rows[0].acknowledged_at, null);
-  assertEquals(rows[0].list_bucket, "active");
+  assertEquals(deriveEpicBucket("done", "converging", rows[0].acknowledged_at), "active");
 });
 
 test("acknowledge-epic: a resolved-not-landed epic (delivery=null) is accepted (200) and flips to History", async () => {
-  const { app, rows } = memApp([{ plan_key: "o/r#2b", status: "done", delivery: null, acknowledged_at: null }]);
-  // Seed the projection as the gateway would have on the last write (resolved-not-landed, unacknowledged → active).
-  await plans(app.data).update("o/r#2b", { delivery: null });
-  assertEquals(rows[0].list_bucket, "active");
-  assertEquals(rows[0].ack_open, 1);
+  const { app, rows } = memApp(
+    [{ plan_key: "o/r#2b", status: "done", acknowledged_at: null }],
+    {
+      plan_tasks: [
+        { id: 1, plan_key: "o/r#2b", pr_key: "o/r#210" },
+        { id: 2, plan_key: "o/r#2b", pr_key: "o/r#211" },
+      ],
+      pull_requests: [
+        { pr_key: "o/r#210", status: "merged" },
+        { pr_key: "o/r#211", status: "abandoned" }, // all terminal, not all merged → delivery null
+      ],
+    },
+  );
+  assertEquals(deriveEpicBucket("done", null, rows[0].acknowledged_at), "active");
+  assertEquals(epicIsAcknowledgeable("done", null), true);
 
   const res = await call(app, { plan_key: "o/r#2b" });
 
   assertEquals(res.status, 200);
   assertEquals(res.body.ok, true);
   assertEquals(typeof rows[0].acknowledged_at, "string");
-  assertEquals(rows[0].list_bucket, "history");
-  assertEquals(rows[0].ack_open, 0);
+  assertEquals(deriveEpicBucket("done", null, rows[0].acknowledged_at), "history");
 });
 
 test("acknowledge-epic: a live (dispatched) epic is rejected (409)", async () => {
-  const { app } = memApp([{ plan_key: "o/r#3", status: "dispatched", delivery: null, acknowledged_at: null }]);
+  const { app } = memApp([{ plan_key: "o/r#3", status: "dispatched", acknowledged_at: null }]);
   const res = await call(app, { plan_key: "o/r#3" });
   assertEquals(res.status, 409);
 });
@@ -114,16 +151,21 @@ test("acknowledge-epic: no matching epic → 404", async () => {
 });
 
 test("acknowledge-epic: idempotent — re-acknowledging a landed epic keeps it in History", async () => {
-  const { app, rows } = memApp([{ plan_key: "o/r#5", status: "done", delivery: "landed", acknowledged_at: null }]);
-  await plans(app.data).update("o/r#5", { delivery: "landed" });
+  const { app, rows } = memApp(
+    [{ plan_key: "o/r#5", status: "done", acknowledged_at: null }],
+    {
+      plan_tasks: [{ id: 1, plan_key: "o/r#5", pr_key: "o/r#500" }],
+      pull_requests: [{ pr_key: "o/r#500", status: "merged" }], // landed
+    },
+  );
 
   assertEquals((await call(app, { plan_key: "o/r#5" })).status, 200);
   const firstStamp = rows[0].acknowledged_at;
-  assertEquals(rows[0].list_bucket, "history");
+  assertEquals(deriveEpicBucket("done", "landed", rows[0].acknowledged_at), "history");
 
   const res2 = await call(app, { plan_key: "o/r#5" });
   assertEquals(res2.status, 200);
-  assertEquals(rows[0].list_bucket, "history");
+  assertEquals(deriveEpicBucket("done", "landed", rows[0].acknowledged_at), "history");
   // Re-stamped (a fresh timestamp) but still resolved.
   assertEquals(typeof rows[0].acknowledged_at, "string");
   void firstStamp;

package/operations/acknowledgeEpic.ts

@@ -4,12 +4,13 @@
 // resolved-not-landed) directly from the Epic / Overview pages so it drops out of the Active epic list
 // into History. It is the epic twin of `acknowledgeDone` (the feature-run tick-off) — a resolved epic
 // is NOT parked at a user task, so this op completes no user task and touches no engine/ledger: it
-// simply stamps `acknowledged_at` on the `plans` row via the plans gateway.
+// simply stamps `acknowledged_at` on the `plans` row.
 //
-// The gateway (app/plan.ts) recomputes `list_bucket`/`ack_open` on that write — a landed, now-
-// acknowledged epic flips `list_bucket` to 'history' and `ack_open` to 0 — so this op NEVER hand-sets
-// a derived projection. Keyed on the row's `plan_key`. Idempotent-safe: re-acknowledging re-stamps
-// the timestamp and keeps the row in History.
+// `list_bucket`/`ack_open` are DERIVED by the `plan_read_model` VIEW (074, issue #439) from
+// `status` + `acknowledged_at` + the derived `plan_delivery` signal — a landed, now-acknowledged epic
+// reads `list_bucket` = 'history' and `ack_open` = 0 — so this op NEVER writes a derived projection.
+// Keyed on the row's `plan_key`. Idempotent-safe: re-acknowledging re-stamps the timestamp and keeps
+// the row in History.
 //
 // It rejects (409) an epic that is NOT yet resolved — i.e. anything the `epicIsAcknowledgeable`
 // guard refuses: a non-`done` status (`planning`/`dispatched`), or `done` but still `converging`. A
@@ -19,6 +20,7 @@
 
 import { epicIsAcknowledgeable } from "../app/delivery.ts";
 import { plans } from "../app/plan.ts";
+import { derivePlanDelivery } from "../app/service.ts";
 import { defineOperation } from "../nano-generated/operations.ts";
 
 const str = (v: unknown): string => (typeof v === "string" ? v.trim() : "");
@@ -43,18 +45,21 @@ export default defineOperation("acknowledgeEpic", async ({ body }, app) => {
   // affordance. Acknowledging a live/converging epic would pre-seed `acknowledged_at`, so the moment
   // it later resolved `deriveEpicBucket` would drop it straight into History, skipping the operator
   // tick-off this op exists to require — and a converging epic must stay visible while its slices land.
-  if (!epicIsAcknowledgeable(plan.status, plan.delivery ?? null)) {
+  // The `plans.delivery` column was retired (epic #412), so derive the signal at read time from the
+  // slice PRs (the same pure `deriveDelivery` the `plan_delivery` VIEW encodes).
+  const delivery = await derivePlanDelivery(app.data, plan);
+  if (!epicIsAcknowledgeable(plan.status, delivery)) {
     app.log.warn("acknowledge-epic rejected: epic is not resolved", {
       planKey,
       status: plan.status,
-      delivery: plan.delivery ?? null,
+      delivery,
     });
     return { status: 409, body: { ok: false, error: "epic is not resolved" } };
   }
 
-  // Stamp the dismissal. The gateway recomputes `list_bucket` (→ 'history') and `ack_open` (→ 0) from
-  // the merged row, so we never hand-set them here. Idempotent: re-acknowledging re-stamps and stays
-  // in History.
+  // Stamp the dismissal. `list_bucket` (→ 'history') and `ack_open` (→ 0) are derived by the
+  // `plan_read_model` VIEW from the resolved, now-acknowledged row, so we never hand-set them here.
+  // Idempotent: re-acknowledging re-stamps and stays in History.
   const now = new Date().toISOString();
   await table.update(planKey, { acknowledged_at: now, updated_at: now });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.121.0",
+  "version": "0.123.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/epic.page.json

@@ -99,7 +99,7 @@
         "data": {
           "kind": "datasource",
           "source": "app",
-          "table": "plans",
+          "table": "plan_read_model",
           "orderBy": { "field": "updated_at", "dir": "desc" },
           "filter": [{ "field": "list_bucket", "in": ["active"] }]
         },

package/pages/feature.page.json

@@ -102,7 +102,7 @@
         "data": {
           "kind": "datasource",
           "source": "app",
-          "table": "feature_runs",
+          "table": "feature_read_model",
           "orderBy": { "field": "updated_at", "dir": "desc" },
           "filter": [{ "field": "list_bucket", "in": ["active"] }]
         },

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

@@ -59,7 +59,7 @@ function fakeApp() {
   return { app, plans, planTasks, planTaskNeeds };
 }
 
-test("record-plan initializes wave progress fields for a taskful plan", async () => {
+test("record-plan dispatches a taskful plan and levelizes its tasks (wave progress is now VIEW-derived)", async () => {
   const { app, plans } = fakeApp();
   await handler(
     {
@@ -74,22 +74,24 @@ test("record-plan initializes wave progress fields for a taskful plan", async ()
     app,
   );
   assertEquals(plans[0].status, "dispatched");
-  assertEquals(plans[0].wave_count, 2);
-  assertEquals(plans[0].current_wave, 0);
-  assertEquals(plans[0].wave_label, "1/2");
+  // Wave progress (wave_count/current_wave/wave_label) was retired as a stored projection (epic
+  // #412) — it is derived from `plan_tasks` by the plan_wave_label/plan_read_model VIEWs — so
+  // record-plan no longer writes it onto the plans row.
+  assertEquals(plans[0].wave_count, undefined);
+  assertEquals(plans[0].current_wave, undefined);
+  assertEquals(plans[0].wave_label, undefined);
 });
 
-test("record-plan leaves all three wave progress fields NULL for a taskless plan", async () => {
+test("record-plan marks a taskless plan done (no wave-progress columns written)", async () => {
   const { app, plans } = fakeApp();
   await handler(
     { variables: { planKey: "owner/repo#137", tasks: [], note: "planner emitted no tasks" } } as any,
     app,
   );
   assertEquals(plans[0].status, "done");
-  // No wave to implement => no misleading wave_count: 0 while current_wave/wave_label are NULL.
-  assertEquals(plans[0].wave_count, null);
-  assertEquals(plans[0].current_wave, null);
-  assertEquals(plans[0].wave_label, null);
+  assertEquals(plans[0].wave_count, undefined);
+  assertEquals(plans[0].current_wave, undefined);
+  assertEquals(plans[0].wave_label, undefined);
 });
 
 test("record-plan persists per-task capability needs into plan_task_needs (issue #289)", async () => {

package/workers/record-plan/worker.ts

@@ -141,14 +141,10 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
   const patch: Record<string, unknown> = {
     status: tasks.length > 0 ? "dispatched" : "done",
     task_count: tasks.length,
-    // Operator-visibility progress projection (issue #137): total waves (N), and the wave the
-    // fleet is actively implementing (0 at dispatch). `select-wave` advances current_wave per
-    // wave; a taskless plan gets no wave (NULL) since there is nothing to implement. Display-only.
-    // All three fields stay NULL until dispatched with tasks — a taskless plan must not leak a
-    // misleading wave_count: 0 while current_wave/wave_label are NULL (inconsistent projection).
-    wave_count: tasks.length > 0 ? waveCount : null,
-    current_wave: tasks.length > 0 ? 0 : null,
-    wave_label: tasks.length > 0 ? `1/${waveCount}` : null,
+    // Operator-visibility wave progress (wave_count / current_wave / wave_label) was RETIRED as a
+    // stored projection (epic #412) — the epics-index reads it from the `plan_wave_label` /
+    // `plan_read_model` SQL VIEWs (060/061) derived from `plan_tasks`, so this worker no longer
+    // denormalises it onto the `plans` row.
     updated_at: ts,
   };
   // Domain-phase projection (#261): recording the plan hands the epic to the `review-plan` agent,

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

@@ -9,6 +9,7 @@
 import { test } from "node:test";
 import { assertEquals, assertRejects } from "#test-assert";
 import { BpmnError } from "@nanobpm/urban";
+import { deriveEpicBucket } from "../../app/delivery.ts";
 import { noopLog } from "../../test/log.ts";
 import handler from "./worker.ts";
 import type { PlanTaskStatus } from "../../app/plan.ts";
@@ -77,8 +78,9 @@ test("no opened PRs (empty plan) hard-fails with NO_WORK_DISPATCHED", async () =
   const plan = app._plans.at(-1) as Record<string, unknown>;
   assertEquals(plan.status, "failed");
   assertEquals(plan.outcome, "no work dispatched — the planner produced no tasks");
-  // The gateway projects the bucket: a failed epic settles to History (no tick-off needed).
-  assertEquals(plan.list_bucket, "history");
+  // `list_bucket` is derived by the `plan_read_model` VIEW (074): a failed epic reads as History
+  // (no tick-off needed). Cross-checked against the pure `deriveEpicBucket` oracle the VIEW mirrors.
+  assertEquals(deriveEpicBucket(plan.status as string, null, plan.acknowledged_at as string | null), "history");
 });
 
 test("tasks present but none opened (all skipped/blocked) hard-fails", async () => {
@@ -102,6 +104,7 @@ test("at least one opened PR finalizes cleanly (no throw)", async () => {
   const plan = app._plans.at(-1) as Record<string, unknown>;
   assertEquals(plan.status, "done");
   assertEquals(plan.outcome, "1 PR(s) dispatched to convergence");
-  // A just-`done` epic (delivery not yet projected) stays in Active — it must not vanish (#298).
-  assertEquals(plan.list_bucket, "active");
+  // A just-`done` epic (delivery not yet converging, unacknowledged) reads as Active through the VIEW —
+  // it must not vanish (#298). Cross-checked against the pure `deriveEpicBucket` oracle.
+  assertEquals(deriveEpicBucket(plan.status as string, null, plan.acknowledged_at as string | null), "active");
 });

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

@@ -142,8 +142,9 @@ test("record-wave retries the same wave when a task is still pending", async ()
     trialMergeSkipReason: "wave-still-pending",
   });
   assertEquals((planUpdates[0].patch as Record<string, unknown>).gate_wave, 1);
-  // Retry keeps the projection on the same (still-pending) wave.
-  assertEquals((planUpdates[0].patch as Record<string, unknown>).current_wave, 1);
+  // 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)");
 });
@@ -171,20 +172,21 @@ test("record-wave pins current_wave to the last index and clears gate_wave on th
     app,
   );
 
-  // Final wave (2 of 3): no successor wave — gate cleared, projection pinned to N-1 so the
-  // epics-index reads 3/3 rather than the one-past-the-end nextWave (3).
+  // Final wave (2 of 3): no successor wave — gate cleared. Wave progress (current_wave/wave_label)
+  // is no longer a stored column (epic #412; derived from `plan_tasks` by the plan_wave_label VIEW),
+  // so record-wave writes neither.
   assertEquals((planUpdates[0].patch as Record<string, unknown>).gate_wave, null);
-  assertEquals((planUpdates[0].patch as Record<string, unknown>).current_wave, 2);
-  assertEquals((planUpdates[0].patch as Record<string, unknown>).wave_label, "3/3");
+  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");
 });
 
-test("record-wave keeps all wave-progress fields NULL for a taskless plan (waveCount 0)", async () => {
+test("record-wave writes no wave-progress columns for a taskless plan (waveCount 0)", async () => {
   // A taskless plan runs record-wave with waveCount 0 (the MI `implement` step completed
-  // immediately). All three progress fields must stay NULL together — never current_wave=0 against
-  // a NULL wave_label, which would clobber record-plan/select-wave's NULL projection.
+  // immediately). Wave progress was retired as a stored projection (epic #412), so record-wave never
+  // writes current_wave/wave_label regardless.
   const { app, planUpdates } = fakeApp([]);
 
   await handler(
@@ -201,8 +203,8 @@ test("record-wave keeps all wave-progress fields NULL for a taskless plan (waveC
   );
 
   const patch = planUpdates[0].patch as Record<string, unknown>;
-  assertEquals(patch.current_wave, null);
-  assertEquals(patch.wave_label, null);
+  assertEquals("current_wave" in patch, false);
+  assertEquals("wave_label" in patch, false);
 });
 
 test("record-wave skips trial merge for mergify-queue repos with 2+ heads", async () => {

package/workers/record-wave/worker.ts

@@ -302,17 +302,15 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
   const nextWave = stillPendingCurrentWave ? currentWave : currentWave + 1;
   const hasMoreWaves = stillPendingCurrentWave || nextWave < waveCount;
 
-  // Operator-visibility projection (issue #137): keep plans.current_wave tracking the wave the
-  // fleet is on. While more waves remain, point it at the wave about to run (select-wave re-writes
-  // the same value when it dispatches); on the final wave, pin it to the last index so a finished
-  // epic reads N/N (nextWave would be waveCount, one past the last band). Display-only.
+  // Wave index the epic is now on (issue #137): while more waves remain, the wave about to run; on
+  // the final wave, pinned to the last index so a finished epic reads N/N (nextWave would be
+  // waveCount, one past the last band). This is a LOCAL value only — it is used below to derive the
+  // `epic_phase` (Implementing wave n/t) and the domain phase.
   const projectedCurrentWave = hasMoreWaves ? nextWave : Math.max(0, waveCount - 1);
-  // Keep the three progress fields consistent: a taskless plan (waveCount 0 — the MI `implement`
-  // step completed immediately with no waves) has no wave to be on, so current_wave and wave_label
-  // both stay NULL rather than writing current_wave=0 against a NULL label (and clobbering the NULL
-  // projection record-plan/select-wave already recorded).
-  const currentWaveProjection = waveCount > 0 ? projectedCurrentWave : null;
-  const waveLabel = waveCount > 0 ? `${projectedCurrentWave + 1}/${waveCount}` : null;
+  // Operator-visibility wave progress (current_wave / wave_label) was RETIRED as a stored projection
+  // (epic #412) — it is now derived from `plan_tasks` by the `plan_wave_label` / `plan_read_model`
+  // VIEWs (060/061), so this worker no longer denormalises it (select-wave no longer writes it
+  // either). `projectedCurrentWave` above is not persisted; it only feeds the phase derivation.
 
   // Domain-phase projection (#261): the wave landed — stamp the phase the epic is ENTERING next,
   // which is data-dependent here (unlike the structural spine writers). A trial merge runs → Trial
@@ -336,8 +334,6 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
   try {
     await plans(app.data).update(planKey, {
       gate_wave: hasMoreWaves ? currentWave : null,
-      current_wave: currentWaveProjection,
-      wave_label: waveLabel,
       epic_phase: epicPhase,
       updated_at: ts,
     });

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

@@ -67,21 +67,22 @@ async function selectWave(rows: Row[], deps: DepRow[]) {
   return out as { waveTasks: unknown[] };
 }
 
-test("select-wave projects the active wave onto plans.current_wave", async () => {
+test("select-wave dispatches the active wave without writing wave-progress columns", async () => {
   const rows: Row[] = [
     { id: 1, plan_key: "owner/repo#63", task_id: "a", title: "A", prompt: "do A", status: "pending", wave: 1 },
   ];
-  const plans: Record<string, unknown>[] = [{ plan_key: "owner/repo#63", current_wave: 0 }];
+  const plans: Record<string, unknown>[] = [{ plan_key: "owner/repo#63" }];
   const out = await handler(
     { variables: { planKey: "owner/repo#63", currentWave: 1 }, elementId: "select-wave" } as any,
     fakeApp(rows, [], plans),
   );
   assertEquals((out as { waveTasks: unknown[] }).waveTasks.length, 1);
-  assertEquals(plans[0].current_wave, 1);
-  // wave_count is derived from the levelized rows (max wave + 1) and the 1-based "X/N" label
-  // is pre-formatted for the epics-index at-a-glance column.
-  assertEquals(plans[0].wave_count, 2);
-  assertEquals(plans[0].wave_label, "2/2");
+  // Wave progress (current_wave/wave_count/wave_label) was retired as a stored projection (epic
+  // #412; the columns are dropped by migration 070) — it is derived from `plan_tasks` by the
+  // plan_wave_label VIEW — so select-wave introduces no wave-progress field onto the plan row.
+  assertEquals(plans[0].current_wave, undefined);
+  assertEquals(plans[0].wave_count, undefined);
+  assertEquals(plans[0].wave_label, undefined);
   // Domain-phase projection (#261): dispatching the wave marks the epic Implementing (wave n/t),
   // derived from this worker's BPMN element id + the levelize records.
   assertEquals(plans[0].epic_phase, "Implementing (wave 2/2)");
@@ -124,17 +125,18 @@ test("select-wave leaves bound_artifacts untouched for a root epic (no resolvedA
   assertEquals(plans[0].bound_artifacts, undefined);
 });
 
-test("select-wave nulls all three progress fields when there are no levelized rows", async () => {
-  // No plan_tasks rows => waveCount 0. current_wave must be NULL too (not a stray index against a
-  // NULL wave_count/wave_label), matching the documented "NULL until dispatched with tasks".
-  const plans: Record<string, unknown>[] = [{ plan_key: "owner/repo#63", current_wave: 5 }];
+test("select-wave writes no wave-progress columns when there are no levelized rows", async () => {
+  // Wave progress was retired as a stored projection (epic #412; the columns are dropped by
+  // migration 070; it is derived from `plan_tasks` by the plan_wave_label VIEW), so select-wave
+  // introduces no wave-progress field onto the plan row.
+  const plans: Record<string, unknown>[] = [{ plan_key: "owner/repo#63" }];
   await handler(
     { variables: { planKey: "owner/repo#63", currentWave: 0 } } as any,
     fakeApp([], [], plans),
   );
-  assertEquals(plans[0].current_wave, null);
-  assertEquals(plans[0].wave_count, null);
-  assertEquals(plans[0].wave_label, null);
+  assertEquals(plans[0].current_wave, undefined);
+  assertEquals(plans[0].wave_count, undefined);
+  assertEquals(plans[0].wave_label, undefined);
 });
 
 test("select-wave leaves dependents pending behind a waiting-for-lane dependency", async () => {

package/workers/select-wave/worker.ts

@@ -78,17 +78,16 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
     : [];
   try {
     await plans(app.data).update(planKey, {
-      // Keep the three progress fields consistent: with no levelized rows (waveCount 0) there is
-      // no wave to implement, so current_wave is NULL too — never a stray index against NULL N.
-      current_wave: waveCount > 0 ? currentWave : null,
-      wave_count: waveCount > 0 ? waveCount : null,
-      wave_label: waveCount > 0 ? `${currentWave + 1}/${waveCount}` : null,
+      // Operator-visibility wave progress (current_wave / wave_count / wave_label) was RETIRED as a
+      // stored projection (epic #412) — it is now derived from `plan_tasks` by the `plan_wave_label`
+      // / `plan_read_model` VIEWs (060/061), so select-wave no longer denormalises it. This write
+      // still stamps the derived domain phase and the inter-epic gate's bound artifacts.
       ...(epicPhase ? { epic_phase: epicPhase } : {}),
       ...(boundArtifacts.length > 0 ? { bound_artifacts: JSON.stringify(boundArtifacts) } : {}),
       updated_at: ts,
     });
   } catch (err) {
-    app.log.error(`select-wave: projecting current_wave failed for ${planKey}`, {
+    app.log.error(`select-wave: projecting plan row (epic phase / bound artifacts) failed for ${planKey}`, {
       err: String(err),
     });
   }