@nanobpm/nano-workforce 0.135.0 → 0.137.0

package/CHANGELOG.md

@@ -1,3 +1,19 @@
+## [0.137.0](https://github.com/nanobpm/nano-workforce/compare/v0.136.0...v0.137.0) (2026-08-24)
+
+### Features
+
+* single-source plan-family read models onto @nanobpm/urban defineRollup/defineReadModel ([#493](https://github.com/nanobpm/nano-workforce/issues/493)) ([#512](https://github.com/nanobpm/nano-workforce/issues/512)) ([2837636](https://github.com/nanobpm/nano-workforce/commit/283763689cc2d0780393efe7c51b09d7c2bef767)), closes [468/#469](https://github.com/468/nano-workforce/issues/469) [#2](https://github.com/nanobpm/nano-workforce/issues/2) [#503](https://github.com/nanobpm/nano-workforce/issues/503)
+
+## [0.136.0](https://github.com/nanobpm/nano-workforce/compare/v0.135.0...v0.136.0) (2026-08-24)
+
+### Features
+
+* **delivery:** agent-node classifier-emit contract so S7 guarded branches fire ([#506](https://github.com/nanobpm/nano-workforce/issues/506)) ([#509](https://github.com/nanobpm/nano-workforce/issues/509)) ([f3acd5b](https://github.com/nanobpm/nano-workforce/commit/f3acd5bd5977fe3b12797f7d1e3acb7d5e67eb8c))
+
+### Bug Fixes
+
+* **deps:** update dependency @nanobpm/urban to ^0.82.0 ([#482](https://github.com/nanobpm/nano-workforce/issues/482)) ([81decc1](https://github.com/nanobpm/nano-workforce/commit/81decc1b8ebd53b2835aaecbb369c5347371ceb3))
+
 ## [0.135.0](https://github.com/nanobpm/nano-workforce/compare/v0.134.0...v0.135.0) (2026-08-24)
 
 ### Features

package/app/delivery.ts

@@ -3,13 +3,38 @@
 // without importing `service.ts` — which imports `pollLineage` back from `lineage.ts` and would
 // otherwise form a `service.ts` ↔ `lineage.ts` module cycle (fragile in ESM). This is the single
 // source of truth for both; `service.ts` re-uses it and remains free to import `pollLineage`.
+//
+// ADR-0065 / issue #493. `deriveDelivery`/`deriveEpicBucket`/`epicIsAcknowledgeable` are no longer
+// hand-authored oracles: they are now THIN ADAPTERS over the ONE `plan_read_model` declaration
+// (app/planReadModel.ts) and the `plan_delivery_counts` rollup (app/planRollups.ts). Each routes
+// through the framework's runtime backend — `planDeliveryCounts.reduce` (the TS group-reduce) for the
+// slice-PR counts, and `planReadModel.evaluate` (the TS derivation) for the per-row `delivery` /
+// `list_bucket` / `ack_open` signals — so these façades and the superseding SQLite VIEWs (migrations
+// 082/083) compute byte-identical values by construction, guarded by `assertReadModelParity` /
+// `assertRollupParity` (app/planReadModel.test.ts). Only the pre-formatted `label` display string is
+// still assembled here (D3 — display formatting stays out of the framework AST).
 
-/** A PR is "done" in exactly these states; everything else (converging, waiting_review,
- * escalated, and the merge-stage waiting_deps/waiting_merge/waiting_lane/queued) is in flight. `converged`
+import { TERMINAL_STATUSES } from "./deliveryStatuses.ts";
+import {
+  DELIVERY_COUNTS_LOOKUP,
+  EFFECTIVE_STATUS_COLUMN,
+  planReadModel,
+  WAVE_PROGRESS_LOOKUP,
+} from "./planReadModel.ts";
+import { PR_TRACKING_RELATION, planDeliveryCounts } from "./planRollups.ts";
+
+/** The synthetic correlation key threaded through the adapters: the base row's `plan_key` and each
+ * synthesised slice `plan_tasks`/`plan_delivery_counts` row share this value so the compiled rollup
+ * lookup / group-reduce correlate exactly as they do on real rows (mirrors app/stage.ts `SELF_KEY`). */
+const SELF_KEY = "self";
+
+/** The PR statuses that are TERMINAL for delivery — re-exported from the canonical leaf module
+ * (app/deliveryStatuses.ts) that BOTH this façade's consumers and the `plan_delivery_counts` rollup
+ * (app/planRollups.ts) read, so the SQL VIEW counts and the TS adapters can never drift. `converged`
  * is terminal only in review-only mode (AUTO_MERGE off); with auto-merge on, a converged PR
- * transitions into the merge stage and lands as `merged`. The status endpoint and the cancel
- * guard both key off this set. */
-export const TERMINAL_STATUSES: readonly string[] = ["converged", "merged", "abandoned"];
+ * transitions into the merge stage and lands as `merged`. The status endpoint and the cancel guard
+ * both key off this set. */
+export { TERMINAL_STATUSES };
 
 /** The derived epic delivery signal (issue #171). Distinct from `plan.status`: `status = done`
  * means "the fan-out finished and ≥1 slice opened a PR, dispatched to convergence" (record-results
@@ -41,38 +66,35 @@ export function deriveDelivery(
   planStatus: string,
   prStatuses: readonly string[],
 ): DeliveryRollup {
-  const prsOpened = prStatuses.length;
-  let prsMerged = 0;
-  let prsInFlight = 0;
-  for (const s of prStatuses) {
-    if (s === "merged") prsMerged++;
-    else if (!TERMINAL_STATUSES.includes(s)) prsInFlight++;
-  }
-  // `delivery` is only meaningful once the fan-out has been dispatched (`status = done`) and at
-  // least one slice PR exists; otherwise there is nothing to have landed yet.
-  if (planStatus !== "done" || prsOpened === 0) {
-    return { delivery: null, label: null, prsOpened, prsMerged, prsInFlight };
-  }
-  if (prsInFlight > 0) {
-    return {
-      delivery: "converging",
-      label: `${prsMerged}/${prsOpened} slices merged, ${prsInFlight} converging`,
-      prsOpened,
-      prsMerged,
-      prsInFlight,
-    };
-  }
-  if (prsMerged === prsOpened) {
-    return {
-      delivery: "landed",
-      label: `${prsOpened}/${prsOpened} slices merged`,
-      prsOpened,
-      prsMerged,
-      prsInFlight,
-    };
-  }
-  // Every slice PR is terminal but not all merged (some abandoned/converged): resolved, not landed.
-  return { delivery: null, label: null, prsOpened, prsMerged, prsInFlight };
+  // Lower the caller's per-slice PR statuses into the two LEAF relations the `plan_delivery_counts`
+  // rollup reduces over (`plan_tasks` LEFT JOIN `pull_requests__tracking`): one opened slice per PR
+  // status. Callers already resolve the PR's terminal-folded `derived_status` (service.ts reads it via
+  // `prsTracking`), so it is fed under the tracking relation's `derived_status` column — the SAME
+  // column the managed VIEW joins — and the framework group-reduce folds the SAME three counts
+  // (`prs_opened`/`prs_merged`/`prs_in_flight`) the VIEW does; a missing/dangling PR status counts as
+  // in-flight, never false-`landed`.
+  const taskRows = prStatuses.map((_, i) => ({ plan_key: SELF_KEY, pr_key: `pr${i}`, wave: null, status: "opened" }));
+  const prRows = prStatuses.map((s, i) => ({ pr_key: `pr${i}`, derived_status: s }));
+  const [counts] = planDeliveryCounts.reduce({ plan_tasks: taskRows, [PR_TRACKING_RELATION]: prRows });
+  const prsOpened = Number(counts?.prs_opened ?? 0);
+  const prsMerged = Number(counts?.prs_merged ?? 0);
+  const prsInFlight = Number(counts?.prs_in_flight ?? 0);
+
+  // Derive the `delivery` signal from the ONE `plan_read_model` declaration, feeding the folded counts
+  // as the `plan_delivery_counts` lookup's single candidate row (the TS twin of the VIEW's LEFT JOIN).
+  const raw = planReadModel.evaluate(
+    { plan_key: SELF_KEY, status: planStatus, [EFFECTIVE_STATUS_COLUMN]: planStatus, acknowledged_at: null },
+    undefined,
+    { [DELIVERY_COUNTS_LOOKUP]: counts ? [counts] : [], [WAVE_PROGRESS_LOOKUP]: [] },
+  ).delivery;
+  const delivery: Delivery | null = raw === "converging" || raw === "landed" ? raw : null;
+
+  // The pre-formatted human label stays hand-authored here (D3 — display formatting is out of the
+  // framework AST); it mirrors the `plan_read_model` VIEW's `delivery_label` display column (083).
+  let label: string | null = null;
+  if (delivery === "converging") label = `${prsMerged}/${prsOpened} slices merged, ${prsInFlight} converging`;
+  else if (delivery === "landed") label = `${prsOpened}/${prsOpened} slices merged`;
+  return { delivery, label, prsOpened, prsMerged, prsInFlight };
 }
 
 /** The `plan.status` values that mean the epic's fan-out lifecycle is still LIVE — the planner is
@@ -108,16 +130,8 @@ export function deriveEpicBucket(
   delivery: string | null | undefined,
   acknowledgedAt: string | null | undefined,
 ): "active" | "history" {
-  if (EPIC_LIVE_STATUSES.some((s) => s === status)) return "active";
-  if (status === "done") {
-    // A still-`converging` epic is Active regardless of any (stray) acknowledged_at — it is genuinely
-    // working and is not acknowledgeable, so it can never be ticked off mid-flight (fail-closed).
-    if (delivery === "converging") return "active";
-    // Otherwise `done` — landed or resolved-not-landed/poller-pending (`delivery = null`): stay Active
-    // until the operator dismisses it, so a just-`done` epic never flickers into History.
-    return (acknowledgedAt ?? null) === null ? "active" : "history";
-  }
-  return "history";
+  const raw = evalEpicRow(status, delivery, acknowledgedAt).list_bucket;
+  return raw === "active" ? "active" : "history";
 }
 
 /** True iff an epic carries the operator "Dismiss" (acknowledge) affordance — a `done` epic whose
@@ -133,5 +147,43 @@ export function epicIsAcknowledgeable(
   status: string,
   delivery: string | null | undefined,
 ): boolean {
-  return status === "done" && delivery !== "converging";
+  // The `ack_open` derivation folds in the `acknowledged_at IS NULL` gate; evaluate it with a null
+  // acknowledgement to isolate the "acknowledgeABLE" predicate (`done` ∧ resolved) from "ack OPEN".
+  return evalEpicRow(status, delivery, null).ack_open === 1;
+}
+
+/** Evaluate the `plan_read_model` per-row derivations (`list_bucket`/`ack_open`) for an epic whose
+ * effective status, already-computed `delivery`, and acknowledgement the caller supplies. The model
+ * recomputes `delivery` internally from its `plan_delivery_counts` lookup + base status, so — the twin
+ * of app/stage.ts's `openTaskRows` synthesis — we SYNTHESISE the lookup row + base status that make the
+ * model's internal `delivery` equal the passed value: `converging`/`landed` need a `done` base status
+ * with an in-flight / all-merged count row; a null/other `delivery` needs an empty count (`prs_opened =
+ * 0` ⇒ the model's first CASE arm ⇒ null). The status-classifying arms read the effective status under
+ * `derived_status`, so the caller's `status` is fed there verbatim. */
+function evalEpicRow(
+  status: string,
+  delivery: string | null | undefined,
+  acknowledgedAt: string | null | undefined,
+): Record<string, unknown> {
+  const merged = delivery === "landed";
+  const inFlight = delivery === "converging";
+  const opened = merged || inFlight;
+  const dcRow = {
+    plan_key: SELF_KEY,
+    prs_opened: opened ? 1 : 0,
+    prs_merged: merged ? 1 : 0,
+    prs_in_flight: inFlight ? 1 : 0,
+  };
+  return planReadModel.evaluate(
+    {
+      plan_key: SELF_KEY,
+      // Force the model's internal `delivery` to the passed value: a `done` base status enables the
+      // non-null arms for converging/landed; any status with a zero-opened count folds to null.
+      status: opened ? "done" : status,
+      [EFFECTIVE_STATUS_COLUMN]: status,
+      acknowledged_at: acknowledgedAt ?? null,
+    },
+    undefined,
+    { [DELIVERY_COUNTS_LOOKUP]: [dcRow], [WAVE_PROGRESS_LOOKUP]: [] },
+  );
 }

package/app/deliveryGraphDeploy.test.ts

@@ -277,6 +277,110 @@ test("S7 deploy+route: the green default branch SKIPS `migrate` and rides the el
   assert(r.releaseRan, "the green outcome still reaches `release` via the else-flow (proof the exclusive merge fires on one token)");
 });
 
+// ── #506: the REAL agentic-worker classifier-emit contract drives a guarded split ──────────────────
+// The S7 stubs above (`() => ({ result: outcome })`) prove the ENGINE routes on a published fact, but a
+// bare `{ result }` is NOT what a real `senior:*` fleet agent returns — it completes with the whole
+// Output-contract envelope (`{ status, summary, pr, … }`) and never a bare fact. So the gap #506 closes
+// is: (a) the node's declared `emits` must be threaded into the agent's `appendPrompt` so a real agent
+// is TOLD to surface the fact, and (b) the fact rides that SAME envelope as an extra top-level field.
+// This graph proves both against the real engine: the `adopt` node declares `emits: [result]` and is
+// serviced by a worker that (1) ASSERTS the emit contract reached it via `appendPrompt` — proving the
+// runner actually delivers the instruction, not a test stub — and (2) returns the full envelope with the
+// fact folded in, exactly as a contract-following agent would. Both branches are driven end to end.
+const GUARDED_ADOPT_REAL: DeliveryGraph = {
+  name: "adopt runbook (real agent)",
+  nodes: [
+    {
+      id: "adopt",
+      kind: "agent",
+      agent: { jobType: "senior:feature", prompt: "Adopt the published package into this consumer and open a PR." },
+      emits: [{ name: "result", type: "string", description: "breaking | compatible" }],
+    },
+    { id: "migrate", kind: "agent", agent: { jobType: "senior:migrate" } },
+    { id: "release", kind: "connector", connector: { target: "npm:publish", dedupeKey: "rel-real-1" } },
+  ],
+  edges: [
+    { from: "adopt", to: "migrate", when: "adopt.result", equals: "breaking" },
+    { from: "adopt", to: "release", default: true },
+    { from: "migrate", to: "release" },
+  ],
+};
+
+/** Drive `GUARDED_ADOPT_REAL` with a worker that behaves like a REAL contract-following `senior:feature`
+ *  agent: it reads the emit contract the runner threaded into its `appendPrompt`, then completes with the
+ *  full Output-contract envelope carrying the classifier fact as a top-level field. Returns whether the
+ *  contract actually reached the agent, plus which branches ran. */
+async function driveGuardedRealAgent(outcome: "breaking" | "compatible"): Promise<{
+  state: string;
+  contractDelivered: boolean;
+  factSurfaced: boolean;
+  migrateRan: boolean;
+  releaseRan: boolean;
+}> {
+  const engine = await createWasmEngineClient();
+  try {
+    let contractDelivered = false;
+    let factSurfaced = false;
+    let migrateRan = false;
+    let releaseRan = false;
+
+    await engine.registerWorker("senior:feature", async (job) => {
+      const appendPrompt = String((job.variables as Record<string, unknown> | undefined)?.appendPrompt ?? "");
+      // (a) The classifier emit contract MUST have reached the agent via its steering channel — this is
+      //     the #506 fix (a plain `senior:feature` seed would carry no such instruction).
+      contractDelivered =
+        appendPrompt.includes("Classifier emit contract") &&
+        appendPrompt.includes("`result`") &&
+        appendPrompt.includes("AGENT_RESULT_FILE");
+      factSurfaced = appendPrompt.includes("`result`");
+      // (b) A real agent completes with the WHOLE Output-contract envelope, folding the declared fact in
+      //     as an extra top-level field — NOT a bare `{ result }` stub.
+      return { status: "opened", summary: `adopt done (${outcome})`, pr: "owner/repo#900", result: outcome };
+    });
+    await engine.registerWorker("senior:migrate", async () => {
+      migrateRan = true;
+      return { status: "opened", summary: "migrated", pr: "owner/repo#901" };
+    });
+    await engine.registerWorker(DELIVERY_CONNECTOR_TASK_TYPE, async () => {
+      releaseRan = true;
+      return {};
+    });
+
+    const run = await runDeliveryGraph(engine, GUARDED_ADOPT_REAL);
+    assert(run.ok, `runDeliveryGraph failed: ${JSON.stringify(run)}`);
+    const key = run.handle.processInstanceKey;
+
+    let state = "?";
+    for (let round = 0; round < MAX_ROUNDS; round++) {
+      await engine.drain();
+      const [pi] = await engine.searchProcessInstances({ processInstanceKeys: [key] });
+      assert(pi, `no process instance snapshot for ${key}`);
+      state = pi.state ?? "?";
+      if (state === "COMPLETED" || state === "TERMINATED") break;
+    }
+    return { state, contractDelivered, factSurfaced, migrateRan, releaseRan };
+  } finally {
+    await engine.close();
+  }
+}
+
+test("#506 deploy+route: a REAL contract-following agent's envelope carries the classifier fact and routes the BREAKING branch through `migrate`", async () => {
+  const r = await driveGuardedRealAgent("breaking");
+  assert(r.contractDelivered, "the emit contract must reach the agent via its threaded appendPrompt (the #506 fix)");
+  assert(r.factSurfaced, "the declared fact must be named to the agent");
+  assertEquals(r.state, "COMPLETED", "the breaking branch must run to a COMPLETED instance");
+  assert(r.migrateRan, "the breaking outcome (returned inside the real Output-contract envelope) must route through `migrate`");
+  assert(r.releaseRan, "both branches must re-converge on `release`");
+});
+
+test("#506 deploy+route: the SAME real agent returning `compatible` in its envelope rides the default flow, SKIPPING `migrate`", async () => {
+  const r = await driveGuardedRealAgent("compatible");
+  assert(r.contractDelivered, "the emit contract must reach the agent via its threaded appendPrompt (the #506 fix)");
+  assertEquals(r.state, "COMPLETED", "the compatible branch must run to a COMPLETED instance");
+  assert(!r.migrateRan, "the compatible outcome must NOT route through `migrate` — the envelope's `result` rides the default flow");
+  assert(r.releaseRan, "the compatible outcome still reaches `release` via the else-flow");
+});
+
 test("S7 deploy+route: mutually-exclusive leaves join End on an exclusive merge — the untaken leaf never blocks completion", async () => {
   // Mode D: `adopt` routes a missing surface to an escalate (human) leaf, else to a `done` connector
   // leaf. On the default path the escalate leaf never fires; an exclusive End merge must still let the

package/app/deliveryRunner.test.ts

@@ -119,6 +119,39 @@ test("the human node seeds prompt/nodeId/emits; a click-done (no-emit, no-prompt
   assertEquals(ack?.nodeId, "ack");
 });
 
+test("agent node classifier-emit contract (#506): a declared `emits` threads the emit instruction into appendPrompt; a no-emit node leaves it untouched", async () => {
+  // #506: a guarded split (S7) routes on a producer's emitted scalar, published from the engine
+  // variable named exactly after the fact. A real `senior:*` agent completes with the Output-contract
+  // envelope and would never return that fact unless TOLD — so an agent node that declares `emits`
+  // must carry the emit contract in its `appendPrompt` (its only steering channel), while a plain
+  // implementation node (no emits) must be byte-for-byte unchanged.
+  const graph: DeliveryGraph = {
+    name: "classifier",
+    nodes: [
+      { id: "adopt", kind: "agent", agent: { jobType: "senior:feature", prompt: "adopt the package" }, emits: [{ name: "result", type: "string", description: "breaking | compatible" }] },
+      { id: "plain", kind: "agent", agent: { jobType: "senior:feature", prompt: "just implement it" } },
+    ],
+    edges: [{ from: "adopt.result", to: "plain", when: "adopt.result", equals: "breaking" }, { from: "adopt", to: "plain", default: true }],
+  };
+  const p = await prepareOk(graph);
+  const agents = Object.values(p.nodeInputs).filter((v) => "jobType" in v) as Array<Record<string, unknown>>;
+  const adopt = agents.find((v) => String(v.appendPrompt).startsWith("adopt the package"));
+  const plain = agents.find((v) => String(v.appendPrompt).startsWith("just implement it"));
+
+  // The emit-declaring node keeps its authored prompt AND gains the emit contract naming its fact.
+  assert(adopt, "the emit-declaring agent node must be seeded");
+  const adoptPrompt = String(adopt?.appendPrompt);
+  assert(adoptPrompt.startsWith("adopt the package"), "the authored prompt is preserved as the prefix");
+  assert(adoptPrompt.includes("Classifier emit contract"), `the emit contract must be threaded in, got: ${adoptPrompt}`);
+  assert(adoptPrompt.includes("`result`") && adoptPrompt.includes("(string)"), "the declared fact name + type must be surfaced to the agent");
+  assert(adoptPrompt.includes("breaking | compatible"), "the fact's optional description rides the contract");
+  assert(adoptPrompt.includes("AGENT_RESULT_FILE"), "the contract names the completion channel the fact rides");
+
+  // A node that declares NO facts is untouched — appendPrompt is exactly the authored prompt.
+  assertEquals(plain?.appendPrompt, "just implement it");
+});
+
+
 test("wait gateKeys default to a fresh per-run token so concurrent runs of one graph never cross-correlate", async () => {
   const gateKeyOf = (p: Awaited<ReturnType<typeof prepareOk>>) =>
     (Object.values(p.nodeInputs).find((v) => "gateKey" in v) as { gateKey?: string } | undefined)?.gateKey;

package/app/deliveryRunner.ts

@@ -170,6 +170,39 @@ function rewriteProcessId(bpmn: string, processDefinitionId: string): string {
     .replace(`bpmnElement="${DELIVERY_GRAPH_PROCESS_ID}"`, `bpmnElement="${processDefinitionId}"`);
 }
 
+/** Render the classifier-emit contract appended to an `agent` node's `appendPrompt` (issue #506) — the
+ * instruction that turns a declared `emits[]` into completion variables a downstream guarded split (S7)
+ * can route on. A `senior:*` fleet agent completes with the Output-contract envelope (`status`,
+ * `summary`, `pr`, …); the delivery output ioMapping instead publishes the engine variable named exactly
+ * after each fact (`factSourceVar` → `fact.name`), so the agent must ALSO return each declared fact as a
+ * TOP-LEVEL field of that same result JSON. This block tells it so, deriving entirely from the node's
+ * declared `emits` (no second source of truth). Empty for a no-emit node → the prompt is unchanged, so a
+ * plain implementation node behaves exactly as before. Deterministic: fixed wording, facts in declared
+ * order, so identical graphs still compile+seed byte-identically. */
+export function renderEmitContract(emits: readonly DeliveryFact[]): string {
+  if (emits.length === 0) return "";
+  const facts = emits.map((f) => `- \`${f.name}\` (${f.type})${f.description ? ` — ${f.description}` : ""}`);
+  return [
+    "",
+    "",
+    "---",
+    "",
+    "## Classifier emit contract (delivery graph)",
+    "",
+    "This node is a PRODUCER in a delivery graph: a downstream **guarded split** routes on the typed",
+    "fact(s) below. In ADDITION to your normal result fields (`status`, `summary`, `pr`, …), the",
+    "structured result you write to `AGENT_RESULT_FILE` MUST include these TOP-LEVEL fields, each a",
+    "bare scalar of the declared type:",
+    "",
+    ...facts,
+    "",
+    "The value you return for each fact IS the routing decision — a downstream edge fires only when the",
+    "fact equals a specific literal, otherwise the graph takes the `default` (else) branch. If you",
+    "genuinely cannot determine a fact, OMIT it (the default branch is taken) rather than guessing.",
+  ].join("\n");
+}
+
+
 /** Build the `nodeInputs.<element>` seed for one node, per its kind — the exact fields the compiled
  * subProcess ioMapping pulls. Total over the closed kind set. */
 function buildNodeInput(
@@ -177,8 +210,21 @@ function buildNodeInput(
   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: isoDuration(node.agent.timeout, ctx.nodeTimeout) };
+    case "agent": {
+      // Classifier-emit contract (issue #506). A `senior:*` fleet agent's real completion is the
+      // Output-contract envelope (`{ status, summary, pr, … }`) — it does NOT return a bare fact, so a
+      // node's declared `emits` would never appear and a downstream GUARDED split (S7) could only ever
+      // take its `default` branch. Close the gap the same way `factSourceVar` already reads it: the
+      // output ioMapping publishes the engine variable named exactly after each fact, so the agent must
+      // return `{ <fact>: <value> }` AS A TOP-LEVEL field of its result JSON (the same channel that
+      // carries `status`/`summary`/`pr`). The agent only knows to do this if it is TOLD — so the
+      // declared emits are rendered into the node's `appendPrompt` (its sole steering channel; the
+      // delivery agent node carries no base-prompt resource), keeping `emits` the single source of
+      // truth. A no-emit node appends nothing, so a plain implementation node is unchanged.
+      const basePrompt = node.agent.prompt ?? "";
+      const emits = Array.isArray(node.emits) ? node.emits.map((f) => ({ ...f })) : [];
+      return { jobType: node.agent.jobType, appendPrompt: basePrompt + renderEmitContract(emits), timeout: isoDuration(node.agent.timeout, ctx.nodeTimeout) };
+    }
     case "wait": {
       const probe = parseProbe(node.wait);
       return {

package/app/deliveryStatuses.ts

@@ -0,0 +1,13 @@
+// The PR statuses that are TERMINAL for epic delivery — a slice PR in any of these is resolved (not
+// in flight). This is the ONE canonical set, factored into a dependency-neutral leaf module (imports
+// nothing) so BOTH sides of the single-sourced delivery derivation read the SAME value and can never
+// drift: the runtime adapters + consumers via `app/delivery.ts` (which re-exports it as
+// `TERMINAL_STATUSES`), and the `plan_delivery_counts` / `plan_wave_counts` rollups' in-flight fold via
+// `app/planRollups.ts`. Adding or removing a terminal state here changes both the SQL VIEW counts and
+// the TS reduce at once.
+//
+// `converged` is terminal only in review-only mode (AUTO_MERGE off); with auto-merge on, a converged PR
+// transitions into the merge stage and lands as `merged`. `merged` is the landed state; `abandoned` is
+// the resolved-not-landed state. Everything else (converging, waiting_review, escalated, and the
+// merge-stage waiting_deps/waiting_merge/waiting_lane/queued) is in flight.
+export const TERMINAL_STATUSES: readonly string[] = ["converged", "merged", "abandoned"];