@nanobpm/nano-workforce 0.121.0 → 0.122.0

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),
     });
   }