@nanobpm/nano-workforce 0.200.5 → 0.200.7

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [0.200.7](https://github.com/nanobpm/nano-workforce/compare/v0.200.6...v0.200.7) (2026-10-05)
+
+### Documentation
+
+* **agent-guide:** document the feature-run start endpoint ([#874](https://github.com/nanobpm/nano-workforce/issues/874)) ([faa01f2](https://github.com/nanobpm/nano-workforce/commit/faa01f28da943dcd5fd8695cb18bd8054d08c3f1))
+
+## [0.200.6](https://github.com/nanobpm/nano-workforce/compare/v0.200.5...v0.200.6) (2026-10-04)
+
+### Bug Fixes
+
+* **delivery-graph:** dispatch large graphs without UI timeout or a stranded phantom run ([#853](https://github.com/nanobpm/nano-workforce/issues/853)) ([d1adc47](https://github.com/nanobpm/nano-workforce/commit/d1adc4752690a91cb764ec3a49015f5a46ac7378)), closes [#852](https://github.com/nanobpm/nano-workforce/issues/852) [#852](https://github.com/nanobpm/nano-workforce/issues/852)
+
 ## [0.200.5](https://github.com/nanobpm/nano-workforce/compare/v0.200.4...v0.200.5) (2026-10-04)
 
 ### Bug Fixes

package/app/deliveryGraphDispatch.test.ts

@@ -9,11 +9,13 @@ import { test } from "node:test";
 import { assert, assertEquals, assertRejects } from "#test-assert";
 import type { AppApi } from "@nanobpm/urban";
 import { dispatchDeliveryGraphRun } from "./deliveryGraphDispatch.ts";
+import { isStaleLaunchClaim } from "./deliveryGraphRun.ts";
 import { noopLog } from "../test/log.ts";
 
-function makeApp(opts: { failIdentityWrite?: boolean } = {}) {
+function makeApp(opts: { failIdentityWrite?: boolean; reconcileReadThrows?: { on: boolean }; liveOriginal?: { processInstanceKey: string; runKey: string | null; processDefinitionId?: string } } = {}) {
   const tables = new Map<string, Record<string, unknown>[]>();
-  const started: { processDefinitionId: string }[] = [];
+  const started: { processDefinitionId: string; variables?: Record<string, unknown> }[] = [];
+  const cancelled: string[] = [];
   const table = (name: string, key: string) => {
     if (opts.failIdentityWrite && name === "delivery_graph_run_identity") {
       // Simulate a transient side-table write error (e.g. a SQLite `disk I/O error`) — NOT a UNIQUE
@@ -61,31 +63,67 @@ function makeApp(opts: { failIdentityWrite?: boolean } = {}) {
   const app = {
     data: {
       table,
-      open: () => ({
-        exec: (sql: string, params: unknown[]) =>
+      open: () => {
+        const exec = (sql: string, params: unknown[]) =>
           Promise.resolve().then(() => {
             const cols = [...sql.matchAll(/"(\w+)"\s*=\s*\?/g)].map((m) => m[1]);
-            const runKey = params[params.length - 1];
+            // The claim CAS (claimRunForLaunch) ends `… WHERE "run_key" = ? AND ("status" <> 'running'
+            // OR ("process_key" IS NULL AND "updated_at" < ?))` — the run_key is the 2nd-to-last param,
+            // the stale-TTL threshold the last. Model BOTH branches so a stale re-claim wins.
+            const isClaimCas = sql.includes('OR ("process_key" IS NULL AND "updated_at" < ?)');
+            const runKey = isClaimCas ? params[params.length - 2] : params[params.length - 1];
+            const staleBefore = isClaimCas ? (params[params.length - 1] as string) : null;
             const rows = tables.get("delivery_graph_runs") ?? [];
             const row = rows.find((r) => r["run_key"] === runKey);
-            if (row && row["status"] !== "running") {
+            const staleReclaimable =
+              isClaimCas && row && row["status"] === "running" && (row["process_key"] == null) && typeof staleBefore === "string" && (row["updated_at"] as string) < staleBefore;
+            if (row && (row["status"] !== "running" || staleReclaimable)) {
               for (let i = 0; i < cols.length - 1; i++) row[cols[i]] = params[i];
               return { changed: 1 };
             }
             return { changed: 0 };
-          }),
-      }),
+          });
+        // The claim runs inside a transaction (`data.open().tx(...)`); model `tx` as a pass-through
+        // that hands the same `exec` to the callback (the mock has no real isolation to model).
+        return { exec, tx: async (fn: (t: { exec: typeof exec }) => Promise<unknown>) => fn({ exec }) };
+      },
     },
     engine: {
       deployResources: () => Promise.resolve([]),
-      createInstance: (req: { processDefinitionId: string }) => {
+      createInstance: (req: { processDefinitionId: string; variables?: Record<string, unknown> }) => {
         started.push(req);
-        return Promise.resolve({ processInstanceKey: "PI-1", processDefinitionId: req.processDefinitionId });
+        return Promise.resolve({ processInstanceKey: `PI-${started.length}`, processDefinitionId: req.processDefinitionId });
+      },
+      // The reconcile-before-relaunch seam (issue #852 review): surface a configured LIVE original
+      // instance (a dispatch that died after createInstance but before stamping the key) so the test can
+      // assert the relaunch cancels it. `liveOriginal.runKey === null` models an instance whose runKey
+      // variable is absent/unreadable — it must NOT be cancelled (unproven ownership).
+      searchProcessInstances: (filter?: { processDefinitionId?: string; state?: string }) =>
+        // A reconcile READ failure (issue #853 review — thread deliveryGraphDispatch.ts:280): the
+        // reconcile pass queries by `processDefinitionId`, so gate the transient throw on that filter.
+        opts.reconcileReadThrows?.on && filter?.processDefinitionId !== undefined
+          ? Promise.reject(new Error("engine unavailable"))
+          : Promise.resolve(
+          opts.liveOriginal &&
+            (filter?.processDefinitionId === undefined || filter.processDefinitionId === (opts.liveOriginal.processDefinitionId ?? filter.processDefinitionId)) &&
+            (filter?.state === undefined || filter.state === "ACTIVE")
+            ? [{ processInstanceKey: opts.liveOriginal.processInstanceKey, state: "ACTIVE" }]
+            : [],
+        ),
+      searchVariables: (filter?: { processInstanceKey?: string; name?: string }) =>
+        Promise.resolve(
+          opts.liveOriginal && filter?.name === "runKey" && filter.processInstanceKey === opts.liveOriginal.processInstanceKey && opts.liveOriginal.runKey !== null
+            ? [{ variableKey: "v1", name: "runKey", value: JSON.stringify(opts.liveOriginal.runKey), scopeKey: opts.liveOriginal.processInstanceKey, processInstanceKey: opts.liveOriginal.processInstanceKey, isTruncated: false }]
+            : [],
+        ),
+      cancelInstance: (req: { processInstanceKey: string }) => {
+        cancelled.push(req.processInstanceKey);
+        return Promise.resolve();
       },
     },
     log: noopLog(),
   } as unknown as AppApi;
-  return { app, started, runs: () => tables.get("delivery_graph_runs") ?? [] };
+  return { app, started, cancelled, runs: () => tables.get("delivery_graph_runs") ?? [] };
 }
 
 const HUMAN_ONLY = {
@@ -257,3 +295,131 @@ test("dispatchDeliveryGraphRun: two credential-differing secret graphs with DIST
   assertEquals(started.length, 2);
   assertEquals(new Set(runs().map((r) => r.run_key)).size, 2);
 });
+
+// ── #852 review: reconcile-before-relaunch (thread deliveryGraphRun.ts:180) ──────────────────────
+// A STALE launch claim can hide a LIVE original instance (the dispatch died after createInstance but
+// before stamping the process key). The relaunch must cancel that original — matched by its seeded
+// `runKey` variable — before starting a second instance of the same side-effecting graph.
+
+/** Seed a STALE launch-claim row (running, NULL process_key, updated_at older than the TTL) straight
+ * into the mock store, as a crashed dispatch left it. */
+async function seedStaleClaim(app: AppApi, runKey: string, digest: string) {
+  const staleAt = new Date(Date.now() - 20 * 60_000).toISOString(); // 20 min ago > 15 min TTL
+  await app.data.table("delivery_graph_runs", "run_key").insert({
+    run_key: runKey,
+    process_key: null,
+    process_definition_id: `delivery-graph-${digest}`,
+    digest,
+    status: "running",
+    side_effecting: 1,
+    node_count: 2,
+    human_node_count: 1,
+    side_effect_count: 1,
+    title: "t",
+    phase: "Running",
+    phase_node_id: null,
+    human_labels: null,
+    created_at: staleAt,
+    updated_at: staleAt,
+    acknowledged_at: null,
+  });
+}
+
+test("#852 dispatchDeliveryGraphRun: re-claiming a STALE claim with a LIVE original instance cancels it before relaunch (at-most-once)", async () => {
+  // The original dispatch died after createInstance but before stamping the key: the row is a stale
+  // claim AND a live instance of this run (runKey "run-x") is still ACTIVE on the engine.
+  const { app, started, cancelled } = makeApp({ liveOriginal: { processInstanceKey: "PI-orig", runKey: "run-x" } });
+  // First dispatch to learn the digest, on a SEPARATE app so it doesn't disturb the test store.
+  const probe = await dispatchDeliveryGraphRun(makeApp().app, SIDE_EFFECTING, { runKey: "run-x", repoless: true });
+  assert(probe.ok);
+  if (!probe.ok) return;
+  await seedStaleClaim(app, "run-x", probe.digest);
+
+  const res = await dispatchDeliveryGraphRun(app, SIDE_EFFECTING, { runKey: "run-x", repoless: true });
+  assertEquals(res.ok, true);
+  if (!res.ok) return;
+  assertEquals(res.alreadyRunning, false, "the stale claim is re-claimed, not short-circuited");
+  assertEquals(cancelled, ["PI-orig"], "the live original instance is cancelled before the relaunch");
+  assertEquals(started.length, 1, "exactly one replacement instance launches");
+});
+
+test("#852 dispatchDeliveryGraphRun: re-claiming a STALE claim whose only ACTIVE instance is a DIFFERENT run relaunches WITHOUT cancelling it", async () => {
+  // A different run of the SAME graph (same content-addressed processDefinitionId) is still ACTIVE.
+  // The relaunch must NOT cancel it — the runKey variable proves it is not ours.
+  const { app, started, cancelled } = makeApp({ liveOriginal: { processInstanceKey: "PI-other", runKey: "other-run" } });
+  const probe = await dispatchDeliveryGraphRun(makeApp().app, SIDE_EFFECTING, { runKey: "run-y", repoless: true });
+  assert(probe.ok);
+  if (!probe.ok) return;
+  await seedStaleClaim(app, "run-y", probe.digest);
+
+  const res = await dispatchDeliveryGraphRun(app, SIDE_EFFECTING, { runKey: "run-y", repoless: true });
+  assertEquals(res.ok, true);
+  if (!res.ok) return;
+  assertEquals(cancelled, [], "a different run's live instance is never cancelled");
+  assertEquals(started.length, 1, "the relaunch still proceeds");
+});
+
+test("#852 dispatchDeliveryGraphRun: an explicit-key stale re-claim whose graph DRIFTED still cancels the original (matched by the STALE ROW's digest, not the new one)", async () => {
+  // Under an explicit idempotencyKey the re-dispatched graph can differ from the original, so the
+  // freshly-compiled digest (d2) diverges from the stale row's digest (d1). The original live instance
+  // was deployed under `delivery-graph-d1`; matching it under the NEW digest d2 would miss it and strand
+  // it live — a double-launch of side-effecting nodes. Reconcile MUST search under the stale row's own
+  // digest. Learn both digests on throwaway apps.
+  const probeOrig = await dispatchDeliveryGraphRun(makeApp().app, SIDE_EFFECTING, { runKey: "run-z", repoless: true });
+  const probeDrift = await dispatchDeliveryGraphRun(makeApp().app, HUMAN_ONLY, { runKey: "run-z", repoless: true });
+  assert(probeOrig.ok && probeDrift.ok);
+  if (!probeOrig.ok || !probeDrift.ok) return;
+  assert(probeOrig.digest !== probeDrift.digest, "the two graphs must have different digests for this test to bite");
+
+  // The live original is deployed under the ORIGINAL digest's definition id — NOT the re-dispatched one.
+  const { app, started, cancelled } = makeApp({
+    liveOriginal: { processInstanceKey: "PI-orig", runKey: "run-z", processDefinitionId: `delivery-graph-${probeOrig.digest}` },
+  });
+  await seedStaleClaim(app, "run-z", probeOrig.digest);
+
+  // Re-dispatch the DRIFTED graph under the same explicit key.
+  const res = await dispatchDeliveryGraphRun(app, HUMAN_ONLY, { runKey: "run-z", repoless: true });
+  assertEquals(res.ok, true);
+  if (!res.ok) return;
+  assertEquals(res.alreadyRunning, false, "the stale claim is re-claimed, not short-circuited");
+  assertEquals(cancelled, ["PI-orig"], "the original (under the stale row's digest) is cancelled despite the graph drift");
+  assertEquals(started.length, 1, "exactly one replacement instance launches");
+});
+
+// ── #853 review: a reconcile-read failure must leave the row RECLAIMABLE-with-reconcile, never `failed`
+// (thread deliveryGraphDispatch.ts:280) ──────────────────────────────────────────────────────────────
+// If the reconcile read/cancel throws TRANSIENTLY while the original instance is still live, retiring
+// the stale claim to `failed` would let the NEXT dispatch relaunch WITHOUT reconciling (a `failed` row
+// is a plain terminal re-run, not a stale claim), double-launching the side-effecting nodes. The claim
+// must instead revert to a stale launch-claim so the reconcile is retried before any relaunch.
+
+test("#853 dispatchDeliveryGraphRun: a reconcile-read failure reverts the row to a STALE claim (not `failed`), launching nothing — so the next dispatch retries reconcile instead of relaunching blind", async () => {
+  const reconcileReadThrows = { on: true };
+  const { app, started, cancelled, runs } = makeApp({ liveOriginal: { processInstanceKey: "PI-orig", runKey: "run-r" }, reconcileReadThrows });
+  const probe = await dispatchDeliveryGraphRun(makeApp().app, SIDE_EFFECTING, { runKey: "run-r", repoless: true });
+  assert(probe.ok);
+  if (!probe.ok) return;
+  await seedStaleClaim(app, "run-r", probe.digest);
+
+  // Phase 1: the reconcile read throws. The dispatch must propagate the error, launch NOTHING, and
+  // leave the row a reclaimable stale claim — NOT retire it to `failed`.
+  await assertRejects(() => dispatchDeliveryGraphRun(app, SIDE_EFFECTING, { runKey: "run-r", repoless: true }), Error, "engine unavailable");
+  const row = runs().find((r) => r["run_key"] === "run-r");
+  assert(row, "the run row still exists");
+  assertEquals(row?.["status"], "running", "the row stays a `running` claim, not `failed`");
+  assertEquals(row?.["process_key"], null, "the row stays a NULL-key launch claim (still reclaimable as stale)");
+  assert(isStaleLaunchClaim(row as Parameters<typeof isStaleLaunchClaim>[0]), "the row is still a STALE launch claim, so the reconcile is retried before any relaunch");
+  assertEquals(started.length, 0, "nothing launched while the original may still be live");
+  assertEquals(cancelled, [], "nothing cancelled — the read failed before any cancel");
+
+  // Phase 2: the engine recovers. The NEXT dispatch re-enters reconcile (because the row is still a
+  // stale claim), cancels the live original, and relaunches exactly once — proving the row was never
+  // stranded in a `failed` state that would have relaunched blind.
+  reconcileReadThrows.on = false;
+  const res = await dispatchDeliveryGraphRun(app, SIDE_EFFECTING, { runKey: "run-r", repoless: true });
+  assertEquals(res.ok, true);
+  if (!res.ok) return;
+  assertEquals(res.alreadyRunning, false, "the stale claim is re-claimed, not short-circuited");
+  assertEquals(cancelled, ["PI-orig"], "the recovered reconcile cancels the live original before relaunch");
+  assertEquals(started.length, 1, "exactly one replacement instance launches across the two dispatches");
+});

package/app/deliveryGraphDispatch.ts

@@ -15,7 +15,7 @@ import { createHash } from "node:crypto";
 import type { AppApi } from "@nanobpm/urban";
 import type { DeliveryGraph } from "../nano-generated/api-io.d.ts";
 import { canonicalJson, validateDeliveryGraph } from "./deliveryGraph.ts";
-import { compileDeliveryGraph, digestInvisibleRawValues, graphCarriesRedactedSecrets } from "./deliveryGraphCompiler.ts";
+import { compileDeliveryGraphSemantic, DELIVERY_GRAPH_PROCESS_ID, digestInvisibleRawValues, graphCarriesRedactedSecrets } from "./deliveryGraphCompiler.ts";
 import {
   buildDeliveryGraphRunRow,
   buildHumanLabels,
@@ -25,6 +25,8 @@ import {
   type DeliveryGraphRunIdentity,
   deliveryGraphRunIdentities,
   deliveryGraphRuns,
+  isStaleLaunchClaim,
+  reconcileOriginalInstanceBeforeRelaunch,
 } from "./deliveryGraphRun.ts";
 import type { DeliveryRunTimeouts } from "./deliveryRunner.ts";
 import { deliveryGraphDigest, runDeliveryGraph } from "./deliveryRunner.ts";
@@ -97,7 +99,9 @@ export async function dispatchDeliveryGraphRun(
   // The graph passed the semantic validator above, so it is safe to narrow to the typed contract.
   // biome-ignore lint/plugin: validated external body narrowed to its contract after validateDeliveryGraph
   const typedGraph = graph as DeliveryGraph;
-  const compiled = await compileDeliveryGraph(typedGraph);
+  // Semantic compile only (#852): this needs the digest / resolved model / side effects / human stops,
+  // not the laid-out BPMN — `runDeliveryGraph` below runs the CPU-bound layout exactly once.
+  const compiled = await compileDeliveryGraphSemantic(typedGraph);
   if (!compiled.ok) {
     return { ok: false, errors: compiled.errors };
   }
@@ -182,7 +186,23 @@ export async function dispatchDeliveryGraphRun(
 
   // Idempotency short-circuit — a re-dispatch onto a still-running run does NOT double-launch.
   const existing = await runs.get(runKey);
-  if (existing && existing.status === "running") {
+  // Capture staleness NOW, off the pre-claim snapshot, and reuse that ONE decision below: the claim
+  // CAS below rewrites `updated_at`, so a staleness check after it would read the fresh claim and
+  // never fire. Only a STALE re-claim needs reconcile-before-relaunch (a fresh claim or a terminal-row
+  // re-run has no possibly-live original). Re-deriving staleness a second time here would race the TTL
+  // boundary: `isStaleLaunchClaim` reads `Date.now()` afresh, so the row can cross the TTL between this
+  // capture and a second check — the short-circuit would then stop firing while `reclaimingStaleClaim`
+  // stays false, the CAS below would still reclaim the (now-stale) row, and the reconcile block would
+  // be skipped, relaunching WITHOUT cancelling a possibly-live original. One captured decision keeps
+  // the short-circuit and the reconcile in lock-step (issue #853 review — thread
+  // deliveryGraphDispatch.ts:193).
+  const reclaimingStaleClaim = existing != null && isStaleLaunchClaim(existing);
+  // Capture the stale claim's original `updated_at` NOW, before the CAS below rewrites it: a
+  // reconcile-read failure must restore the row to exactly this past-the-TTL timestamp so it stays a
+  // RECLAIMABLE stale claim (see `revertToStaleClaim`). Captured as a value (not read back off
+  // `existing` after the CAS) because the CAS refreshes `updated_at` in place.
+  const staleClaimUpdatedAt = existing?.updated_at;
+  if (existing && existing.status === "running" && !reclaimingStaleClaim) {
     app.log.info("dispatch-delivery-graph short-circuit: already running", { runKey });
     return {
       ok: true,
@@ -236,6 +256,55 @@ export async function dispatchDeliveryGraphRun(
     const { run_key, created_at, ...patch } = failed;
     await runs.update(runKey, patch);
   };
+  // Reconcile-FAILURE recovery (issue #853 review — thread deliveryGraphDispatch.ts:280): a reconcile
+  // READ/CANCEL failure must NOT retire the row to `failed`. A `failed` row is terminal, so
+  // `isStaleLaunchClaim` rejects it and the NEXT dispatch re-runs it as a plain terminal-row relaunch —
+  // WITHOUT re-entering reconcile-before-relaunch — double-launching the side-effecting nodes if the
+  // original instance is in fact still live (the read failed only transiently). Instead revert the row
+  // to the pre-claim STALE launch-claim snapshot so the reconcile is RETRIED before any relaunch: the
+  // next dispatch sees a stale claim again (`reclaimingStaleClaim` → reconcile) and the poller sees one
+  // too (`reconcileStaleLaunchClaim` cancels the original via `finalize`). This mirrors the poller's own
+  // reconcile-failure behaviour, whose `finalize` throw rolls the CAS back to the same stale-claim
+  // `running` state rather than failing it — one canonical "a failed reconcile leaves the row
+  // reconcile-pending, never terminal" rule across both the dispatch and poller paths.
+  const revertToStaleClaim = async () => {
+    await runs.update(runKey, { status: "running", phase: DELIVERY_PHASE.RUNNING, process_key: null, process_definition_id: null, updated_at: staleClaimUpdatedAt });
+  };
+  // Reconcile-before-relaunch (issue #852 review — thread deliveryGraphRun.ts:180): if we just RE-CLAIMED
+  // a STALE launch claim (a `running`/NULL-key row past its TTL), the original dispatch may have died
+  // AFTER `createInstance` succeeded but BEFORE stamping the process key — leaving a LIVE instance
+  // executing this graph's side-effecting nodes. A timeout alone cannot tell that from "died before
+  // create". Now that the engine seam exposes it, close the window: cancel any still-ACTIVE instance of
+  // this run (matched by its seeded `runKey` variable) BEFORE we launch a replacement, so the relaunch
+  // stays at-most-once. Only a STALE re-claim needs this — a fresh claim or a terminal-row re-run has no
+  // possibly-live original. The content-addressed definition id is derived from the STALE ROW's own
+  // `digest` (`existing.digest`), NOT the freshly-compiled `digest` of THIS dispatch: under an explicit
+  // idempotency key the re-dispatched graph can differ (digest drift), and the original was deployed
+  // under `delivery-graph-<existing.digest>`. Searching under the new digest would miss the original and
+  // strand it live — the exact double-launch this reconcile exists to prevent. Mirrors the poller, which
+  // uses the stored `run.digest` (service.ts). `existing` is non-null whenever `reclaimingStaleClaim`.
+  if (reclaimingStaleClaim) {
+    const originalDigest = existing?.digest ?? digest;
+    try {
+      const cancelled = await reconcileOriginalInstanceBeforeRelaunch(app.engine, {
+        runKey,
+        processDefinitionId: `${DELIVERY_GRAPH_PROCESS_ID}-${originalDigest}`,
+      });
+      if (cancelled.length > 0) {
+        app.log.warn("dispatch-delivery-graph cancelled a still-running original instance before relaunch", { runKey, cancelled });
+      }
+    } catch (err) {
+      // A reconciliation read/cancel failure — OR a fail-closed `ReconcileConflictError` (an ACTIVE
+      // same-definition instance with no readable run-root `runKey`, e.g. a pre-upgrade legacy original)
+      // — must not strand the claim OR waive a blind relaunch through: revert to the pre-claim STALE
+      // launch-claim so the reconcile is retried (by the next dispatch or the poller) BEFORE any
+      // replacement launches, rather than retiring to `failed` (which a later dispatch would
+      // short-circuit past into a possible double-launch).
+      await revertToStaleClaim();
+      app.log.error("dispatch-delivery-graph reconcile-before-relaunch threw", { runKey });
+      throw err;
+    }
+  }
   // The claim is ours — persist THIS run's lossless identity so a later same-key short-circuit can prove
   // the running run is this exact graph. Upsert: a relaunch off a persisted (e.g. failed) row under an
   // explicit key may carry a different graph, so overwrite the stored fingerprint. This runs AFTER the

package/app/deliveryGraphDispatchLayoutOnce.test.ts

@@ -0,0 +1,13 @@
+// #852 — a dispatch must run the CPU-bound, superlinear `layoutBpmn` pass ONCE. `dispatchDeliveryGraphRun`
+// needs only the digest / resolved model / side effects / human stops (all on the semantic compile); the
+// laid-out BPMN is produced by `runDeliveryGraph` → `prepareDeliveryGraph`. Calling the layout-bearing
+// `compileDeliveryGraph` here too doubled a 54-node dispatch on merlin to ~105 s (52 s per layout).
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { test } from "node:test";
+
+test("#852: dispatchDeliveryGraphRun uses the semantic compile, never the layout-bearing compileDeliveryGraph", () => {
+  const src = readFileSync(new URL("./deliveryGraphDispatch.ts", import.meta.url), "utf8").replace(/\/\/.*$|\/\*[\s\S]*?\*\//gm, "");
+  assert.doesNotMatch(src, /\bcompileDeliveryGraph\s*\(/, "dispatch must not lay the diagram out (runDeliveryGraph already does)");
+  assert.match(src, /\bcompileDeliveryGraphSemantic\s*\(/);
+});