@nanobpm/nano-workforce 0.131.1 → 0.133.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [0.133.0](https://github.com/nanobpm/nano-workforce/compare/v0.132.0...v0.133.0) (2026-08-24)
+
+### Features
+
+* **delivery-graph:** connector `converge`/`converge-merge` target enrolls a PR via submitPr (retire the manual land gate) ([#501](https://github.com/nanobpm/nano-workforce/issues/501)) ([a24562e](https://github.com/nanobpm/nano-workforce/commit/a24562eb12db8e6f81e6f382e94886a537f16378)), closes [#500](https://github.com/nanobpm/nano-workforce/issues/500)
+
+## [0.132.0](https://github.com/nanobpm/nano-workforce/compare/v0.131.1...v0.132.0) (2026-08-24)
+
+### Features
+
+* **lineage:** surface delivery-graph runs as fan-in parent threads ([#504](https://github.com/nanobpm/nano-workforce/issues/504)) ([c62b925](https://github.com/nanobpm/nano-workforce/commit/c62b92556dd8ec21f42bc70ca4eba5455e448343)), closes [#498](https://github.com/nanobpm/nano-workforce/issues/498) [#498](https://github.com/nanobpm/nano-workforce/issues/498)
+
 ## [0.131.1](https://github.com/nanobpm/nano-workforce/compare/v0.131.0...v0.131.1) (2026-08-24)
 
 ### Bug Fixes

package/app/deliveryConnector.test.ts

@@ -15,10 +15,14 @@ import { join, resolve } from "node:path";
 import type { DataLayer } from "@nanobpm/urban";
 import { bootTestApp, type TestApp } from "@nanobpm/urban-testkit";
 import {
+  CONVERGE_MERGE_TARGET,
+  CONVERGE_TARGET,
   connectorDedupeKey,
+  convergeOnlyForTarget,
   type DeliveryConnectorDispatchRow,
   deliveryConnectorDispatches,
   dispatchConnector,
+  isConvergeTarget,
 } from "./deliveryConnector.ts";
 
 const APP_ROOT = resolve(import.meta.dirname, "..");
@@ -84,6 +88,21 @@ test("connectorDedupeKey: author key wins; else derives <processInstanceKey>:<el
   assertEquals(connectorDedupeKey({ processInstanceKey: 12345, elementId: "n3" }), "12345:n3");
 });
 
+test("converge targets: `converge`/`converge-merge` are the enrollment targets; `converge` is review-only", () => {
+  assertEquals(CONVERGE_TARGET, "converge");
+  assertEquals(CONVERGE_MERGE_TARGET, "converge-merge");
+  // Only the two converge literals route into `submitPr`; any other target stays a stub dispatch.
+  assert(isConvergeTarget("converge"));
+  assert(isConvergeTarget("converge-merge"));
+  assert(!isConvergeTarget("slack"));
+  assert(!isConvergeTarget("Converge"));
+  assert(!isConvergeTarget(""));
+  // `convergeOnly` default maps onto `submitPr`'s arg: `converge` stops at converged (true),
+  // `converge-merge` drives the merge loop (false) — mirroring converge-feature's autoMerge inversion.
+  assertEquals(convergeOnlyForTarget("converge"), true);
+  assertEquals(convergeOnlyForTarget("converge-merge"), false);
+});
+
 test("first dispatch delivers exactly once; a redelivery on the same key dedupes and never re-acts", async () => {
   await withApp(async (app) => {
     const at = "2025-01-01T00:00:00.000Z";

package/app/deliveryConnector.ts

@@ -33,6 +33,33 @@ export const DELIVERY_CONNECTOR_TASK_TYPE = "pr.delivery-connector";
 export const OUTCOME_CLAIMED = "claimed";
 export const OUTCOME_DELIVERED = "delivered";
 
+/** The two connector `target`s that enroll an agent-opened PR into the app's SHARED convergence /
+ * merge doors via `submitPr` (issue #500) — the delivery-graph side of the exact seam the feature
+ * cell reuses (`workers/converge-feature`), no duplicated machinery. `converge-merge` drives review
+ * convergence AND the merge loop; `converge` stops at `converged` (converge-only). This is the "real
+ * target dispatch" ADR 0005 deferred as a later slice for the connector I/O surface: a `converge`/
+ * `converge-merge` connector IS the "automated, side-effecting outbound action" a connector is
+ * defined to be. Named constants so the worker's dispatch branch and the docs/preview can never drift
+ * on the literal. */
+export const CONVERGE_TARGET = "converge";
+export const CONVERGE_MERGE_TARGET = "converge-merge";
+
+/** Is `target` one of the converge-enrollment targets (`converge` / `converge-merge`)? The single
+ * predicate the worker branches on to route a dispatch into `submitPr` instead of the forward-declared
+ * stub. */
+export function isConvergeTarget(target: string): boolean {
+  return target === CONVERGE_TARGET || target === CONVERGE_MERGE_TARGET;
+}
+
+/** The DEFAULT `convergeOnly` for a converge target: `converge` is review-only (`true` — stop at
+ * `converged`), `converge-merge` drives the merge loop too (`false`). Maps directly onto `submitPr`'s
+ * `convergeOnly` argument (mirroring how `converge-feature` inverts `autoMerge`). An author may still
+ * override it per-dispatch via the connector payload's `convergeOnly`. Only ever consulted behind
+ * `isConvergeTarget`, so a non-converge target's `false` is unreachable. */
+export function convergeOnlyForTarget(target: string): boolean {
+  return target === CONVERGE_TARGET;
+}
+
 /** One durable dispatch-claim row — the at-most-once ledger entry a connector writes before it acts. */
 export interface DeliveryConnectorDispatchRow extends Record<string, unknown> {
   id?: number;
@@ -77,16 +104,27 @@ export function connectorDedupeKey(input: {
   return null;
 }
 
-/** The forward-declared connector I/O surface (ADR non-goal — the concrete scheme is deferred). A STUB
- * that "performs" the action by returning a deterministic acknowledgement; a later slice replaces the
- * body with the real transport without touching the idempotency envelope around it. */
-function performConnectorAction(_input: {
+/** The side effect a connector dispatch performs EXACTLY ONCE per dedupe key. It runs only on the claim
+ * winner (or a resumed crashed claim), never on a `deduped` settled redelivery, so a real, non-idempotent
+ * side effect (e.g. `submitPr`, which deliberately re-opens a TERMINAL PR) is fenced by the ledger and
+ * can never double-fire — the reason the enrollment lives HERE rather than unconditionally around the
+ * dispatch. Returns the `detail` recorded on the ledger row. May be async (the real converge enrollment
+ * awaits `submitPr`). Must be idempotent so a resumed crashed claim can safely re-perform it — including
+ * terminal-safe against a NON-idempotent target (the converge action no-ops when its PR already settled,
+ * so a resume can never regress a terminal PR by re-opening it). */
+export type ConnectorAction = (input: {
   target: string;
   payload: Record<string, unknown> | null;
   boundFacts: readonly BoundFact[];
-}): { detail: string } {
+}) => { detail: string } | Promise<{ detail: string }>;
+
+/** The forward-declared connector I/O surface (ADR non-goal — the concrete scheme is deferred). The
+ * DEFAULT `ConnectorAction`: a STUB that "performs" the action by returning a deterministic
+ * acknowledgement; a caller with a real side effect (the converge worker's `submitPr` enrollment) injects
+ * its own action into `dispatchConnector` instead, without touching the idempotency envelope around it. */
+const performConnectorAction: ConnectorAction = (_input) => {
   return { detail: "connector stub — I/O surface forward-declared (ADR 0005 non-goal)" };
-}
+};
 
 /** The result of one connector dispatch attempt. `delivered` — the claim was won and the action fired
  * exactly once; `deduped` — the key was already claimed (an at-least-once redelivery), so the recorded
@@ -107,13 +145,14 @@ async function resumeOrDedupe(
   ledger: ReturnType<typeof deliveryConnectorDispatches>,
   row: DeliveryConnectorDispatchRow,
   input: { dedupeKey: string; target: string; payload?: Record<string, unknown> | null; boundFacts?: readonly BoundFact[] | null },
+  perform: ConnectorAction,
 ): Promise<ConnectorDispatchResult> {
   if (row.outcome === OUTCOME_DELIVERED) {
     return { connectorOutcome: "deduped", connectorDedupeKey: input.dedupeKey, connectorDetail: row.detail ?? "" };
   }
   // Still `claimed` — a prior attempt (sequential or the concurrent-race winner) claimed the key but
   // never recorded delivery. Resume on the existing row rather than dedupe forever on an un-acted claim.
-  const { detail } = performConnectorAction({
+  const { detail } = await perform({
     target: input.target,
     payload: input.payload ?? null,
     boundFacts: input.boundFacts ?? [],
@@ -149,6 +188,7 @@ export async function dispatchConnector(
   data: DataLayer,
   input: { dedupeKey: string; target: string; payload?: Record<string, unknown> | null; boundFacts?: readonly BoundFact[] | null },
   at: string,
+  perform: ConnectorAction = performConnectorAction,
 ): Promise<ConnectorDispatchResult> {
   const ledger = deliveryConnectorDispatches(data);
   const existing = await ledger.findOne({ dedupe_key: input.dedupeKey });
@@ -167,7 +207,7 @@ export async function dispatchConnector(
   if (existing) {
     // A prior attempt recorded (`delivered`) or claimed-but-crashed (`claimed`) this key. Dedupe or
     // resume it on the existing row — the ONE decision shared with the fence-loser path below.
-    return resumeOrDedupe(ledger, existing, input);
+    return resumeOrDedupe(ledger, existing, input, perform);
   }
   let claimId: number | bigint;
   try {
@@ -196,11 +236,11 @@ export async function dispatchConnector(
     // as the sequential path. Deduping a still-`claimed` winner here would complete the job on our ack,
     // so a winner that then crashed would strand the side effect forever (the engine won't redeliver an
     // acked job); resuming closes that gap and is safe because the action is idempotent.
-    if (won) return resumeOrDedupe(ledger, won, input);
+    if (won) return resumeOrDedupe(ledger, won, input, perform);
     return { connectorOutcome: "deduped", connectorDedupeKey: input.dedupeKey, connectorDetail: "" };
   }
   // We alone won the claim — perform the side effect exactly once and record its outcome on our row.
-  const { detail } = performConnectorAction({
+  const { detail } = await perform({
     target: input.target,
     payload: input.payload ?? null,
     boundFacts: input.boundFacts ?? [],

package/app/deliveryGraphCompiler.test.ts

@@ -280,6 +280,29 @@ test("sideEffects: agent + connector only; connector carries its dedupeKey", asy
   assert(!r.sideEffects.some((s) => s.nodeId === "publish"));
 });
 
+test("converge-merge worked graph: agent → connector[converge-merge] → wait[pr,merged] compiles with NO human node (retires the manual land gate, #500)", async () => {
+  const graph = {
+    name: "open → converge+merge → wait merged",
+    nodes: [
+      { id: "open", kind: "agent", agent: { jobType: "senior:feature", prompt: "Implement the change and open a PR." } },
+      { id: "land", kind: "connector", connector: { target: "converge-merge", payload: { pr: "acme/repo#123" } } },
+      { id: "merged", kind: "wait", wait: { kind: "pr", target: "acme/repo#123", match: { prState: "merged" }, onTimeout: "escalate" } },
+    ],
+    edges: [
+      { from: "open", to: "land" },
+      { from: "land", to: "merged" },
+    ],
+  };
+  const r = await compileOk(graph);
+  // The canonical shape has NO human land-* gate — convergence is driven by the connector itself.
+  assertEquals(r.humanNodes.length, 0, "no human node bridges the PR to convergence");
+  // The connector is a side effect, naming its converge-merge target; the wait gate is read-only.
+  const connector = r.sideEffects.find((s) => s.nodeId === "land");
+  assertEquals(connector?.kind, "connector");
+  assert(connector?.description.includes("converge-merge"), "the side-effect names the converge-merge target");
+  assert(!r.sideEffects.some((s) => s.nodeId === "merged"), "the wait gate is not a side effect");
+});
+
 test("resolved edges carry the resolved fromNode and the referenced fact", async () => {
   const r = await compileOk(RELEASE_RUNBOOK);
   const factEdge = r.resolved.edges.find((e) => e.from === "watch-b.mergedSha");

package/app/lineage.test.ts

@@ -131,6 +131,91 @@ test("feature/self-rooted threads carry no epic phase label", () => {
   assertEquals(self.epicPhaseLabel, null, "a self-rooted PR is not an epic slice");
 });
 
+// ── delivery-graph fan-in parent (issue #498) ─────────────────────────────────────────────────
+
+test("delivery: a running run with no PR yet is implementing, frontier from its phase", () => {
+  const t = deriveLineage(
+    { kind: "delivery", key: "dg-abc", title: "Ship widget", status: "running", phase: "Running", processKey: "d1" },
+    [],
+  );
+  assertEquals(t.kind, "delivery");
+  assertEquals(t.rootRequestKey, "dg-abc");
+  assertEquals(t.stage, "implementing");
+  assertEquals(t.stageLabel, "Running", "the frontier reflects the run's derived phase");
+  assert(t.active, "a running run is active");
+  assertEquals(t.processKey, "d1");
+  assertEquals(t.title, "Ship widget");
+  assertEquals(t.issueUrl, null, "a delivery run is keyed by run_key, not a GitHub issue");
+  assertEquals(t.epicPhaseLabel, null, "a delivery run's member PRs are not epic slices");
+  assertEquals(t.prCount, 0);
+});
+
+test("delivery: downstream PR convergences nest under the run and temper the frontier to converging", () => {
+  const t = deriveLineage(
+    { kind: "delivery", key: "dg-abc", title: "Ship widget", status: "running", phase: "Parked on human node: publish", processKey: "d1" },
+    [
+      pr({ prKey: "a/b#1", status: "merged" }),
+      pr({ prKey: "c/d#9", status: "converging", processKey: "c9" }),
+    ],
+  );
+  assertEquals(t.kind, "delivery");
+  assertEquals(t.stage, "converging", "a member PR still in flight tempers the frontier to converging");
+  assertEquals(t.stageLabel, "Parked on human node: publish", "the label still prefers the run's stamped phase");
+  assertEquals(t.processKey, "c9", "frontier prefers the in-flight member PR's instance");
+  assertEquals(t.prKeys, ["a/b#1", "c/d#9"], "heterogeneous downstream PRs across repos nest under the run");
+  assert(t.active);
+});
+
+test("delivery: a done run settles as resolved (no active frontier)", () => {
+  const t = deriveLineage(
+    { kind: "delivery", key: "dg-abc", title: "Ship widget", status: "done", phase: "Completed", processKey: "d1" },
+    [pr({ prKey: "a/b#1", status: "merged" })],
+  );
+  assertEquals(t.stage, "resolved");
+  assertEquals(t.stageLabel, "Completed");
+  assert(!t.active, "a completed run has no active frontier");
+});
+
+test("delivery: a failed run settles as abandoned", () => {
+  const t = deriveLineage(
+    { kind: "delivery", key: "dg-abc", title: "Ship widget", status: "failed", phase: "Failed", processKey: "d1" },
+    [],
+  );
+  assertEquals(t.stage, "abandoned");
+  assert(!t.active);
+});
+
+test("delivery: an abandoned run with no phase is labeled 'Abandoned', not 'Failed'", () => {
+  // `deliveryOriginStage` folds both `failed` and `abandoned` statuses onto the `abandoned` stage, so
+  // the label must consult the run status: a genuinely abandoned run reads "Abandoned" (only a failed
+  // one reads "Failed"). Regress with no stamped phase so the status-derived fallback label is used.
+  const t = deriveLineage(
+    { kind: "delivery", key: "dg-abc", title: "Ship widget", status: "abandoned", phase: null, processKey: "d1" },
+    [],
+  );
+  assertEquals(t.stage, "abandoned");
+  assertEquals(t.stageLabel, "Abandoned", "an abandoned run is not mislabeled as failed");
+  assert(!t.active);
+});
+
+test("delivery: a failed run with no phase is labeled 'Failed'", () => {
+  const t = deriveLineage(
+    { kind: "delivery", key: "dg-abc", title: "Ship widget", status: "failed", phase: null, processKey: "d1" },
+    [],
+  );
+  assertEquals(t.stage, "abandoned");
+  assertEquals(t.stageLabel, "Failed");
+});
+
+test("delivery: with no stamped phase, the frontier falls back to a status-derived label", () => {
+  const t = deriveLineage(
+    { kind: "delivery", key: "dg-abc", title: "Ship widget", status: "running", phase: null, processKey: "d1" },
+    [],
+  );
+  assertEquals(t.stage, "implementing");
+  assertEquals(t.stageLabel, "Running", "null phase falls back to the status-derived frontier label");
+});
+
 // ── self-rooted (human/webhook) PR ───────────────────────────────────────────────────────────
 
 test("pr: a human/webhook PR with no origin is its own root", () => {
@@ -237,6 +322,67 @@ test("pollLineage: projects feature, epic, and self-rooted threads onto lineage_
   assertEquals(after, before, "steady-state pass is a no-op");
 });
 
+test("pollLineage: projects a delivery-graph run as a fan-in parent thread with its downstream PRs nested", async () => {
+  // Issue #498: a dispatched delivery-graph run appears as its own thread, and the downstream PR
+  // convergences threaded to it (root_request_key = run_key) across DIFFERENT repos nest under it
+  // rather than appearing as disconnected self-rooted PRs.
+  const { data, stores } = memData();
+  stores.feature_runs = [];
+  stores.plans = [];
+  stores.plan_tasks = [];
+  stores.delivery_graph_runs = [
+    { run_key: "dg-xyz", title: "Ship widget across repos", status: "running", phase: "Running", process_key: "P-dg" },
+  ];
+  stores.pull_requests = [
+    { pr_key: "a/b#1", title: "widget in a/b", url: "x", status: "merged", current_round: 1, process_key: "c1", outcome: null, root_request_key: "dg-xyz" },
+    { pr_key: "c/d#9", title: "widget in c/d", url: "x", status: "converging", current_round: 2, process_key: "c2", outcome: null, root_request_key: "dg-xyz" },
+  ];
+
+  await pollLineage(data);
+
+  const threads: LineageThreadRow[] = stores.lineage_threads;
+  assertEquals(threads.length, 1, "one delivery thread, not two disconnected self-rooted PRs");
+  const dg = threads.find((t) => t.root_request_key === "dg-xyz");
+  assert(dg, "delivery thread present, keyed on run_key");
+  // A member PR still converging tempers the frontier to converging; the label prefers the run phase.
+  assertEquals(dg?.stage, "converging");
+  assertEquals(dg?.stage_label, "Running");
+  assertEquals(dg?.active, 1);
+  assertEquals(dg?.pr_count, 2);
+  assertEquals(JSON.parse(dg?.pr_keys ?? "[]").sort(), ["a/b#1", "c/d#9"]);
+  // A delivery run's member PRs are not epic slices, so no epic phase label is projected onto them.
+  const prById = (k: string) => stores.pull_requests.find((r: any) => r.pr_key === k);
+  assertEquals(prById("a/b#1").epic_phase_label ?? null, null);
+  assertEquals(prById("c/d#9").epic_phase_label ?? null, null);
+});
+
+test("pollLineage: a delivery run_key colliding with a feature key does not overwrite the feature thread", async () => {
+  // The SQL view (migration 079) classifies epic > feature > delivery, so a `delivery_graph_runs.run_key`
+  // that equals an existing `feature_key`/`plan_key` must NOT clobber that earlier thread — otherwise the
+  // poller would stamp delivery-derived frontier columns onto a row the view still classifies feature/epic,
+  // and the two projections drift. The colliding run is skipped; feature precedence is preserved.
+  const { data, stores } = memData();
+  stores.feature_runs = [
+    { feature_key: "o/r#7", title: "Feature seven", issue_url: "u7", status: "converging", process_key: "f7", pr_key: "o/r#700" },
+  ];
+  stores.plans = [];
+  stores.plan_tasks = [];
+  stores.delivery_graph_runs = [
+    { run_key: "o/r#7", title: "Colliding run", status: "running", phase: "Running", process_key: "P-dup" },
+  ];
+  stores.pull_requests = [
+    { pr_key: "o/r#700", title: "Feat PR", url: "x", status: "converging", current_round: 2, process_key: "c1", outcome: null, root_request_key: "o/r#7" },
+  ];
+
+  await pollLineage(data);
+
+  const threads: LineageThreadRow[] = stores.lineage_threads;
+  assertEquals(threads.length, 1, "the colliding run does not create a second row for the same key");
+  const t = threads.find((r) => r.root_request_key === "o/r#7");
+  assert(t, "the single thread for the shared key is the feature thread");
+  assertEquals(t?.stage_label, "Converging (round 2)", "feature frontier wins; the delivery run did not overwrite it");
+});
+
 test("pollLineage: a self-rooted PR row (root_request_key === pr_key) projects exactly one thread keyed on its pr_key", async () => {
   // Regression (#245): submitPr now self-roots a human/webhook PR on its own `pr_key` (rather than
   // NULL) so the Lineage page's `lineage_threads.root_request_key → pull_requests.root_request_key`

package/app/lineage.ts

@@ -20,14 +20,15 @@
 // `pr_key` (kind `pr`), and also tolerates a legacy NULL `root_request_key` the same way.
 import type { DataLayer } from "@nanobpm/urban";
 import { deriveDelivery, TERMINAL_STATUSES } from "./delivery.ts";
+import { type DeliveryGraphRun, deliveryGraphRuns } from "./deliveryGraphRun.ts";
 import { type FeatureRun, featureRuns } from "./feature.ts";
 import { derivedTrackingTable } from "./instanceTracking.ts";
 import { type Plan, type PlanTask, plans, planTasks } from "./plan.ts";
 
 const now = () => new Date().toISOString();
 
-/** The three origin shapes a lineage arc can spring from. */
-export type LineageKind = "feature" | "epic" | "pr";
+/** The origin shapes a lineage arc can spring from. */
+export type LineageKind = "feature" | "epic" | "pr" | "delivery";
 
 /** A member PR of a lineage thread — the subset of `pull_requests` the projection reads. */
 export interface LineagePr {
@@ -66,6 +67,23 @@ export type LineageOrigin =
       // A human/webhook PR with no originating request: its own root.
       kind: "pr";
       key: string;
+    }
+  | {
+      // A delivery-graph run (issue #498): a FAN-IN parent thread. The run is the thread root, and
+      // the heterogeneous downstream tasks it spawns — PR convergences across different repos/issue
+      // numbers, package publishes, human gates — nest under it (they thread `root_request_key =
+      // run_key`, mirroring how `submitPr` threads feature/epic roots). Closer to an epic than a
+      // single-PR arc.
+      kind: "delivery";
+      key: string;
+      title: string | null;
+      status: string;
+      // The run's already-derived display phase (`delivery_graph_runs.phase`, recomputed by
+      // `pollDeliveryGraphPhase` from engine truth — generalised from `epic_phase`), e.g. "Running",
+      // "Parked on human node: manual OTP publish", "Completed". NULL until the poller stamps one; the
+      // thread then falls back to a status-derived frontier label.
+      phase: string | null;
+      processKey: string | null;
     };
 
 /** One stitched arc: `request → implementation → PR(s) → convergence → merge → outcome`. */
@@ -241,6 +259,18 @@ export function deriveLineage(origin: LineageOrigin, prsIn: readonly LineagePr[]
       stageLabel = featureStageLabel(stage);
       processKey = origin.processKey ?? rep?.processKey ?? null;
     }
+  } else if (origin.kind === "delivery") {
+    // Fan-in parent (issue #498): the delivery-graph RUN is the thread root; its heterogeneous
+    // downstream PR convergences (across different repos/issues) nest under it. Unlike an epic's
+    // slice rollup, a run's narrative is "where is the run" — so the frontier reflects the run's OWN
+    // derived phase (`delivery_graph_runs.phase`), with member PRs shown as nested children. The
+    // machine `stage` is derived from the run status (tempered to `converging` while a member PR is
+    // still in flight); the human `stageLabel` prefers the run's stamped phase, else a status label.
+    stage = deliveryOriginStage(origin.status, prs);
+    stageLabel = origin.phase ?? deliveryStageLabel(stage, origin.status);
+    // Active-frontier instance: an in-flight member PR's process, else the run's own.
+    const activePr = prs.find((p) => !TERMINAL_STATUSES.includes(p.status));
+    processKey = activePr?.processKey ?? origin.processKey ?? rep?.processKey ?? null;
   } else {
     // Self-rooted PR (human/webhook): the PR IS the whole arc.
     stage = rep ? prStage(rep.status) : "converging";
@@ -259,7 +289,9 @@ export function deriveLineage(origin: LineageOrigin, prsIn: readonly LineagePr[]
     rootRequestKey: origin.key,
     kind: origin.kind,
     title: origin.kind === "pr" ? (rep?.title ?? null) : origin.title,
-    issueUrl: origin.kind === "pr" ? null : origin.issueUrl,
+    // Only feature/epic threads root on a GitHub issue; a self-rooted PR and a delivery-graph run
+    // (issue #498, keyed by `run_key`) have none.
+    issueUrl: origin.kind === "feature" || origin.kind === "epic" ? origin.issueUrl : null,
     stage,
     stageLabel,
     epicPhaseLabel,
@@ -293,6 +325,45 @@ function featureStageLabel(stage: LineageStage): string {
   }
 }
 
+/** Map a delivery-graph run's lifecycle status onto a frontier stage (issue #498). A `running` run
+ * with a member PR still in flight reads as `converging` (the fan-in is landing PRs); otherwise it is
+ * `implementing`. Terminal run statuses settle: `done` → `resolved` (the run completed), `failed` /
+ * `abandoned` → `abandoned`. `awaiting-approval` (reserved, no longer produced) parks at `planning`. */
+function deliveryOriginStage(status: string, prs: readonly LineagePr[]): LineageStage {
+  switch (status) {
+    case "awaiting-approval":
+      return "planning";
+    case "running":
+      return prs.some((p) => !TERMINAL_STATUSES.includes(p.status)) ? "converging" : "implementing";
+    case "done":
+      return "resolved";
+    case "failed":
+    case "abandoned":
+      return "abandoned";
+    default:
+      return "implementing";
+  }
+}
+
+/** The fallback frontier label for a delivery thread when the run has not stamped a `phase` yet.
+ * `deliveryOriginStage` folds both the `failed` and `abandoned` run statuses onto the terminal
+ * `abandoned` stage, so the stage alone cannot tell them apart — take the run `status` too and label a
+ * genuinely `abandoned` run "Abandoned" (only a `failed` run reads "Failed"). */
+function deliveryStageLabel(stage: LineageStage, status: string): string {
+  switch (stage) {
+    case "planning":
+      return "Awaiting approval";
+    case "converging":
+      return "Converging";
+    case "resolved":
+      return "Completed";
+    case "abandoned":
+      return status === "abandoned" ? "Abandoned" : "Failed";
+    default:
+      return "Running";
+  }
+}
+
 // ── gateway glue ───────────────────────────────────────────────────────────────────────────────
 
 /** The subset of `pull_requests` the lineage projection reads. */
@@ -450,6 +521,21 @@ async function collectThreads(
     threads.set(plan.plan_key, deriveLineage(epicOrigin(plan), prs.map(toLineagePr)));
   }
 
+  // Delivery-graph runs (issue #498): each run is a fan-in parent thread keyed on its `run_key`,
+  // attaching the downstream PRs threaded to it (`pull_requests.root_request_key = run_key`). Mirrors
+  // the feature/epic loops — a run with no PR landed yet still projects a thread (its derived phase).
+  const deliveryRows = await deliveryGraphRuns(data).all();
+  for (const run of deliveryRows) {
+    // Feature/epic precedence: the SQL view's CASE classifies epic > feature > delivery, so a
+    // `run_key` that collides with an existing `plan_key`/`feature_key` must NOT overwrite that
+    // thread — otherwise the poller projection would stamp delivery-derived frontier columns onto a
+    // row the view still classifies epic/feature, and the two drift. Skip the colliding run so the
+    // earlier feature/epic thread (and the view's precedence) stays intact.
+    if (threads.has(run.run_key)) continue;
+    const prs = collectRootPrs(run.run_key, null, prsByRoot, prByKey, claimed);
+    threads.set(run.run_key, deriveLineage(deliveryGraphOrigin(run), prs.map(toLineagePr)));
+  }
+
   // Any PR not claimed by a feature/epic root is its own root: a human/webhook PR, a legacy row
   // predating migration 037's backfill, or a `root_request_key` whose origin row no longer survives.
   // Key each such thread by the root STORED on the PR row (`root_request_key`, falling back to
@@ -532,6 +618,17 @@ function epicOrigin(plan: Plan): LineageOrigin {
   };
 }
 
+function deliveryGraphOrigin(run: DeliveryGraphRun): LineageOrigin {
+  return {
+    kind: "delivery",
+    key: run.run_key,
+    title: run.title,
+    status: run.status,
+    phase: run.phase,
+    processKey: run.process_key,
+  };
+}
+
 /** On-demand: the stitched thread for one origin issue (or self-rooted PR), computed from the live
  * rows. Returns null when the root is unknown. */
 export async function getLineage(