@nanobpm/nano-workforce 0.130.0 → 0.131.1

package/app/deliveryGraphDeploy.test.ts

@@ -207,3 +207,151 @@ test("di coverage: every compiled flow node carries a BPMNShape and every sequen
 function escapeRe(s: string): string {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+
+// ── S7: guarded (conditional) routing DEPLOYS and ROUTES on the real engine (ADR 0005 S7) ──────────
+// The compiler tests prove a guarded split emits an exclusiveGateway with FEEL conditions; only a live
+// deploy proves the engine EVALUATES those conditions and takes exactly ONE branch. Here the `bump`
+// agent's emitted scalar (`result`) is published to a process var and the exclusive gateway routes on
+// it: the breaking outcome runs the `migrate` node, the green outcome skips straight to `release`, and
+// BOTH re-converge on the exclusive merge to a COMPLETED instance (a parallel merge would deadlock the
+// skipped branch). A guarded string fact needs a `default`, so green rides the else-flow.
+const GUARDED_ADOPT: DeliveryGraph = {
+  name: "adopt runbook",
+  nodes: [
+    { id: "bump", kind: "agent", agent: { jobType: "senior:bump" }, emits: [{ name: "result", type: "string" }] },
+    { id: "migrate", kind: "agent", agent: { jobType: "senior:migrate" } },
+    { id: "release", kind: "connector", connector: { target: "npm:publish", dedupeKey: "rel-1" } },
+  ],
+  edges: [
+    { from: "bump", to: "migrate", when: "bump.result", equals: "breaking" },
+    { from: "bump", to: "release", default: true },
+    { from: "migrate", to: "release" },
+  ],
+};
+
+async function driveGuarded(outcome: "breaking" | "green"): Promise<{ state: string; migrateRan: boolean; releaseRan: boolean }> {
+  const engine = await createWasmEngineClient();
+  try {
+    let migrateRan = false;
+    let releaseRan = false;
+    // The split agent publishes its scalar outcome; the exclusive gateway routes on it.
+    await engine.registerWorker("senior:bump", async () => ({ result: outcome }));
+    await engine.registerWorker("senior:migrate", async () => {
+      migrateRan = true;
+      return {};
+    });
+    await engine.registerWorker(DELIVERY_CONNECTOR_TASK_TYPE, async () => {
+      releaseRan = true;
+      return {};
+    });
+
+    const run = await runDeliveryGraph(engine, GUARDED_ADOPT);
+    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, migrateRan, releaseRan };
+  } finally {
+    await engine.close();
+  }
+}
+
+test("S7 deploy+route: the breaking guard branch runs `migrate` before re-converging on the exclusive merge to COMPLETED", async () => {
+  const r = await driveGuarded("breaking");
+  assertEquals(r.state, "COMPLETED", "the breaking branch must run to a COMPLETED instance");
+  assert(r.migrateRan, "the breaking outcome must route through the guarded `migrate` node");
+  assert(r.releaseRan, "both branches must re-converge on `release`");
+});
+
+test("S7 deploy+route: the green default branch SKIPS `migrate` and rides the else-flow straight to COMPLETED", async () => {
+  const r = await driveGuarded("green");
+  assertEquals(r.state, "COMPLETED", "the green branch must run to a COMPLETED instance");
+  assert(!r.migrateRan, "the green outcome must NOT route through `migrate` — it rides the default flow");
+  assert(r.releaseRan, "the green outcome still reaches `release` via the else-flow (proof the exclusive merge fires on one token)");
+});
+
+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
+  // instance COMPLETE (a parallel End join would wait forever on the untaken human leaf).
+  const graph: DeliveryGraph = {
+    name: "surface check",
+    nodes: [
+      { id: "adopt", kind: "agent", agent: { jobType: "senior:adopt" }, emits: [{ name: "surface", type: "string" }] },
+      { id: "escalate", kind: "human", human: { prompt: "file the upstream issue" } },
+      { id: "done", kind: "connector", connector: { target: "npm:install", dedupeKey: "done-1" } },
+    ],
+    edges: [
+      { from: "adopt", to: "escalate", when: "adopt.surface", equals: "missing" },
+      { from: "adopt", to: "done", default: true },
+    ],
+  };
+
+  // Default path (surface present): the human leaf is skipped and the instance COMPLETES on its own.
+  {
+    const engine = await createWasmEngineClient();
+    try {
+      let doneRan = false;
+      await engine.registerWorker("senior:adopt", async () => ({ surface: "present" }));
+      await engine.registerWorker(DELIVERY_CONNECTOR_TASK_TYPE, async () => {
+        doneRan = true;
+        return {};
+      });
+      const run = await runDeliveryGraph(engine, graph, { escalationSlaTimeout: "PT1H" });
+      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] });
+        state = pi?.state ?? "?";
+        if (state === "COMPLETED" || state === "TERMINATED") break;
+        const open = await engine.searchUserTasks({ processInstanceKey: key, state: "CREATED" });
+        assertEquals(open.length, 0, "the default path must never surface the escalate human leaf");
+      }
+      assertEquals(state, "COMPLETED", "the default (present) path completes without the human leaf");
+      assert(doneRan, "the default path routes to the `done` connector leaf");
+    } finally {
+      await engine.close();
+    }
+  }
+
+  // Guarded path (surface missing): the human leaf parks; `done` never runs.
+  {
+    const engine = await createWasmEngineClient();
+    try {
+      let doneRan = false;
+      await engine.registerWorker("senior:adopt", async () => ({ surface: "missing" }));
+      await engine.registerWorker(DELIVERY_CONNECTOR_TASK_TYPE, async () => {
+        doneRan = true;
+        return {};
+      });
+      const run = await runDeliveryGraph(engine, graph, { escalationSlaTimeout: "PT1H" });
+      assert(run.ok, `runDeliveryGraph failed: ${JSON.stringify(run)}`);
+      const key = run.handle.processInstanceKey;
+      let parked = "";
+      for (let round = 0; round < MAX_ROUNDS; round++) {
+        await engine.drain();
+        const open = await engine.searchUserTasks({ processInstanceKey: key, state: "CREATED" });
+        if (open.length > 0) {
+          parked = open[0].elementId ?? "";
+          break;
+        }
+      }
+      assert(
+        parked.startsWith("delivery-human-task__") && !parked.endsWith("__esc"),
+        `the missing outcome must park on the escalate human leaf, saw ${JSON.stringify(parked)}`,
+      );
+      assert(!doneRan, "the guarded (missing) path must NOT run the `done` leaf");
+    } finally {
+      await engine.close();
+    }
+  }
+});

package/app/deliveryRunner.test.ts

@@ -79,12 +79,46 @@ test("nodeInputs seeds the exact per-kind fields each node's subProcess ioMappin
   assert(wait?.probe && typeof wait.probe === "object", "the wait node carries its ReadinessProbe descriptor");
 
   const human = byField((v) => "escalationSlaTimeout" in v);
-  assertEquals(human, { escalationSlaTimeout: "PT2H", escalationAssignee: "alice" });
+  assertEquals(human, {
+    escalationSlaTimeout: "PT2H",
+    escalationAssignee: "alice",
+    // #499: the human node seeds its authored prompt, node identity, and declared emits so the
+    // generic user-task form renders "now do X", names the parked node, and labels its emit field.
+    prompt: "run the manual OTP publish",
+    nodeId: "publish",
+    emits: [{ name: "resolvedArtifact", type: "artifact" }],
+  });
 
   const connector = byField((v) => v.target === "npm:install");
   assertEquals(connector, { target: "npm:install", dedupeKey: "consume-1", payload: null, timeout: "PT10M" });
 });
 
+test("the human node seeds prompt/nodeId/emits; a click-done (no-emit, no-prompt) node seeds empty defaults", async () => {
+  // #499: the compiled human user-task's form reads `prompt`/`nodeId`/`emits` from `nodeInputs.<el>`;
+  // a discarded prompt is the contextless-form bug. Pin both an emit-declaring node and the degenerate
+  // click-done node (no `human` config, no `emits`) so the seed never regresses to null/undefined.
+  const graph: DeliveryGraph = {
+    nodes: [
+      { id: "publish", kind: "human", human: { prompt: "run the manual OTP publish" }, emits: [{ name: "resolvedArtifact", type: "artifact" }] },
+      { id: "ack", kind: "human" },
+    ],
+    edges: [{ from: "publish.resolvedArtifact", to: "ack" }],
+  };
+  const p = await prepareOk(graph);
+  const humans = Object.values(p.nodeInputs).filter((v) => "escalationSlaTimeout" in v) as Array<Record<string, unknown>>;
+  const publish = humans.find((v) => v.nodeId === "publish");
+  const ack = humans.find((v) => v.nodeId === "ack");
+
+  assertEquals(publish?.prompt, "run the manual OTP publish");
+  assertEquals(publish?.emits, [{ name: "resolvedArtifact", type: "artifact" }]);
+
+  // The click-done node carries a defined-but-empty prompt and an empty emits list (never undefined),
+  // so the form seeds a blank instruction and hides its emit field rather than seeding null.
+  assertEquals(ack?.prompt, "");
+  assertEquals(ack?.emits, []);
+  assertEquals(ack?.nodeId, "ack");
+});
+
 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

@@ -15,7 +15,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 type { DeliveryFact, 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";
 
@@ -65,7 +65,7 @@ const DEFAULTS: Required<Omit<DeliveryRunTimeouts, "escalationAssignee">> = {
 type NodeInput =
   | { jobType: string; appendPrompt: string; timeout: string }
   | { gateKey: string; probe: unknown; probeTimeout: string; probePollEvery: string }
-  | { escalationSlaTimeout: string; escalationAssignee: string | null }
+  | { escalationSlaTimeout: string; escalationAssignee: string | null; prompt: string; nodeId: string; emits: DeliveryFact[] }
   | { target: string; dedupeKey: string | null; payload: Record<string, unknown> | null; timeout: string };
 
 /** The result of compiling + preparing a graph for deployment: the content-addressed process id, the
@@ -185,7 +185,17 @@ function buildNodeInput(
       };
     }
     case "human":
-      return { escalationSlaTimeout: ctx.escalationSlaTimeout, escalationAssignee: ctx.escalationAssignee };
+      return {
+        escalationSlaTimeout: ctx.escalationSlaTimeout,
+        escalationAssignee: ctx.escalationAssignee,
+        // Seed the authored instruction, node identity, and declared emits so the human user-task's
+        // form can render its "now do X" prompt, name the parked node, and label/hide its emit field
+        // (issue #499 — the generic form otherwise renders contextless). `emits` stays the single
+        // source of truth: the compiled ioMapping derives the emit label/mode from it in FEEL.
+        prompt: node.human?.prompt ?? "",
+        nodeId: node.id ?? ctx.element,
+        emits: Array.isArray(node.emits) ? node.emits.map((f) => ({ ...f })) : [],
+      };
     case "connector":
       return {
         target: node.connector.target,

package/docs/adr/0005-agent-authored-delivery-graphs.md

@@ -225,6 +225,31 @@ resume cannot double-fire.
 - **Non-npm emit facts** (OCI/github-release) and behavioural edges beyond the `command` escape hatch —
   added when a real case lands.
 
+> **Amendment (issue #492): conditional (guarded) edges landed (S7).** The "behavioural edges" deferral
+> above is **partially lifted**: an edge may now carry an optional guard — `when: "<node>.<fact>"` +
+> `equals: <scalar>` — or be the split's single `default: true` else-branch. A node whose out-edges
+> carry guards is an **exclusive** (data-based) split instead of the default parallel fan-out; its guarded branches compile to a BPMN `exclusiveGateway` (`gwx<i>`) with one FEEL
+> `conditionExpression` per guarded flow (`=<producerElement>_<fact> = <literal>`) and a named default
+> flow, and where those branches re-converge they merge on an **exclusive** gateway (`gwm<i>`,
+> first-token-proceeds) rather than the parallel AND-join that would deadlock the untaken branch. The
+> validator enforces the guard's shape and closes the deadlock/ambiguity classes: a guard must
+> reference a **scalar** fact **declared by the edge's own producer** (`bad-when`), carry an `equals`
+> whose type matches the fact (`guard-missing-equals` / `guard-type-mismatch`), never combine `when`
+> with `default` (`guard-default-conflict`); a split must not **mix** guarded and plain out-edges
+> (`mixed-fan-out`) nor declare **two** defaults (`multiple-defaults`), must be **exhaustive** — a
+> `default`, unless a single boolean fact is guarded on both `true` and `false` (`non-exhaustive-split`)
+> — and a plain (parallel) AND-join may not be fed by an exclusive-split branch (`exclusive-merge-parity`),
+> including the implicit **End sink**: the terminal nodes may not mix a conditional (exclusive-split)
+> tail with an always-firing one, which would deadlock the End join or double-fire its exclusive merge.
+> The exclusive-split topology (both the validator's parity analysis and the compiler's gateway
+> selection) is derived from the **guarded (`when`) edges fanning out to \>=2 distinct downstream
+> targets only** — a lone `default: true` edge with no guarded sibling always fires, and a node whose
+> guarded + `default` edges all converge on **one** downstream target has no real fan-out, so in
+> either case its producer is **not** a split and must not mark downstream nodes/leaves conditional;
+> the per-node mixing/exhaustiveness checks still apply to any `default`.
+> Determinism is preserved: gateway ids are positional over id-sorted nodes, so a graph with no guards
+> compiles byte-for-byte as before.
+
 ## Open questions
 
 - **Compiler target for the first cut** — confirm compile-to-native (diagram + native scheduling) vs a

package/openapi.yaml

@@ -1502,7 +1502,9 @@ components:
         `from` is either a bare `<nodeId>` (wait for the upstream node's completion fact) or a
         qualified `<nodeId>.<fact>` referencing a declared `emits` fact of that node. Both endpoints
         must resolve to a node in the graph, the referenced fact must be declared, and the whole edge
-        set must be a DAG — all enforced by `validateDeliveryGraph`.
+        set must be a DAG — all enforced by `validateDeliveryGraph`. An OPTIONAL `when`/`equals` guard
+        (or a `default` else-branch) makes the edge CONDITIONAL, turning its producer into an
+        exclusive split (ADR 0005 S7) — a node's out-edges are then ALL guarded or ALL unconditional.
       type: object
       additionalProperties: false
       required:
@@ -1517,6 +1519,33 @@ components:
           type: string
           minLength: 1
           description: The dependent node's id — proceeds once `from` is observed.
+        when:
+          type: string
+          minLength: 1
+          description: >-
+            OPTIONAL guard reference `<nodeId>.<fact>` naming a SCALAR emitted fact (`string`,
+            `number`, or `boolean`) of the `from`-adjacent producer (ADR 0005 S7). Its presence makes
+            this a GUARDED edge and turns the producer into an exclusive-split point: the edge is taken
+            only when that runtime fact `equals` the literal below. Equality-only — no arbitrary
+            expressions (the trust boundary). Mutually exclusive with `default`.
+        equals:
+          description: >-
+            The literal value `when`'s fact must equal for this guarded edge to be taken (ADR 0005 S7).
+            REQUIRED iff `when` is present, and its JSON type must match the referenced fact's declared
+            type (`string`/`number`/`boolean`).
+          oneOf:
+            - type: string
+            - type: number
+            - type: boolean
+        default:
+          type: boolean
+          enum: [true]
+          description: >-
+            OPTIONAL — marks this edge as the ELSE branch of the exclusive split (taken when no guarded
+            edge matches at runtime). A FLAG: only `true` is meaningful, so it is constrained to `true`
+            (omit the field entirely for a non-default edge — `default: false` is not a valid wire
+            value). At most one `default` edge per split node. Mutually exclusive with `when`/`equals`
+            (ADR 0005 S7).
     DeliveryCompileError:
       description: >-
         One semantic-validation or compile failure, path-qualified at the offending input
@@ -1749,6 +1778,19 @@ components:
         fromFact:
           type: string
           description: The referenced emitted fact, when the edge `from` was qualified.
+        when:
+          type: string
+          description: The guard reference (`<nodeId>.<fact>`) verbatim, present only on a guarded edge (ADR 0005 S7).
+        equals:
+          description: The literal the guard fact must equal, present only on a guarded edge (ADR 0005 S7).
+          oneOf:
+            - type: string
+            - type: number
+            - type: boolean
+        default:
+          type: boolean
+          enum: [true]
+          description: True when this is the exclusive split's default (else) branch; a FLAG, only ever `true` and omitted otherwise (ADR 0005 S7).
     ResolvedDeliveryGraph:
       description: >-
         The normalised graph the compiler resolved from the input (ADR 0005 slice S1) — nodes and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.130.0",
+  "version": "0.131.1",
   "description": "Nano Workforce — an Agent Graph Orchestration application for Agentic SDLC: durable BPMN processes that coordinate a graph of AI agents across the software delivery lifecycle.",
   "type": "module",
   "main": "main.ts",

package/pages/cockpit/cockpit.css

@@ -173,6 +173,18 @@
   border-radius: 6px;
 }
 
+/* The "connected — waiting for output" status note under the terminal (blank-terminal defect fix):
+   hidden until a live drill is connected-but-quiet, so a blank panel reads as "waiting" not "broken". */
+.cockpit-terminal-note {
+  margin: 8px 0 0;
+  font-size: 0.85em;
+  color: #7c8794;
+  font-style: italic;
+}
+.cockpit-terminal-note[data-terminal-note="none"] {
+  display: none;
+}
+
 /* ── Past sessions (H3 read path / #222): the captured-session history + replay. ──────────────── */
 
 .cockpit-past-header {

package/pages/cockpit/mount.js

@@ -72,6 +72,7 @@ function workerView(worker, staleAfterMs, byJobKey) {
     host: worker.host ?? "\u2014",
     jobKeys,
     jobs: jobKeys.length,
+    drillable: jobKeys.length > 0,
     correlations,
     liveness: liveness(worker, staleAfterMs),
     staleMs: worker.staleMs,
@@ -141,12 +142,18 @@ function workerRow(doc, worker, onDrill, onOpenWorker) {
   button.setAttribute("data-stream", worker.stream);
   if (onOpenWorker) button.addEventListener("click", () => onOpenWorker(worker.instance));
   nameCell.appendChild(button);
-  const drill = el(doc, "button", "cockpit-worker-drill", "terminal");
-  drill.setAttribute("type", "button");
-  drill.setAttribute("data-instance", worker.instance);
-  drill.setAttribute("data-stream", worker.stream);
-  if (onDrill) drill.addEventListener("click", () => onDrill(worker.stream));
-  nameCell.appendChild(drill);
+  // The inline live-terminal drill — ONLY for a worker that currently holds a job. An idle worker's
+  // `stream` is its bare instance id, which no producer writes to, so drilling it opens a permanently
+  // blank "live" terminal. Suppress the affordance when there is nothing live to stream (mirrors
+  // app/agentic/cockpit/supply-render.ts).
+  if (worker.drillable) {
+    const drill = el(doc, "button", "cockpit-worker-drill", "terminal");
+    drill.setAttribute("type", "button");
+    drill.setAttribute("data-instance", worker.instance);
+    drill.setAttribute("data-stream", worker.stream);
+    if (onDrill) drill.addEventListener("click", () => onDrill(worker.stream));
+    nameCell.appendChild(drill);
+  }
   row.appendChild(nameCell);
 
   row.appendChild(el(doc, "td", "cockpit-td cockpit-supply-family", worker.family));
@@ -494,6 +501,12 @@ export function mountCockpit(host, opts = {}) {
   const terminalHost = el(doc, "div", "cockpit-terminal-host");
   terminalHost.setAttribute("data-terminal", "host");
   terminalPanel.appendChild(terminalHost);
+  // Status note under the terminal, shown while a LIVE drill has connected but no output has arrived
+  // yet (a quiet job between frames), so a blank panel reads as "waiting" not "broken". Cleared on
+  // the first frame and on every mode change (mirrors app/agentic/cockpit/supply-boot.ts).
+  const terminalNote = el(doc, "p", "cockpit-terminal-note");
+  terminalNote.setAttribute("data-terminal-note", "none");
+  terminalPanel.appendChild(terminalNote);
   shell.appendChild(listRegion);
   shell.appendChild(pastRegion);
   shell.appendChild(terminalPanel);
@@ -524,6 +537,19 @@ export function mountCockpit(host, opts = {}) {
     if (next === "live") terminalTitle.textContent = "Worker terminal — live";
     else if (next === "replay") terminalTitle.textContent = "Worker terminal — replay (past session)";
     else terminalTitle.textContent = "Worker terminal";
+    // Any mode change replaces what's behind the panel, so the prior "waiting" note is stale — clear
+    // it. A live drill re-arms it once its fresh terminal is mounted.
+    setNote(undefined);
+  }
+
+  function setNote(text) {
+    if (text == null) {
+      terminalNote.textContent = "";
+      terminalNote.setAttribute("data-terminal-note", "none");
+      return;
+    }
+    terminalNote.textContent = text;
+    terminalNote.setAttribute("data-terminal-note", "waiting");
   }
 
   function teardownTerminal() {
@@ -586,8 +612,19 @@ export function mountCockpit(host, opts = {}) {
     teardownTerminal();
     try {
       terminalHost.replaceChildren();
-      const sink = xtermSink(terminalHost);
-      terminal = sink;
+      const rawSink = xtermSink(terminalHost);
+      terminal = rawSink;
+      // Wrap the sink so the first byte of live output clears the "waiting" note (mirrors supply-boot).
+      let cleared = false;
+      const sink = {
+        write: (chunk) => {
+          if (!cleared) {
+            cleared = true;
+            setNote(undefined);
+          }
+          rawSink.write(chunk);
+        },
+      };
       let session;
       const client = new RelayChannelClient({
         connect: connectRelay,
@@ -599,6 +636,8 @@ export function mountCockpit(host, opts = {}) {
       client.open();
       drill = { stream, client };
       setMode("live", stream);
+      // Arm the "waiting for output" note (after setMode, which clears it) until the first frame.
+      setNote("Connected — waiting for live output…");
     } catch (err) {
       // The new terminal failed to build after the prior one was torn down: reset the region to idle
       // (and drop any partially-built terminal) so the UI never shows a stale "live"/"replay"

package/resources/forms/delivery-human-generic.form

@@ -3,6 +3,13 @@
   "schemaVersion": 18,
   "type": "default",
   "components": [
+    {
+      "type": "text",
+      "text": "### Delivery graph — node `{{nodeId}}`",
+      "conditional": {
+        "hide": "=(nodeId = null) or (nodeId = \"\")"
+      }
+    },
     {
       "type": "textarea",
       "key": "prompt",
@@ -10,15 +17,32 @@
       "description": "The scheduled human step this delivery graph is waiting on.",
       "readonly": true
     },
+    {
+      "type": "text",
+      "text": "**Emits:** {{emitLabel}} — enter its typed value below (validated against the node's declared fact).",
+      "conditional": {
+        "hide": "=emitMode != \"typed\""
+      }
+    },
     {
       "type": "textfield",
       "key": "value",
       "label": "Emitted value",
       "description": "The typed value this step hands forward to its downstream dependents. Validated against the node's declared emitted fact.",
+      "conditional": {
+        "hide": "=emitMode != \"typed\""
+      },
       "validate": {
         "required": true
       }
     },
+    {
+      "type": "text",
+      "text": "_This step emits no typed fact (N/A) — just complete it to unblock its dependents._",
+      "conditional": {
+        "hide": "=emitMode = \"typed\""
+      }
+    },
     {
       "type": "textarea",
       "key": "note",

package/resources/processes/delivery-human.bpmn

@@ -10,6 +10,10 @@
         <zeebe:userTask />
         <zeebe:assignmentDefinition candidateGroups="operators" assignee="=if (is defined(escalationAssignee) and escalationAssignee != null and trim(string(escalationAssignee)) != &#34;&#34;) then escalationAssignee else null" />
         <zeebe:ioMapping>
+          <zeebe:input source="=if (is defined(prompt)) then prompt else null" target="prompt" />
+          <zeebe:input source="=if (is defined(nodeId)) then nodeId else null" target="nodeId" />
+          <zeebe:input source="=if (is defined(emits) and count(emits) != 0) then &#34;typed&#34; else &#34;none&#34;" target="emitMode" />
+          <zeebe:input source="=if (is defined(emits)) then string join(for _e in emits return _e.name + &#34; (&#34; + _e.type + &#34;)&#34;, &#34;, &#34;) else &#34;&#34;" target="emitLabel" />
           <zeebe:output source="=&#34;completed&#34;" target="humanOutcome" />
           <zeebe:output source="=if (is defined(value)) then value else null" target="humanEmitValue" />
           <zeebe:output source="=if (is defined(resolvedArtifact)) then resolvedArtifact else null" target="humanEmitArtifact" />