@nanobpm/nano-workforce 0.144.0 → 0.145.1

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 () => {

package/workers/record-wave/worker.ts

@@ -15,7 +15,6 @@
 // and, crucially, so a later wave's `dependsOn` can reference the PR keys earlier waves produced.
 import type { AppJobHandler } from "@nanobpm/urban";
 import { appendEntry } from "../../app/blackboard.ts";
-import { EPIC_PHASE, implementingPhase } from "../../app/epicPhase.ts";
 import { fetchPrFiles, fetchPrHead } from "../../app/github.ts";
 import { deriveExclusions, recordExclusions } from "../../app/mergeExclusion.ts";
 import { loadMergeProtocol } from "../../app/mergeProtocol.ts";
@@ -302,25 +301,11 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
   const nextWave = stillPendingCurrentWave ? currentWave : currentWave + 1;
   const hasMoreWaves = stillPendingCurrentWave || nextWave < waveCount;
 
-  // 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);
-  // 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
-  // merging; another wave follows → Implementing (next wave n/t); otherwise the finalizer runs →
-  // Finalizing (record-results then advances to the Dispatched terminal).
-  const epicPhase = runTrialMerge
-    ? EPIC_PHASE.TRIAL_MERGING
-    : hasMoreWaves
-      ? implementingPhase(projectedCurrentWave, waveCount)
-      : EPIC_PHASE.FINALIZING;
+  // The epic's domain phase is no longer stamped here (S8, #542) — it is a pure read-model derivation
+  // off the live element-instance model (`pollEpicPhase` → `deriveEpicPhaseLive`, app/epicPhase.ts),
+  // which reads the live token position (a running `implement` fan-out, `trial-merge`, or the
+  // finalizer) directly rather than this worker projecting the phase it is ABOUT to enter. This write
+  // now only arms the durable wave-merge barrier marker.
 
   // Wave-merge barrier: when another wave follows, park the plan-fanout instance at the
   // `wait-wave-merged` catch event until THIS wave's opened PRs have MERGED (not merely opened).
@@ -334,7 +319,6 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
   try {
     await plans(app.data).update(planKey, {
       gate_wave: hasMoreWaves ? currentWave : null,
-      epic_phase: epicPhase,
       updated_at: ts,
     });
   } catch (err) {

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

@@ -83,9 +83,10 @@ test("select-wave dispatches the active wave without writing wave-progress colum
   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)");
+  // Domain-phase projection is no longer stamped by this worker (S8, #542) — the epic phase is now a
+  // pure read-model derivation off the live element-instance model (`pollEpicPhase`, app/service.ts),
+  // so select-wave introduces no `epic_phase` onto the plan row.
+  assertEquals(plans[0].epic_phase, undefined);
 });
 
 test("select-wave captures the preflight's resolvedArtifacts onto plans.bound_artifacts (#292 S4)", async () => {

package/workers/select-wave/worker.ts

@@ -16,7 +16,6 @@
 // immediately (the same 0-task path the flat fan-out already relied on).
 import type { AppJobHandler } from "@nanobpm/urban";
 import type { CapabilityNeed } from "../../app/capabilityNeed.ts";
-import { deriveEpicPhase } from "../../app/epicPhase.ts";
 import { plans, planTaskDeps, planTaskNeeds, planTasks } from "../../app/plan.ts";
 import type { WorkerInputs } from "../../nano-generated/worker-io.d.ts";
 
@@ -52,20 +51,6 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
   const statusById = new Map<string, string>();
   for (const r of rows) statusById.set(r.task_id, r.status);
 
-  // Operator-visibility projection (issue #137): mark this as the wave the fleet is now
-  // implementing, so the epics-index can show wave X/N at a glance. wave_count is derivable from
-  // the levelized rows (max wave + 1), so the "X/N" label stays correct even if a re-levelize
-  // changed the total. Best-effort + idempotent (a retry re-writes the same value) and
-  // display-only — it must never gate control flow, which stays driven by the process
-  // `currentWave`/`waveCount`/`gate_wave` state.
-  const waveCount = rows.reduce((m, r) => Math.max(m, r.wave ?? 0), -1) + 1;
-  // Domain-phase projection (#261): select-wave dispatches this wave and is the last host write
-  // before the write-silent `implement` MI, so it durably marks the implementation phase for the
-  // wave it launches — `Implementing (wave n/t)` from the levelize records (job.elementId +
-  // current/total waves). A null derivation (element id absent) must not clobber the phase.
-  const epicPhase = waveCount > 0
-    ? deriveEpicPhase(job.elementId, { current: currentWave, total: waveCount })
-    : null;
   // Inter-epic gate projection (#292 slice S4): reaching select-wave proves this epic's leading
   // capability PREFLIGHT (S3) already went GREEN, so capture the `resolvedArtifacts` the preflight
   // bound — the exact `pkg@version`s first carrying each producer's awaited capability — onto the
@@ -76,20 +61,21 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
   const boundArtifacts = Array.isArray(job.variables.resolvedArtifacts)
     ? job.variables.resolvedArtifacts.filter((v): v is string => typeof v === "string" && v.trim().length > 0)
     : [];
-  try {
-    await plans(app.data).update(planKey, {
-      // 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 plan row (epic phase / bound artifacts) failed for ${planKey}`, {
-      err: String(err),
-    });
+  // The epic's Implementing (wave n/t) phase is no longer stamped here (S8, #542) — it is a pure
+  // read-model derivation off the live element-instance model (`pollEpicPhase`, app/service.ts), which
+  // reads the running `implement` fan-out directly. This write now only carries the inter-epic gate's
+  // bound artifacts, so it is skipped entirely when there are none.
+  if (boundArtifacts.length > 0) {
+    try {
+      await plans(app.data).update(planKey, {
+        bound_artifacts: JSON.stringify(boundArtifacts),
+        updated_at: ts,
+      });
+    } catch (err) {
+      app.log.error(`select-wave: projecting plan row (bound artifacts) failed for ${planKey}`, {
+        err: String(err),
+      });
+    }
   }
 
   const deps = await planTaskDeps(app.data).find({ plan_key: planKey });