@nanobpm/nano-workforce 0.119.0 → 0.120.1

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [0.120.1](https://github.com/nanobpm/nano-workforce/compare/v0.120.0...v0.120.1) (2026-08-22)
+
+
+### Bug Fixes
+
+* **readiness:** make pr.readiness-probe single-shot; engine owns retry cadence ([#428](https://github.com/nanobpm/nano-workforce/issues/428)) ([#429](https://github.com/nanobpm/nano-workforce/issues/429)) ([07db031](https://github.com/nanobpm/nano-workforce/commit/07db031f0d5e3f63ff47ffa51583bdef3012a2ab))
+
+# [0.120.0](https://github.com/nanobpm/nano-workforce/compare/v0.119.0...v0.120.0) (2026-08-22)
+
+
+### Features
+
+* **lineage:** derive view-expressible lineage_threads columns via SQL VIEW ([#437](https://github.com/nanobpm/nano-workforce/issues/437)) ([f25c824](https://github.com/nanobpm/nano-workforce/commit/f25c824bf9c72c3757a58794065a5c86b208dbe0)), closes [nano-ide#424](https://github.com/nano-ide/issues/424) [nanobpm/nano-workforce#412](https://github.com/nanobpm/nano-workforce/issues/412)
+* **velocity:** back merged-per-day with a SQL VIEW, repoint Velocity page ([#412](https://github.com/nanobpm/nano-workforce/issues/412)) ([#436](https://github.com/nanobpm/nano-workforce/issues/436)) ([5be81e4](https://github.com/nanobpm/nano-workforce/commit/5be81e466f2593622ae837d6e63b00f0287c305d)), closes [nano-ide#424](https://github.com/nano-ide/issues/424) [#411](https://github.com/nanobpm/nano-workforce/issues/411) [#361](https://github.com/nanobpm/nano-workforce/issues/361)
+
 # [0.119.0](https://github.com/nanobpm/nano-workforce/compare/v0.118.2...v0.119.0) (2026-08-22)
 
 

package/app/capabilityNeed.test.ts

@@ -106,9 +106,11 @@ test("capabilityNeedToProbeInput: maps a need to the readiness-gate capability p
     planKey: "owner/repo#289",
     taskId: "issue-289",
     probeTimeout: "PT12H",
+    probePollEvery: "PT15S",
   });
   assertEquals(input.gateKey, "owner/repo#289:issue-289:nanobpm/nano-ide#274:@nanobpm/urban");
   assertEquals(input.probeTimeout, "PT12H");
+  assertEquals(input.probePollEvery, "PT15S");
   assertEquals(input.onTimeout, "escalate");
   assertEquals(input.probe.kind, "capability");
   assertEquals(input.probe.target, "github-releases:nanobpm/nano-ide");
@@ -121,7 +123,7 @@ test("capabilityNeedToProbeInput: maps a need to the readiness-gate capability p
 test("capabilityNeedToProbeInput: omits verifyCommand when the need has none", () => {
   const input = capabilityNeedToProbeInput(
     { capabilityRef: "nanobpm/nano-ide#274", package: "@nanobpm/urban" },
-    { planKey: "o/r#1", taskId: "t1", probeTimeout: "PT1H" },
+    { planKey: "o/r#1", taskId: "t1", probeTimeout: "PT1H", probePollEvery: "PT15S" },
   );
   assertEquals(input.probe.match?.verifyCommand, undefined);
 });
@@ -131,7 +133,7 @@ test("capabilityNeedToProbeInput: throws when the handle names no releases sourc
     () =>
       capabilityNeedToProbeInput(
         { capabilityRef: "#274", package: "@nanobpm/urban" },
-        { planKey: "o/r#1", taskId: "t1", probeTimeout: "PT1H" },
+        { planKey: "o/r#1", taskId: "t1", probeTimeout: "PT1H", probePollEvery: "PT15S" },
       ),
     UnresolvableCapabilityRefError,
     "names no owner/repo releases source",

package/app/capabilityNeed.ts

@@ -36,6 +36,7 @@ export interface CapabilityNeed {
 export interface ReadinessProbeInput {
   readonly gateKey: string;
   readonly probeTimeout: string;
+  readonly probePollEvery: string;
   readonly onTimeout?: OnTimeout;
   readonly probe: ReadinessProbe;
 }
@@ -152,7 +153,7 @@ export function capabilityTaskBarrierKey(planKey: string, taskId: string): strin
  * the handle names no releases source. */
 export function capabilityNeedToProbeInput(
   need: CapabilityNeed,
-  opts: { planKey: string; taskId: string; probeTimeout: string },
+  opts: { planKey: string; taskId: string; probeTimeout: string; probePollEvery: string },
 ): ReadinessProbeInput {
   const repo = capabilityReleasesRepo(need.capabilityRef);
   if (!repo) throw new UnresolvableCapabilityRefError(need.capabilityRef);
@@ -170,6 +171,7 @@ export function capabilityNeedToProbeInput(
   return {
     gateKey: capabilityGateKey(opts.planKey, opts.taskId, need.capabilityRef, need.package),
     probeTimeout: opts.probeTimeout,
+    probePollEvery: opts.probePollEvery,
     onTimeout: "escalate",
     probe,
   };

package/app/deliveryGraphCompiler.test.ts

@@ -85,10 +85,10 @@ test("determinism: the same JSON always yields byte-identical bpmn/diagram/resol
 
 test("trust bound: every node inlines an embedded subProcess delegating to an allowlisted body — no other activity type", () => {
   const r = compileOk(RELEASE_RUNBOOK);
-  // Each of the 4 nodes compiles to an EMBEDDED subProcess (call activities are a no-op on the pinned
+  // Each of the 4 nodes compiles to an EMBEDDED subProcess; wait adds one nested retry-loop subProcess (call activities are a no-op on the pinned
   // WASM engine, so delegation is an inlined subProcess sharing the parent scope — never a callActivity).
   assertEquals((r.bpmn.match(/<bpmn:callActivity/g) ?? []).length, 0);
-  assertEquals((r.bpmn.match(/<bpmn:subProcess /g) ?? []).length, 4);
+  assertEquals((r.bpmn.match(/<bpmn:subProcess /g) ?? []).length, 5);
   assert(!r.bpmn.includes("<bpmn:scriptTask"), "no script task is ever emitted");
   // Each node's inner body delegates to an allowlisted engine-native body: a `serviceTask` typed to a
   // worker (agent → its `senior:*` job; wait → `pr.readiness-probe`; connector → `pr.delivery-connector`)

package/app/deliveryGraphCompiler.ts

@@ -604,6 +604,7 @@ function ioMappingLines(w: NodeWiring, boundInputs: readonly BoundInput[]): stri
       inputs.push({ source: cfg("gateKey"), target: "gateKey" });
       inputs.push({ source: cfg("probe"), target: "probe" });
       inputs.push({ source: cfg("probeTimeout"), target: "probeTimeout" });
+      inputs.push({ source: cfg("probePollEvery"), target: "probePollEvery" });
       break;
     case "human":
       inputs.push({ source: cfg("escalationSlaTimeout"), target: "escalationSlaTimeout" });
@@ -712,33 +713,78 @@ function waitBodyLines(el: string, nodeId: string): string[] {
   const esc = escalationTaskElement(el);
   return [
     `      <bpmn:startEvent id="${el}_start"><bpmn:outgoing>${el}_i0</bpmn:outgoing></bpmn:startEvent>`,
-    `      <bpmn:serviceTask id="${el}_task" name="Probe readiness: ${escapeXml(nodeId)}">`,
+    `      <bpmn:subProcess id="${el}_probeLoop" name="Probe readiness loop: ${escapeXml(nodeId)}">`,
+    "        <bpmn:extensionElements>",
+    "          <zeebe:ioMapping>",
+    '            <zeebe:output source="=ready" target="ready" />',
+    '            <zeebe:output source="=if (is defined(detail)) then detail else null" target="detail" />',
+    '            <zeebe:output source="=if (is defined(resolvedArtifact)) then resolvedArtifact else null" target="resolvedArtifact" />',
+    '            <zeebe:output source="=if (is defined(mergedSha)) then mergedSha else null" target="mergedSha" />',
+    "          </zeebe:ioMapping>",
+    "        </bpmn:extensionElements>",
+    `        <bpmn:incoming>${el}_i0</bpmn:incoming>`,
+    `        <bpmn:outgoing>${el}_i1</bpmn:outgoing>`,
+    `        <bpmn:startEvent id="${el}_loopStart"><bpmn:outgoing>${el}_li0</bpmn:outgoing></bpmn:startEvent>`,
+    `        <bpmn:serviceTask id="${el}_task" name="Probe readiness: ${escapeXml(nodeId)}">`,
+    "          <bpmn:extensionElements>",
+    `            <zeebe:taskDefinition type="${DELEGATE_TASK_TYPE.wait}" />`,
+    "            <zeebe:properties>",
+    '              <zeebe:property name="io.nanobpm.dataEnvelope.in" value="ReadinessProbeIn" />',
+    '              <zeebe:property name="io.nanobpm.dataEnvelope.out" value="ReadinessProbeOut" />',
+    "            </zeebe:properties>",
+    "          </bpmn:extensionElements>",
+    `          <bpmn:incoming>${el}_li0</bpmn:incoming>`,
+    `          <bpmn:incoming>${el}_li4</bpmn:incoming>`,
+    `          <bpmn:outgoing>${el}_li1</bpmn:outgoing>`,
+    "        </bpmn:serviceTask>",
+    `        <bpmn:exclusiveGateway id="${el}_gw" name="ready?" default="${el}_li3">`,
+    `          <bpmn:incoming>${el}_li1</bpmn:incoming>`,
+    `          <bpmn:outgoing>${el}_li2</bpmn:outgoing>`,
+    `          <bpmn:outgoing>${el}_li3</bpmn:outgoing>`,
+    "        </bpmn:exclusiveGateway>",
+    `        <bpmn:intermediateCatchEvent id="${el}_waitPoll" name="Wait poll interval">`,
+    `          <bpmn:incoming>${el}_li3</bpmn:incoming>`,
+    `          <bpmn:outgoing>${el}_li4</bpmn:outgoing>`,
+    `          <bpmn:timerEventDefinition id="${el}_pollTed"><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">=probePollEvery</bpmn:timeDuration></bpmn:timerEventDefinition>`,
+    "        </bpmn:intermediateCatchEvent>",
+    `        <bpmn:endEvent id="${el}_loopEnd"><bpmn:incoming>${el}_li2</bpmn:incoming></bpmn:endEvent>`,
+    flow(`${el}_li0`, `${el}_loopStart`, `${el}_task`),
+    flow(`${el}_li1`, `${el}_task`, `${el}_gw`),
+    `      <bpmn:sequenceFlow id="${el}_li2" name="ready" sourceRef="${el}_gw" targetRef="${el}_loopEnd"><bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">=ready = true</bpmn:conditionExpression></bpmn:sequenceFlow>`,
+    `        <bpmn:sequenceFlow id="${el}_li3" name="not ready" sourceRef="${el}_gw" targetRef="${el}_waitPoll" />`,
+    flow(`${el}_li4`, `${el}_waitPoll`, `${el}_task`),
+    "      </bpmn:subProcess>",
+    `      <bpmn:boundaryEvent id="${el}_be" name="Gate timed out" attachedToRef="${el}_probeLoop">`,
+    `        <bpmn:outgoing>${el}_i2</bpmn:outgoing>`,
+    `        <bpmn:timerEventDefinition id="${el}_ted"><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">=probeTimeout</bpmn:timeDuration></bpmn:timerEventDefinition>`,
+    "      </bpmn:boundaryEvent>",
+    `      <bpmn:serviceTask id="${el}_lastAttempt" name="Probe readiness at boundary: ${escapeXml(nodeId)}">`,
     "        <bpmn:extensionElements>",
     `          <zeebe:taskDefinition type="${DELEGATE_TASK_TYPE.wait}" />`,
     "          <zeebe:properties>",
     '            <zeebe:property name="io.nanobpm.dataEnvelope.in" value="ReadinessProbeIn" />',
     '            <zeebe:property name="io.nanobpm.dataEnvelope.out" value="ReadinessProbeOut" />',
     "          </zeebe:properties>",
+    "          <zeebe:ioMapping>",
+    '            <zeebe:input source="=true" target="lastAttempt" />',
+    "          </zeebe:ioMapping>",
     "        </bpmn:extensionElements>",
-    `        <bpmn:incoming>${el}_i0</bpmn:incoming>`,
-    `        <bpmn:outgoing>${el}_i1</bpmn:outgoing>`,
+    `        <bpmn:incoming>${el}_i2</bpmn:incoming>`,
+    `        <bpmn:outgoing>${el}_i6</bpmn:outgoing>`,
     "      </bpmn:serviceTask>",
-    `      <bpmn:boundaryEvent id="${el}_be" name="Gate timed out" attachedToRef="${el}_task">`,
-    `        <bpmn:outgoing>${el}_i2</bpmn:outgoing>`,
-    `        <bpmn:timerEventDefinition id="${el}_ted"><bpmn:timeDuration xsi:type="bpmn:tFormalExpression">=probeTimeout</bpmn:timeDuration></bpmn:timerEventDefinition>`,
-    "      </bpmn:boundaryEvent>",
-    `      <bpmn:exclusiveGateway id="${el}_gw" name="ready?" default="${el}_i4">`,
-    `        <bpmn:incoming>${el}_i1</bpmn:incoming>`,
-    `        <bpmn:outgoing>${el}_i3</bpmn:outgoing>`,
+    `      <bpmn:exclusiveGateway id="${el}_lastGw" name="ready after boundary?" default="${el}_i4">`,
+    `        <bpmn:incoming>${el}_i6</bpmn:incoming>`,
+    `        <bpmn:outgoing>${el}_i7</bpmn:outgoing>`,
     `        <bpmn:outgoing>${el}_i4</bpmn:outgoing>`,
     "      </bpmn:exclusiveGateway>",
-    ...escalationTaskLines(esc, nodeId, [`${el}_i2`, `${el}_i4`], `${el}_i5`),
-    `      <bpmn:endEvent id="${el}_end"><bpmn:incoming>${el}_i3</bpmn:incoming><bpmn:incoming>${el}_i5</bpmn:incoming></bpmn:endEvent>`,
-    flow(`${el}_i0`, `${el}_start`, `${el}_task`),
-    flow(`${el}_i1`, `${el}_task`, `${el}_gw`),
-    flow(`${el}_i2`, `${el}_be`, esc),
-    `      <bpmn:sequenceFlow id="${el}_i3" name="ready" sourceRef="${el}_gw" targetRef="${el}_end"><bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">=ready = true</bpmn:conditionExpression></bpmn:sequenceFlow>`,
-    `      <bpmn:sequenceFlow id="${el}_i4" name="not ready" sourceRef="${el}_gw" targetRef="${esc}" />`,
+    ...escalationTaskLines(esc, nodeId, [`${el}_i4`], `${el}_i5`),
+    `      <bpmn:endEvent id="${el}_end"><bpmn:incoming>${el}_i1</bpmn:incoming><bpmn:incoming>${el}_i5</bpmn:incoming><bpmn:incoming>${el}_i7</bpmn:incoming></bpmn:endEvent>`,
+    flow(`${el}_i0`, `${el}_start`, `${el}_probeLoop`),
+    flow(`${el}_i1`, `${el}_probeLoop`, `${el}_end`),
+    flow(`${el}_i2`, `${el}_be`, `${el}_lastAttempt`),
+    flow(`${el}_i6`, `${el}_lastAttempt`, `${el}_lastGw`),
+    `      <bpmn:sequenceFlow id="${el}_i7" name="ready" sourceRef="${el}_lastGw" targetRef="${el}_end"><bpmn:conditionExpression xsi:type="bpmn:tFormalExpression">=ready = true</bpmn:conditionExpression></bpmn:sequenceFlow>`,
+    `      <bpmn:sequenceFlow id="${el}_i4" name="not ready" sourceRef="${el}_lastGw" targetRef="${esc}" />`,
     flow(`${el}_i5`, esc, `${el}_end`),
   ];
 }

package/app/deliveryRunner.test.ts

@@ -64,6 +64,7 @@ test("nodeInputs seeds the exact per-kind fields each node's subProcess ioMappin
   const wait = byField((v) => "gateKey" in v);
   assertEquals(wait?.gateKey, "run-7:n3");
   assertEquals(wait?.probeTimeout, "PT20M");
+  assertEquals(wait?.probePollEvery, "PT15S");
   assert(wait?.probe && typeof wait.probe === "object", "the wait node carries its ReadinessProbe descriptor");
 
   const human = byField((v) => "escalationSlaTimeout" in v);

package/app/deliveryRunner.ts

@@ -17,6 +17,7 @@ import { createHash, randomUUID } from "node:crypto";
 import type { EngineClient } from "@nanobpm/urban";
 import type { DeliveryGraph, DeliveryNode } from "../nano-generated/api-io.d.ts";
 import { assertNever, compileDeliveryGraph, DELIVERY_GRAPH_PROCESS_ID } from "./deliveryGraphCompiler.ts";
+import { DEFAULT_EVERY_MS, msToIsoDuration, parseProbe, readinessPollEvery } from "./readiness.ts";
 
 /** The content digest of a compiled graph — `sha256(bpmn)[:12]` — the single source of truth for the
  * content-addressed deploy id (`delivery-graph-<digest>`) AND the S5 dispatch door's approval token /
@@ -35,6 +36,8 @@ export interface DeliveryRunTimeouts {
   probeTimeout?: string;
   /** `human` node SLA before it records an `escalated` outcome and settles. */
   escalationSlaTimeout?: string;
+  /** `wait` gate retry cadence owned by the engine. */
+  probePollEvery?: string;
   /** Optional explicit assignee for `human` nodes + escalation tasks (else candidate-group routed). */
   escalationAssignee?: string | null;
 }
@@ -51,6 +54,7 @@ export interface DeliveryRunOptions extends DeliveryRunTimeouts {
 const DEFAULTS: Required<Omit<DeliveryRunTimeouts, "escalationAssignee">> = {
   nodeTimeout: "PT30M",
   probeTimeout: "PT30M",
+  probePollEvery: msToIsoDuration(DEFAULT_EVERY_MS),
   escalationSlaTimeout: "P1D",
 };
 
@@ -59,7 +63,7 @@ const DEFAULTS: Required<Omit<DeliveryRunTimeouts, "escalationAssignee">> = {
  * silently seeds `null` into a node body), so both derive from the same node kinds. */
 type NodeInput =
   | { jobType: string; appendPrompt: string; timeout: string }
-  | { gateKey: string; probe: unknown; probeTimeout: string }
+  | { gateKey: string; probe: unknown; probeTimeout: string; probePollEvery: string }
   | { escalationSlaTimeout: string; escalationAssignee: string | null }
   | { target: string; dedupeKey: string | null; payload: Record<string, unknown> | null; timeout: string };
 
@@ -105,6 +109,7 @@ export function prepareDeliveryGraph(graph: DeliveryGraph, options: DeliveryRunO
   const timeouts = {
     nodeTimeout: options.nodeTimeout ?? DEFAULTS.nodeTimeout,
     probeTimeout: options.probeTimeout ?? DEFAULTS.probeTimeout,
+    probePollEvery: options.probePollEvery ?? DEFAULTS.probePollEvery,
     escalationSlaTimeout: options.escalationSlaTimeout ?? DEFAULTS.escalationSlaTimeout,
     escalationAssignee: options.escalationAssignee ?? null,
   };
@@ -155,13 +160,20 @@ function rewriteProcessId(bpmn: string, processDefinitionId: string): string {
  * subProcess ioMapping pulls. Total over the closed kind set. */
 function buildNodeInput(
   node: DeliveryNode,
-  ctx: { runKey: string; element: string; nodeTimeout: string; probeTimeout: string; escalationSlaTimeout: string; escalationAssignee: string | null },
+  ctx: { runKey: string; element: string; nodeTimeout: string; probeTimeout: string; probePollEvery: string; escalationSlaTimeout: string; escalationAssignee: string | null },
 ): NodeInput {
   switch (node.kind) {
     case "agent":
       return { jobType: node.agent.jobType, appendPrompt: node.agent.prompt ?? "", timeout: ctx.nodeTimeout };
-    case "wait":
-      return { gateKey: `${ctx.runKey}:${ctx.element}`, probe: node.wait, probeTimeout: ctx.probeTimeout };
+    case "wait": {
+      const probe = parseProbe(node.wait);
+      return {
+        gateKey: `${ctx.runKey}:${ctx.element}`,
+        probe: node.wait,
+        probeTimeout: ctx.probeTimeout,
+        probePollEvery: probe.poll?.everyMs ? readinessPollEvery(probe, {}) : ctx.probePollEvery,
+      };
+    }
     case "human":
       return { escalationSlaTimeout: ctx.escalationSlaTimeout, escalationAssignee: ctx.escalationAssignee };
     case "connector":

package/app/feature.test.ts

@@ -320,6 +320,7 @@ test("startFeature: no readiness ⇒ readinessProbes/probeTimeout/gateKey seeded
   const v = captured.variables;
   assertEquals(v.readinessProbes, null);
   assertEquals(v.probeTimeout, null);
+  assertEquals(v.probePollEvery, null);
   assertEquals(v.gateKey, null);
   assertEquals(v.resolvedArtifacts, null);
 });
@@ -348,11 +349,12 @@ test("startFeature: readiness probes seed the gate variables + a non-blank corre
     false,
     false,
     null,
-    { probes, probeTimeout: "PT30M" },
+    { probes, probeTimeout: "PT30M", probePollEvery: "PT15S" },
   );
   const v = captured.variables;
   assertEquals(v.readinessProbes, probes);
   assertEquals(v.probeTimeout, "PT30M");
+  assertEquals(v.probePollEvery, "PT15S");
   // The preflight probe worker requires a non-blank gateKey to publish readiness-ready on.
   assertEquals(v.gateKey, "feature-readiness:owner/repo#42");
   assertEquals(v.resolvedArtifacts, null);

package/app/feature.ts

@@ -29,6 +29,7 @@ import { deriveListBucket, deriveStage } from "./stage.ts";
 export interface FeatureReadinessOptions {
   readonly probes?: ReadinessProbe[];
   readonly probeTimeout?: string | null;
+  readonly probePollEvery?: string | null;
 }
 
 /** The BPMN process this module drives (resources/processes/feature.bpmn). */
@@ -367,6 +368,13 @@ export async function startFeature(
         "a non-blank bound. Derive it via parseFeatureReadiness before starting a gated feature.",
     );
   }
+  if (readinessProbes && (readiness.probePollEvery ?? "").trim() === "") {
+    throw new Error(
+      `startFeature(${parsed.planKey}): ${readinessProbes.length} readiness probe(s) seeded without a ` +
+        "probePollEvery — the preflight retry timers (=probePollEvery) require a non-blank cadence. " +
+        "Derive it via parseFeatureReadiness before starting a gated feature.",
+    );
+  }
   // Operator free-text steering for the implementation agent (issue #172 follow-on): blank/absent →
   // null so the implement task's `appendPrompt` FEEL (`customInstructions = null`) skips the block
   // rather than appending an empty "Operator custom instructions" heading.
@@ -487,6 +495,7 @@ export async function startFeature(
       // gate-less run still resolves the variable in that FEEL instead of raising an incident.
       readinessProbes,
       probeTimeout: readinessProbes ? (readiness.probeTimeout ?? null) : null,
+      probePollEvery: readinessProbes ? (readiness.probePollEvery ?? null) : null,
       gateKey: readinessProbes ? `feature-readiness:${parsed.planKey}` : null,
       resolvedArtifacts: null,
     },

package/app/featureReadiness.test.ts

@@ -9,12 +9,12 @@ import { test } from "node:test";
 import { assertEquals } from "#test-assert";
 import { parseFeatureReadiness } from "./featureReadiness.ts";
 
-const ENV = { NANO_READINESS_POLL_TIMEOUT: "PT30M" } as Record<string, string | undefined>;
+const ENV = { NANO_READINESS_POLL_TIMEOUT: "PT30M", NANO_READINESS_POLL_EVERY_MS: "15000" } as Record<string, string | undefined>;
 
 test("parseFeatureReadiness: no intake ⇒ empty probes, null bound (gate skipped)", () => {
-  assertEquals(parseFeatureReadiness(undefined, ENV), { probes: [], probeTimeout: null });
-  assertEquals(parseFeatureReadiness({}, ENV), { probes: [], probeTimeout: null });
-  assertEquals(parseFeatureReadiness({ readiness: [], blockedOn: [] }, ENV), { probes: [], probeTimeout: null });
+  assertEquals(parseFeatureReadiness(undefined, ENV), { probes: [], probeTimeout: null, probePollEvery: null });
+  assertEquals(parseFeatureReadiness({}, ENV), { probes: [], probeTimeout: null, probePollEvery: null });
+  assertEquals(parseFeatureReadiness({ readiness: [], blockedOn: [] }, ENV), { probes: [], probeTimeout: null, probePollEvery: null });
 });
 
 test("parseFeatureReadiness: blockedOn + consumerPackage ⇒ capability probes with derived bound", () => {
@@ -32,6 +32,7 @@ test("parseFeatureReadiness: blockedOn + consumerPackage ⇒ capability probes w
   assertEquals(out.probes[1].match?.capabilityRef, "nanobpm/nano-bpm#808");
   // Every derived probe shares the env default, so the bound is that default.
   assertEquals(out.probeTimeout, "PT30M");
+  assertEquals(out.probePollEvery, "PT15S");
 });
 
 test("parseFeatureReadiness: blockedOn without consumerPackage ⇒ command state probes (merged-is-enough)", () => {
@@ -43,6 +44,7 @@ test("parseFeatureReadiness: blockedOn without consumerPackage ⇒ command state
     onTimeout: "escalate",
   });
   assertEquals(out.probeTimeout, "PT30M");
+  assertEquals(out.probePollEvery, "PT15S");
 });
 
 test("parseFeatureReadiness: full readiness descriptors round-trip through parseProbe", () => {
@@ -82,6 +84,7 @@ test("parseFeatureReadiness: a longer per-probe budget wins the derived bound",
     ENV,
   );
   assertEquals(out.probeTimeout, "PT3600S");
+  assertEquals(out.probePollEvery, "PT15S");
 });
 
 test("parseFeatureReadiness: a bare repo#N handle is rejected (cannot name a provenance repo)", () => {

package/app/featureReadiness.ts

@@ -26,6 +26,7 @@ import {
   DEFAULT_READINESS_TIMEOUT,
   parseProbe,
   type ReadinessProbe,
+  readinessPollEvery,
   readinessTimeout,
 } from "./readiness.ts";
 import { isoDurationToMs } from "./reviewWait.ts";
@@ -47,6 +48,7 @@ export interface FeatureReadinessInput {
 export interface FeatureReadiness {
   readonly probes: ReadinessProbe[];
   readonly probeTimeout: string | null;
+  readonly probePollEvery: string | null;
 }
 
 function isNonEmptyString(v: unknown): v is string {
@@ -104,7 +106,7 @@ function desugarHandle(handle: string, consumerPackage: string | null): Readines
 }
 
 /** Parse + desugar a feature's optional intake readiness into the gate's `readinessProbes` +
- * `probeTimeout`. Accepts EITHER the full `readiness` descriptor list OR the `blockedOn` shorthand
+ * `probeTimeout`/`probePollEvery`. Accepts EITHER the full `readiness` descriptor list OR the `blockedOn` shorthand
  * (or both — they concatenate). Returns an empty probe set (gate skipped) when neither is present.
  *
  * Throws a descriptive error on a malformed descriptor (via {@link parseProbe}), a `blockedOn` entry
@@ -139,7 +141,7 @@ export function parseFeatureReadiness(
     }
   }
 
-  if (probes.length === 0) return { probes: [], probeTimeout: null };
+  if (probes.length === 0) return { probes: [], probeTimeout: null, probePollEvery: null };
 
   // One bound governs the whole preflight's escalation timers — the LONGEST of the probes' derived
   // timeouts (via the canonical `readinessTimeout`), so no probe is cut short. Mirrors the epic
@@ -147,5 +149,8 @@ export function parseFeatureReadiness(
   const probeTimeout = probes
     .map((p) => readinessTimeout(p, env))
     .reduce((a, b) => (isoDurationToMs(b, DEFAULT_READINESS_TIMEOUT) > isoDurationToMs(a, DEFAULT_READINESS_TIMEOUT) ? b : a));
-  return { probes, probeTimeout };
+  const probePollEvery = probes
+    .map((p) => readinessPollEvery(p, env))
+    .reduce((a, b) => (isoDurationToMs(b, DEFAULT_READINESS_TIMEOUT) < isoDurationToMs(a, DEFAULT_READINESS_TIMEOUT) ? b : a));
+  return { probes, probeTimeout, probePollEvery };
 }

package/app/lineage.ts

@@ -330,6 +330,31 @@ export interface LineageThreadRow {
 const lineageThreads = (data: DataLayer) =>
   data.table<LineageThreadRow>("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
+ *  `lineage_threads` (`stage`/`stage_label`/`process_key`/`pr_keys`/`pr_count`/`active`/timestamps)
+ *  and DERIVES the view-expressible identity columns (`kind`, `issue_url`, and an epic/feature
+ *  thread's `title`) from the `plans`/`feature_runs` origin joins — the single source of truth,
+ *  eliminating those columns' drift surface (epic #412). A self-rooted PR's `title` falls back to
+ *  the poller-written value, since it is a procedural representative-PR pick. */
+const lineageThreadView = (data: DataLayer) =>
+  data.table<LineageThreadRow>("lineage_thread_view", "root_request_key");
+
+/** All lineage threads off the same `lineage_thread_view` VIEW the Lineage page binds, in this
+ *  module's own active-frontier-first, then-by-key stable order (matching {@link listLineage}) —
+ *  NOT the page datasource's `orderBy: updated_at desc` + tab-specific `active` filter, which the
+ *  page applies on top of this table. Additive: this reads the derived view rather than recomputing
+ *  via {@link collectThreads}, so it reflects the identity columns' single source of truth (origin
+ *  joins) while the frontier columns come through from the still-poller-written `lineage_threads`. */
+export async function listLineageView(data: DataLayer): Promise<LineageThreadRow[]> {
+  const rows = await lineageThreadView(data).all();
+  return rows.sort(
+    (a, b) =>
+      Number(b.active) - Number(a.active) ||
+      a.root_request_key.localeCompare(b.root_request_key),
+  );
+}
+
 function toLineagePr(row: PrRow): LineagePr {
   return {
     prKey: row.pr_key,

package/app/mergesPerDayView.test.ts

@@ -0,0 +1,166 @@
+// Coverage for the merged-per-day VIEW that retires the denormalised `merges_per_day` table
+// (epic #412; the read model originally shipped in issue #344 / 051_merges_per_day.sql).
+//
+// The whole point of #412 is that this aggregate — merged-per-day throughput + burn-up + a
+// pre-formatted proportional bar — is now a derived SQL VIEW (enabled by nano-ide#424) instead of a
+// worker-written flat table, so it is a single source of truth with no drift. This test therefore
+// exercises the REAL SQLite view (062_merges_per_day_view.sql applied to an in-memory DB, mirroring
+// migration053.test.ts / planWaveSummary.test.ts) and pins that it reproduces the previous
+// projection's EXACT values: the DISTINCT-per-day count, the ascending burn-up `cumulative`, and the
+// byte-for-byte pre-formatted `bar` string the Velocity `prose` renderer draws.
+//
+// `deriveMergesPerDay` (app/mergesPerDay.ts) is the pure function the retired `pollMergesPerDay`
+// write-path used, so it is the authoritative oracle for "what the table held". We assert the view
+// equals it over sample `merges` rows. Bucketing is local-calendar-day (issue #361 — the view uses
+// `date(at, 'localtime')`, which resolves against the host zone). To keep the SQLite `localtime`
+// bucketing and the JS oracle in lockstep WITHOUT mutating the process-global `process.env.TZ`
+// (which `node --test` runs concurrently across FILES, so a `TZ` flip could leak into the
+// timezone-specific assertions in app/mergesPerDay.test.ts), we drive the oracle with the SAME host
+// zone SQLite uses by omitting its `timeZone` argument — `deriveMergesPerDay(rows)` defaults to the
+// host zone. Both sides therefore bucket identically in any host zone, so no `day` string is
+// hard-coded.
+
+import { readFileSync } from "node:fs";
+import { DatabaseSync } from "node:sqlite";
+import { test } from "node:test";
+import { fileURLToPath } from "node:url";
+import { assert, assertEquals } from "#test-assert";
+import { deriveMergesPerDay, type MergeAuditRow } from "./mergesPerDay.ts";
+
+const MIGRATION = fileURLToPath(new URL("../db/migrations/062_merges_per_day_view.sql", import.meta.url));
+
+/** A DB with the `merges` audit shape (004_merge.sql, FK-free like migration053.test.ts) + the view. */
+function viewDb(): DatabaseSync {
+  const db = new DatabaseSync(":memory:");
+  db.exec(
+    `CREATE TABLE merges (
+       id INTEGER PRIMARY KEY AUTOINCREMENT, pr_key TEXT NOT NULL, outcome TEXT NOT NULL,
+       method TEXT, detail TEXT, at TEXT NOT NULL);`,
+  );
+  db.exec(readFileSync(MIGRATION, "utf8"));
+  return db;
+}
+
+function seed(db: DatabaseSync, rows: readonly MergeAuditRow[]): void {
+  const ins = db.prepare("INSERT INTO merges (pr_key, outcome, at) VALUES (?, ?, ?)");
+  for (const r of rows) ins.run(r.pr_key, r.outcome, r.at);
+}
+
+/** The view's rows as `[day, merged, cumulative, bar]`, ordered like the Velocity page (day asc). */
+function view(db: DatabaseSync): Array<[string, number, number, string]> {
+  return (
+    db.prepare("SELECT day, merged, cumulative, bar FROM merges_per_day_view ORDER BY day").all() as Array<
+      Record<string, unknown>
+    >
+  ).map((r) => [r.day as string, Number(r.merged), Number(r.cumulative), r.bar as string]);
+}
+
+const merged = (pr_key: string, at: string): MergeAuditRow => ({ pr_key, outcome: "merged", at });
+
+test("merges_per_day_view reproduces the retired projection exactly (count, burn-up, bar)", () => {
+  const db = viewDb();
+  const rows: MergeAuditRow[] = [
+    // day A: 4 distinct PRs (the busiest day → widest bar), including a duplicate merged row.
+    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"),
+    merged("o/r#4", "2026-01-01T05:00:00Z"), // retry / already-merged short-circuit → counts once
+    // day B: 1 PR → short but visible bar.
+    merged("o/r#5", "2026-01-02T10:00:00Z"),
+    // day C: 2 PRs.
+    merged("o/r#6", "2026-01-03T10:00:00Z"),
+    merged("o/r#7", "2026-01-03T11:00:00Z"),
+    // non-merged attempts must be ignored entirely.
+    { pr_key: "o/r#8", outcome: "queued", at: "2026-01-02T12:00:00Z" },
+    { pr_key: "o/r#9", outcome: "blocked", at: "2026-01-03T12:00:00Z" },
+  ];
+  seed(db, rows);
+
+  const expected = deriveMergesPerDay(rows).map(
+    (d) => [d.day, d.merged, d.cumulative, d.bar] as [string, number, number, string],
+  );
+  assertEquals(view(db), expected);
+});
+
+test("merges_per_day_view bar: full glyph run for the busiest day, min one glyph for a lone merge", () => {
+  const db = viewDb();
+  seed(db, [
+    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"),
+    merged("o/r#5", "2026-01-02T01:00:00Z"),
+  ]);
+  const rows = view(db);
+  const [a, b] = rows;
+  assertEquals(a[3], "█".repeat(30), "the busiest day fills the configured bar width (30)");
+  assert(a[3].length > b[3].length, "the busier day draws a longer bar");
+  assert([...b[3]].length >= 1, "a day with any merge draws at least one glyph");
+  assertEquals(view(db), deriveMergesPerDay([
+    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"),
+    merged("o/r#5", "2026-01-02T01:00:00Z"),
+  ]).map((d) => [d.day, d.merged, d.cumulative, d.bar]));
+});
+
+test("merges_per_day_view is empty when no merges are recorded", () => {
+  const db = viewDb();
+  seed(db, [{ pr_key: "o/r#1", outcome: "queued", at: "2026-01-01T01:00:00Z" }]);
+  assertEquals(view(db), []);
+});
+
+test("merges_per_day_view buckets on the LOCAL calendar day, matching deriveMergesPerDay (issue #361)", () => {
+  // The view's `date(at, 'localtime')` and the oracle's default zone both resolve against the host
+  // zone, so two merges either side of a local-day boundary bucket identically on both sides — no
+  // matter which host zone the suite runs under.
+  const db = viewDb();
+  const rows: MergeAuditRow[] = [
+    merged("o/r#1", "2026-01-01T23:30:00Z"),
+    merged("o/r#2", "2026-01-02T00:30:00Z"),
+  ];
+  seed(db, rows);
+  assertEquals(view(db), deriveMergesPerDay(rows).map((d) => [d.day, d.merged, d.cumulative, d.bar]));
+});
+
+// A tiny deterministic PRNG (mulberry32) so the property check runs the SAME audit rows every time —
+// non-determinism (`Math.random()`) would make a failure impossible to reproduce (see "no flaky
+// tests" in AGENTS.md). Seeded once with a fixed constant.
+function mulberry32(seed: number): () => number {
+  let a = seed >>> 0;
+  return () => {
+    a = (a + 0x6d2b79f5) >>> 0;
+    let t = a;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+test("merges_per_day_view reproduces the projection across many random audits (property check)", () => {
+  const db = viewDb();
+  const outcomes = ["merged", "merged", "merged", "queued", "blocked"];
+  const rand = mulberry32(0x9e3779b9); // fixed seed → the same 200 trials on every run.
+  for (let trial = 0; trial < 200; trial++) {
+    db.exec("DELETE FROM merges");
+    const rows: MergeAuditRow[] = [];
+    const n = 1 + Math.floor(rand() * 40);
+    for (let i = 0; i < n; i++) {
+      const day = 1 + Math.floor(rand() * 9);
+      const hh = String(Math.floor(rand() * 24)).padStart(2, "0");
+      rows.push({
+        pr_key: `o/r#${1 + Math.floor(rand() * 12)}`,
+        outcome: outcomes[Math.floor(rand() * outcomes.length)],
+        at: `2026-01-0${day}T${hh}:00:00Z`,
+      });
+    }
+    seed(db, rows);
+    assertEquals(
+      view(db),
+      deriveMergesPerDay(rows).map((d) => [d.day, d.merged, d.cumulative, d.bar]),
+      `random trial ${trial} diverged from the projection`,
+    );
+  }
+});