@nanobpm/nano-workforce 0.101.0 → 0.102.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [0.102.0](https://github.com/nanobpm/nano-workforce/compare/v0.101.1...v0.102.0) (2026-08-19)
+
+
+### Features
+
+* **console:** merged-per-day burn-down/throughput chart ([#345](https://github.com/nanobpm/nano-workforce/issues/345)) ([d4b27a9](https://github.com/nanobpm/nano-workforce/commit/d4b27a9cad36217db7c8ffc49ef26e0f31fb688e)), closes [#344](https://github.com/nanobpm/nano-workforce/issues/344) [#290](https://github.com/nanobpm/nano-workforce/issues/290) [#337](https://github.com/nanobpm/nano-workforce/issues/337) [#339](https://github.com/nanobpm/nano-workforce/issues/339) [#340](https://github.com/nanobpm/nano-workforce/issues/340) [#338](https://github.com/nanobpm/nano-workforce/issues/338)
+
+## [0.101.1](https://github.com/nanobpm/nano-workforce/compare/v0.101.0...v0.101.1) (2026-08-19)
+
+
+### Bug Fixes
+
+* **merge-loop:** abandon a closed-not-merged PR instead of escalating ([#342](https://github.com/nanobpm/nano-workforce/issues/342)) ([#343](https://github.com/nanobpm/nano-workforce/issues/343)) ([10ea6be](https://github.com/nanobpm/nano-workforce/commit/10ea6be0e23c9315dfb71a6c94958826a1795a8c)), closes [#350](https://github.com/nanobpm/nano-workforce/issues/350)
+
 # [0.101.0](https://github.com/nanobpm/nano-workforce/compare/v0.100.0...v0.101.0) (2026-08-19)
 
 

package/app/github.test.ts

@@ -3,7 +3,7 @@
 // the merge-exclusion graph. Force the token transport and stub `globalThis.fetch`.
 import { test } from "node:test";
 import { assertEquals, assertRejects } from "#test-assert";
-import { BaseBranchMustExistError, coalesceTitle, createPullRequest, ensureBaseBranch, ensurePromotionPr, fetchIssueTitle, fetchPrFiles, isNotAPullRequestError, listPrsForHead } from "./github.ts";
+import { BaseBranchMustExistError, classifyPrLiveness, coalesceTitle, createPullRequest, ensureBaseBranch, ensurePromotionPr, fetchIssueTitle, fetchPrFiles, isNotAPullRequestError, listPrsForHead, type PrState } from "./github.ts";
 
 // A fake `fetch` that serves `pages` of file batches; each page N (1-based) returns `pages[N-1]`
 // files (named `f{index}`), setting a `Link: rel="next"` header whenever a later page exists.
@@ -428,3 +428,38 @@ test("ensurePromotionPr: creates when none exists, then reuses on a re-run (idem
   assertEquals(second?.number, 500);
   assertEquals(state.creates.length, 1);
 });
+// The shared PR-liveness gate (#342) maps live GitHub state onto one of {open, merged, closed,
+// unknown} so neither durable loop (merge/convergence) can escalate against a non-open PR. A closed
+// PR is terminal (abandon), a merged PR completes, and a null read stays conservative (unknown →
+// proceed as before). `merged` wins over `state` because a merged PR also reports state="closed".
+function prState(over: Partial<PrState>): PrState {
+  return {
+    merged: false,
+    state: "open",
+    mergeStateStatus: "CLEAN",
+    failingChecks: 0,
+    failingCheckNames: [],
+    presentCheckNames: [],
+    totalChecks: 0,
+    isDraft: false,
+    headRefOid: null,
+    ...over,
+  };
+}
+
+test("classifyPrLiveness: an open PR proceeds", () => {
+  assertEquals(classifyPrLiveness(prState({ state: "open" })), "open");
+});
+
+test("classifyPrLiveness: a merged PR completes (merged wins over a closed state)", () => {
+  assertEquals(classifyPrLiveness(prState({ merged: true, state: "closed" })), "merged");
+  assertEquals(classifyPrLiveness(prState({ merged: true, state: "merged" })), "merged");
+});
+
+test("classifyPrLiveness: a closed-not-merged PR is terminal (abandon)", () => {
+  assertEquals(classifyPrLiveness(prState({ merged: false, state: "closed" })), "closed");
+});
+
+test("classifyPrLiveness: a null read (transport hiccup) is unknown — never abandons blind", () => {
+  assertEquals(classifyPrLiveness(null), "unknown");
+});

package/app/github.ts

@@ -484,6 +484,11 @@ export function coalesceTitle(...candidates: (string | null | undefined)[]): str
  * failing gates (empty in token mode) so the CI-fix agent knows what to make green. */
 export interface PrState {
   merged: boolean;
+  /** GitHub's high-level PR lifecycle state, normalised to `"open" | "closed" | "merged"`. A PR
+   * closed *without* merging reports `"closed"` (GitHub also reports a merged PR as `"closed"` on
+   * the REST list, but `merged` disambiguates it). Lets a caller gate on PR liveness — see
+   * `classifyPrLiveness` — so neither loop escalates against a non-open PR (#342). */
+  state: "open" | "closed" | "merged";
   mergeStateStatus: string;
   failingChecks: number;
   failingCheckNames: string[];
@@ -584,8 +589,10 @@ export async function fetchPrState(
     };
     const rollup = j.statusCheckRollup ?? [];
     const names = failingCheckNames(rollup);
+    const merged = j.state === "MERGED" || !!j.mergedAt;
     return {
-      merged: j.state === "MERGED" || !!j.mergedAt,
+      merged,
+      state: merged ? "merged" : (j.state ?? "").toUpperCase() === "CLOSED" ? "closed" : "open",
       mergeStateStatus: (j.mergeStateStatus || "UNKNOWN").toUpperCase(),
       failingChecks: names.length,
       failingCheckNames: names,
@@ -604,14 +611,19 @@ export async function fetchPrState(
   const j = (await r.json()) as {
     merged?: boolean;
     merged_at?: string | null;
+    state?: string;
     mergeable_state?: string;
     draft?: boolean;
     head?: { sha?: string | null };
   };
+  const restMerged = !!j.merged || !!j.merged_at;
   return {
     // The single-PR GET returns a `merged` boolean (unlike the list endpoint); we also honour
     // `merged_at` so this mirrors the gh branch's `state === "MERGED" || mergedAt` rule.
-    merged: !!j.merged || !!j.merged_at,
+    merged: restMerged,
+    // REST reports a merged PR as `state:"closed"` too, so `merged` disambiguates: a `closed` PR
+    // here is genuinely closed WITHOUT merging (e.g. superseded) — the #342 abandon case.
+    state: restMerged ? "merged" : (j.state ?? "").toLowerCase() === "closed" ? "closed" : "open",
     mergeStateStatus: normalizeMergeState(j.mergeable_state ?? "unknown"),
     failingChecks: -1, // REST here doesn't enumerate checks → classifier treats BLOCKED as "wait"
     failingCheckNames: [], // …and the CI-fix agent gets no per-check list in token mode
@@ -622,6 +634,27 @@ export async function fetchPrState(
   };
 }
 
+/** Map a PR's live GitHub state to one **liveness** verdict shared by both durable loops (merge +
+ * convergence), so neither can ever escalate against a non-open PR (#342):
+ *
+ *   • `open`     — proceed with the normal protocol.
+ *   • `merged`   — already landed (out-of-band); complete the loop as merged.
+ *   • `closed`   — closed on GitHub WITHOUT merging (e.g. superseded); the PR can never merge, so
+ *                  the loop must **abandon** (terminate) it — NOT escalate a merge no human can
+ *                  complete. This is terminal state, not a human decision.
+ *   • `unknown`  — a transport hiccup left us without live state (`fetchPrState` returned null);
+ *                  stay conservative and fall through to the normal path rather than abandoning a
+ *                  PR we could not read.
+ *
+ * Deriving all three from one source keeps a single canonical liveness gate instead of each loop
+ * re-implementing `pre?.merged`/closed checks against drifting field names. */
+export function classifyPrLiveness(pre: PrState | null): "open" | "merged" | "closed" | "unknown" {
+  if (!pre) return "unknown";
+  if (pre.merged) return "merged";
+  if (pre.state === "closed") return "closed";
+  return "open";
+}
+
 /** The changed file paths of a PR (for the D2 conflict-scan, #58). `gh` returns them directly;
  * the token transport pages `/pulls/{n}/files` (100/page, capped). Returns `null` when no
  * transport is usable (idle), an empty array for a PR with no files. */

package/app/mergesPerDay.test.ts

@@ -0,0 +1,173 @@
+// Read-model derivation + projection 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.
+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";
+
+// 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", () => {
+  const days = deriveMergesPerDay([
+    merged("o/r#1", "2026-01-01T09:00:00Z"),
+    merged("o/r#2", "2026-01-01T18:30:00Z"),
+    merged("o/r#3", "2026-01-02T10:00:00Z"),
+  ]);
+  assertEquals(days.map((d) => [d.day, d.merged]), [
+    ["2026-01-01", 2],
+    ["2026-01-02", 1],
+  ]);
+});
+
+test("dedupes duplicate merged rows for the same PR on the same day (COUNT DISTINCT pr_key)", () => {
+  const days = deriveMergesPerDay([
+    merged("o/r#1", "2026-01-01T09:00:00Z"),
+    merged("o/r#1", "2026-01-01T09:00:05Z"), // retry / already-merged short-circuit
+    merged("o/r#1", "2026-01-01T23:59:00Z"),
+  ]);
+  assertEquals(days.length, 1);
+  assertEquals(days[0].merged, 1);
+});
+
+test("the same PR merged on two different days counts once per day", () => {
+  // A defensive case: distinctness is per-day, not global.
+  const days = deriveMergesPerDay([
+    merged("o/r#1", "2026-01-01T09:00:00Z"),
+    merged("o/r#1", "2026-01-02T09:00:00Z"),
+  ]);
+  assertEquals(days.map((d) => [d.day, d.merged]), [
+    ["2026-01-01", 1],
+    ["2026-01-02", 1],
+  ]);
+});
+
+test("ignores queued and blocked attempts", () => {
+  const days = deriveMergesPerDay([
+    merged("o/r#1", "2026-01-01T09:00:00Z"),
+    { pr_key: "o/r#2", outcome: "queued", at: "2026-01-01T09:10:00Z" },
+    { pr_key: "o/r#3", outcome: "blocked", at: "2026-01-01T09:20:00Z" },
+  ]);
+  assertEquals(days.length, 1);
+  assertEquals(days[0].merged, 1);
+});
+
+test("orders days ascending and carries a running burn-up cumulative", () => {
+  const days = deriveMergesPerDay([
+    merged("o/r#5", "2026-01-03T10:00:00Z"),
+    merged("o/r#1", "2026-01-01T10:00:00Z"),
+    merged("o/r#2", "2026-01-01T11:00:00Z"),
+    merged("o/r#4", "2026-01-02T10:00:00Z"),
+  ]);
+  assertEquals(days.map((d) => d.day), ["2026-01-01", "2026-01-02", "2026-01-03"]);
+  assertEquals(days.map((d) => d.merged), [2, 1, 1]);
+  assertEquals(days.map((d) => d.cumulative), [2, 3, 4]);
+});
+
+test("bar scales against the busiest day: full for the max, non-empty for a lone merge, empty for zero", () => {
+  const days = deriveMergesPerDay([
+    // day A: 4 merges (the max) → widest bar
+    merged("o/r#1", "2026-01-01T01:00:00Z"),
+    merged("o/r#2", "2026-01-01T02:00:00Z"),
+    merged("o/r#3", "2026-01-01T03:00:00Z"),
+    merged("o/r#4", "2026-01-01T04:00:00Z"),
+    // day B: 1 merge → short but visible bar
+    merged("o/r#5", "2026-01-02T01:00:00Z"),
+  ]);
+  const [a, b] = days;
+  assert(a.bar.length > b.bar.length, "the busier day must draw a longer bar");
+  assert(b.bar.length >= 1, "a day with any merge must draw at least one glyph");
+  assert(a.bar.length <= 30, "the busiest bar must not exceed the configured width");
+});
+
+test("empty audit yields no days", () => {
+  assertEquals(deriveMergesPerDay([]), []);
+});
+
+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);
+  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);
+  const afterFirst = writes();
+  assert(afterFirst > 0, "the first pass must project at least one row");
+  await pollMergesPerDay(data);
+  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);
+  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

@@ -0,0 +1,150 @@
+// Merged-per-day throughput / burn-up read model (issue #344).
+//
+// A simple time-series behind the console's "Velocity" page: how many PRs the fleet landed each
+// calendar day (throughput), plus a running `cumulative` burn-up total. Every land is already
+// audited in the `merges` table (004_merge.sql) — one row per merge attempt, whose `outcome`
+// includes `merged`, `queued`, `blocked` and `retry` (see the merge classifier in github.ts; the
+// set is not exhaustive), `at` = ISO timestamp. Only `outcome = 'merged'` rows feed this aggregate,
+// so merged-per-day is
+// fully DERIVABLE from that audit trail with NO new write-path bookkeeping (AGENTS.md: "Derivation
+// over duplication"). The canonical aggregate is the one in the issue:
+//
+//   SELECT date(at) AS day, COUNT(DISTINCT pr_key) AS merged
+//   FROM merges WHERE outcome = 'merged' GROUP BY date(at);
+//
+// Two halves, mirroring the `deriveDelivery`/`pollDelivery` and `deriveLineage`/`pollLineage`
+// convention:
+//   • `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. */
+export interface MergeAuditRow {
+  pr_key: string;
+  outcome: string;
+  at: string;
+}
+
+/** One projected calendar day of merge throughput. */
+export interface MergeDay {
+  /** Calendar day, ISO `YYYY-MM-DD` (SQLite `date(at)`). */
+  day: string;
+  /** Distinct PRs merged that day (`COUNT(DISTINCT pr_key)`). */
+  merged: number;
+  /** Running total of merged PRs up to and including this day — the burn-up line. */
+  cumulative: number;
+  /** Proportional block-character bar (length scaled to the busiest day), for the prose chart. */
+  bar: string;
+}
+
+/** Widest bar (in block glyphs) the busiest day draws; every other day scales against it. */
+const BAR_WIDTH = 30;
+const BAR_FULL = "█";
+
+/** The calendar day of an ISO timestamp — the JS twin of SQLite `date(at)`. A well-formed `merges.at`
+ *  is an ISO string, so the first 10 chars are `YYYY-MM-DD`; fall back to the whole trimmed value for
+ *  any non-ISO shape so a malformed row still groups deterministically rather than throwing. */
+function dayOf(at: string): string {
+  const s = String(at).trim();
+  return /^\d{4}-\d{2}-\d{2}/.test(s) ? s.slice(0, 10) : s;
+}
+
+/** Render a proportional bar: `merged` glyphs scaled against the busiest day's `max`, min one glyph
+ *  for any non-zero day so a lone merge is still visible. Zero renders as an empty bar. */
+function barFor(merged: number, max: number): string {
+  if (merged <= 0 || max <= 0) return "";
+  const n = Math.max(1, Math.round((merged / max) * BAR_WIDTH));
+  return BAR_FULL.repeat(n);
+}
+
+/** PURE aggregate: merge audit rows → one ordered `MergeDay` per calendar day (ascending).
+ *
+ * Only `outcome === "merged"` rows count; `queued`/`blocked` attempts are ignored. Within a day a
+ * `pr_key` is counted once (`COUNT(DISTINCT pr_key)`), so duplicate `merged` audit rows — an
+ * `already-merged` short-circuit or a retry — do not double-count. `cumulative` is the running total
+ * across days (burn-up); `bar` is scaled against the busiest day so the chart is comparable. */
+export function deriveMergesPerDay(rows: readonly MergeAuditRow[]): MergeDay[] {
+  // day -> set of distinct merged pr_keys that day.
+  const prKeysByDay = new Map<string, Set<string>>();
+  for (const r of rows) {
+    if (r.outcome !== "merged") continue;
+    if (r.pr_key == null || r.at == null) continue;
+    const day = dayOf(r.at);
+    let set = prKeysByDay.get(day);
+    if (!set) {
+      set = new Set<string>();
+      prKeysByDay.set(day, set);
+    }
+    set.add(r.pr_key);
+  }
+
+  const counts = [...prKeysByDay.entries()]
+    .map(([day, set]) => ({ day, merged: set.size }))
+    .sort((a, b) => a.day.localeCompare(b.day));
+  const max = counts.reduce((m, c) => Math.max(m, c.merged), 0);
+
+  let cumulative = 0;
+  const out: MergeDay[] = [];
+  for (const { day, merged } of counts) {
+    cumulative += merged;
+    out.push({ day, merged, cumulative, bar: barFor(merged, max) });
+  }
+  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). */
+export async function pollMergesPerDay(data: DataLayer): 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);
+    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/queuedVerdict.test.ts

@@ -11,6 +11,7 @@ import { queuedVerdict } from "./service.ts";
 function st(over: Partial<PrState>): PrState {
   return {
     merged: false,
+    state: "open",
     mergeStateStatus: "CLEAN",
     failingChecks: 0,
     failingCheckNames: [],

package/app/reviewReadinessGate.test.ts

@@ -76,7 +76,10 @@ test("the migrated wait stays bounded: an event-based gateway races the signal a
 });
 
 test("the timeout arm escalates to a human (the wait cannot hang forever)", () => {
-  // timer catch → persist-review-stalled (records the escalation) → wait-answer (native userTask).
+  // timer catch → persist-review-stalled (records the escalation) → gw-escalated → wait-answer.
+  // Since #340 every escalation arm converges on the shared `gw-escalated` gateway (no per-arm twin
+  // edge to the userTask — derivation over duplication), which routes to the native `wait-answer`
+  // userTask when an escalation actually opened (`escalated = true`). Assert that canonical path.
   assert(
     /sourceRef="wait-review-timeout"[^>]*targetRef="persist-review-stalled"|targetRef="persist-review-stalled"[^>]*sourceRef="wait-review-timeout"/.test(
       flat,
@@ -84,9 +87,18 @@ test("the timeout arm escalates to a human (the wait cannot hang forever)", () =
     "a timed-out review wait routes to the stalled-review escalation",
   );
   assert(
-    /sourceRef="persist-review-stalled"[^>]*targetRef="wait-answer"|targetRef="wait-answer"[^>]*sourceRef="persist-review-stalled"/.test(
+    /sourceRef="persist-review-stalled"[^>]*targetRef="gw-escalated"|targetRef="gw-escalated"[^>]*sourceRef="persist-review-stalled"/.test(
       flat,
     ),
-    "the stalled-review escalation parks on the human answer userTask",
+    "the stalled-review escalation converges on the shared gw-escalated gateway",
+  );
+  const escWait = flat.match(
+    /<bpmn:sequenceFlow\b[^>]*\bsourceRef="gw-escalated"[^>]*\btargetRef="wait-answer"[^>]*>[\s\S]*?<\/bpmn:sequenceFlow>/,
+  );
+  assert(escWait, "gw-escalated must route to the human answer userTask (wait-answer)");
+  assertStringIncludes(
+    escWait![0],
+    "escalated = true",
+    "gw-escalated parks on wait-answer only when an escalation actually opened",
   );
 });

package/app/service.ts

@@ -25,6 +25,7 @@ import { deriveDelivery, TERMINAL_STATUSES } from "./delivery.ts";
 import { backfillFeatureStages, deriveFeatureDelivery, FEATURE_BLOCKED_ELEMENT, FEATURE_ESCALATION_ELEMENT, FEATURE_RUN_STATUSES, type FeatureRunStatus, featureEscalations, featureRuns } from "./feature.ts";
 import {
   classifyMergeability,
+  classifyPrLiveness,
   coalesceTitle,
   ensureFreshHeadRun,
   ensurePromotionPr,
@@ -42,6 +43,7 @@ import {
 import { pollLineage } from "./lineage.ts";
 import { mergeLanes, readExclusions } from "./mergeExclusion.ts";
 import { freshHeadRunAction, headRunPresenceCount, loadMergeProtocol } from "./mergeProtocol.ts";
+import { pollMergesPerDay } from "./mergesPerDay.ts";
 import { type PrLaneDecision, planPrLane, taskDependencyDepths } from "./mergeTrain.ts";
 import {
   backfillPlanBuckets,
@@ -925,7 +927,8 @@ async function pollMerges(data: DataLayer, engine: EngineClient, token: string)
     try {
       const st = await fetchPrState(repo, number, token);
       if (st === null) continue; // no transport → skip this PR (others may still advance)
-      if (st.merged) {
+      const liveness = classifyPrLiveness(st);
+      if (liveness === "merged") {
         // Landed out-of-band (a maintainer clicked Merge, a mergify queue merged it, etc.). The
         // instance is parked at `wait-mergeable`, which subscribes to `merge-ready` — NOT
         // `merge-landed` (that catch, `wait-landed`, only exists later, after we enqueue). Publishing
@@ -941,6 +944,21 @@ async function pollMerges(data: DataLayer, engine: EngineClient, token: string)
         console.log(`[poller] already merged -> ${prKey}`);
         continue;
       }
+      if (liveness === "closed") {
+        // Closed on GitHub WITHOUT merging (e.g. superseded by a newer PR — #350). The PR can never
+        // land, so it must NOT be classified as blocked/conflict and escalated (that orphans the
+        // process on a dead PR, #342). Route it through the same canonical `merge-ready` → `ready` →
+        // `attempt-merge` path as the merged case; the merge worker's closed short-circuit records a
+        // terminal `abandoned` audit row and drives the loop down its terminate/abandon end event.
+        // One canonical abandon implementation lives in the worker — the poller only routes to it.
+        await flipToMergingThenPublish(data, engine, prKey, "waiting_merge", {
+          name: "merge-ready",
+          correlationKey: prKey,
+          variables: { mergeState: "ready", failingChecks: 0, failingChecksList: "" },
+        });
+        console.log(`[poller] closed without merging -> ${prKey}`);
+        continue;
+      }
       const verdict = classifyMergeability(st);
       if (verdict === "waiting") {
         // Frugal-CI remedy (#43): when the repo publishes a merge protocol that wants a fresh
@@ -2099,6 +2117,7 @@ export async function pollOnce(
   await pollPromotion(data, engine, token);
   await pollFeatureDelivery(data);
   await pollLineage(data);
+  await pollMergesPerDay(data);
   await pollUserTasks(data, engine);
   if (engineRest) {
     const base = engineRest.restAddress.replace(/\/+$/, "");

package/db/migrations/051_merges_per_day.sql

@@ -0,0 +1,33 @@
+-- Merged-per-day throughput / burn-up read model (issue #344).
+--
+-- Every land is already audited in `merges` (004_merge.sql): one row per merge attempt, whose
+-- `outcome` includes `merged`, `queued`, `blocked` and `retry` (the set is not exhaustive) and
+-- `at` = ISO timestamp. Only `outcome = 'merged'` rows count. The per-calendar-day merged count is
+-- therefore fully DERIVABLE from that audit trail — no new write-path bookkeeping (AGENTS.md:
+-- "Derivation over duplication"). The canonical aggregate is:
+--
+--   SELECT date(at) AS day, COUNT(DISTINCT pr_key) AS merged
+--   FROM merges WHERE outcome = 'merged' GROUP BY date(at);
+--
+-- `COUNT(DISTINCT pr_key)` (not `COUNT(*)`) so a PR that produced several audit rows on one day —
+-- e.g. an `already-merged` short-circuit or a retry — counts once per day.
+--
+-- The natural home for that aggregate would be a SQL VIEW, but Urban's page datasource cannot read
+-- one: `gateway.ts schema()` whitelists `sqlite_master.type = 'table'` only, so a page binding to a
+-- VIEW 400s at request time (see the `lineage_threads` / `plans.delivery` precedent, 037_lineage.sql).
+-- So — following the codebase convention for read-model projections — this is a DENORMALISED flat
+-- table the schema-driven Velocity page reads directly, recomputed idempotently each poll pass by
+-- `pollMergesPerDay` (app/mergesPerDay.ts) from the `merges` audit rows. `cumulative` is the burn-up
+-- running total; `bar` is a precomputed proportional block-character bar so the declarative `prose`
+-- renderer can draw a horizontal bar per day with no chart node type.
+--
+-- Forward-only, additive (expand): a new derived read table. The runner wraps each file in its own
+-- transaction, so this file must NOT contain BEGIN/COMMIT. Numbered after the current highest prefix
+-- (050). `day` is the PRIMARY KEY, which SQLite already indexes, so no extra index is needed.
+CREATE TABLE IF NOT EXISTS merges_per_day (
+  day        TEXT PRIMARY KEY,             -- calendar day (date(at), ISO YYYY-MM-DD)
+  merged     INTEGER NOT NULL DEFAULT 0,   -- COUNT(DISTINCT pr_key) merged that day
+  cumulative INTEGER NOT NULL DEFAULT 0,   -- running total of merged PRs up to and including `day` (burn-up)
+  bar        TEXT NOT NULL DEFAULT '',     -- proportional block-character bar for the prose chart
+  updated_at TEXT NOT NULL
+);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.101.0",
+  "version": "0.102.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/_nav.json

@@ -23,7 +23,8 @@
         }
       },
       { "label": "Cockpit", "page": "cockpit" },
-      { "label": "Board", "page": "board" }
+      { "label": "Board", "page": "board" },
+      { "label": "Velocity", "page": "velocity" }
     ],
     "sticky": true
   }

package/pages/board.page.json

@@ -48,6 +48,10 @@
           {
             "label": "Board",
             "page": "board"
+          },
+          {
+            "label": "Velocity",
+            "page": "velocity"
           }
         ],
         "sticky": true

package/pages/cockpit.page.json

@@ -48,6 +48,10 @@
           {
             "label": "Board",
             "page": "board"
+          },
+          {
+            "label": "Velocity",
+            "page": "velocity"
           }
         ],
         "sticky": true

package/pages/epic-detail.page.json

@@ -48,6 +48,10 @@
           {
             "label": "Board",
             "page": "board"
+          },
+          {
+            "label": "Velocity",
+            "page": "velocity"
           }
         ],
         "sticky": true