@openwop/openwop-conformance 2.46.5 → 2.46.7

package/CHANGELOG.md

@@ -1,3 +1,20 @@
+## [2.46.7] — 2026-10-14 — one id per leg; RFC 0243 G2 closes
+
+- **RFC 0243 G2 closes.** No assertion changes; the packed `spec/v1/gaps.json` changes. openwop-app's certified 2.46.6 cut (build `44960bca5`) records all three G2 ids `executed-pass`.
+- **Registry: a requirement id passed through a helper is registered.** A scenario writing `assert(ID_X, judge(o))`, where the helper calls `req(id, …)`, registered `explicitId: null`. `src/setup.ts` labels a soft-skipped row from `explicitId`, so on a host where the leg was `inapplicable` the row read `openwop.it.<file>.<slug>`, and on a host where it ran, the requirement id. One leg, two ids, depending on the host. Found by openwop-app-8f on `v2-agents-fan-out-waves`.
+  - The generator now takes the first `openwop.requirement.*` const passed as a call's first argument when the body has no `req()`. 20 records in 7 files gain their id, and no existing id changes: `v2-agents-fan-out-waves`, `v2-dispatch-loop`, `v2-dispatch-input-mapping`, `v2-subworkflow-input-mapping`, `v2-subworkflow-linkage`, `v2-host-event-delivery`, `v2-safefetch-ssrf-refused`.
+  - **What a host's next bundle shows:** those legs' non-executed rows are renamed from `openwop.it.*` to their requirement ids. Executed rows are unchanged. A bundle cut on an older suite lacks rows for the three 2.46.6 ids under `check-cut-gates` Witness, which is the usual currency effect.
+  - A self-test pins the registered ids for two of the files.
+
+## [2.46.6] — 2026-10-13 — RFC 0243 G2: fan-out waves and per-item input
+
+- **New `v2-agents-fan-out-waves`** (three ids, legs in `lib/fan-out-witness.ts`). The v1 twins drove a seam v2 does not carry; these run fixtures whose supervisor emits its `mockDispatchPlan`.
+  - `0243.max-fan-out-waves`, on `conformance-dispatch-fanout-waves`: three `conformance-delay` children under `maxConcurrency: 2` all complete, `dispatch.fanned-out` and `dispatch.joined` count three, and no more than `min(2, maxFanOut)` child windows overlap by more than 100 ms. Gated on `agents.fanOut` admitting `wait-all` with `collect`.
+  - `0243.per-item-input-gated`, on `conformance-dispatch-per-item`: at `agents.fanOut.perItemInput: true` each child receives its own `nextWorkerInputs` item; on any other dispatch host the dispatch node fails `validation_error` and no child is dispatched (a `400 validation_error` at `createRun` also satisfies it).
+  - `agents.dispatch-per-item-length-mismatch`, on `conformance-dispatch-per-item-mismatch`: one item for two children fails the dispatch node `validation_error`, no child, on every dispatch host.
+- **What a host's next bundle shows:** the fixtures are opt-in through discovery `fixtures`, so a host that does not list them records all three `inapplicable`. A dispatch host that lists the per-item fixtures and drops `nextWorkerInputs` records `executed-fail`.
+- `ObservedRun` gains an optional `createBody`; the run-graph double can refuse a create and add snapshot members.
+
 ## [2.46.5] — 2026-10-13 — RFC 0243 Accepted; a fan-out prediction corrected
 
 - **No assertion changes.** This cycle opens because RFC 0243's gap G1 closes, which changes the packed `spec/v1/gaps.json`.

package/README.md

@@ -137,7 +137,7 @@ Each scenario file records its disposition and assertion count in `<report-dir>/
 
 ## What's Covered
 
-The current suite has 656 scenario files under `src/scenarios/`. By target major ([`scenario-majors.json`](./scenario-majors.json)): 216 files run against a v2 host and 455 against a v1 host; 15 of them run at both.
+The current suite has 657 scenario files under `src/scenarios/`. By target major ([`scenario-majors.json`](./scenario-majors.json)): 217 files run against a v2 host and 455 against a v1 host; 15 of them run at both.
 
 The v2 scenarios (`src/scenarios/v2-*.test.ts`) cover, by area:
 
@@ -166,7 +166,7 @@ Three kinds of scenario share the tree:
 - **Host** checks drive a live host over HTTP.
 - **Gated** checks run only when the host advertises the family, profile or fixture they need, and otherwise record `inapplicable` or `blocked` with a reason. `--require-behavior` turns an advertised-but-unwitnessable behaviour into a failure.
 
-Current source tree: 656 scenario files. [`coverage.md`](./coverage.md) maps each spec document and every OpenAPI operation to its scenarios. [`CHANGELOG.md`](./CHANGELOG.md) records when each scenario landed.
+Current source tree: 657 scenario files. [`coverage.md`](./coverage.md) maps each spec document and every OpenAPI operation to its scenarios. [`CHANGELOG.md`](./CHANGELOG.md) records when each scenario landed.
 
 ## How the 2.x suite is built
 

package/dist/spec-artifacts.lock.json

@@ -1,5 +1,5 @@
 {
   "package": "@openwop/spec-artifacts",
-  "version": "2.46.5",
-  "stampSha256": "0f3441572726c05b4ce03f9892f3b90ef77a8e37fa913c5f069fef3553cedf94"
+  "version": "2.46.7",
+  "stampSha256": "aa3b7b3012274a6d025e75053ff2697d94062a06f4dd2fee48e2ef01964f8581"
 }

package/fixtures/conformance-dispatch-fanout-waves.json

@@ -0,0 +1,84 @@
+{
+  "id": "conformance-dispatch-fanout-waves",
+  "name": "Conformance: Dispatch Fan-Out Waves",
+  "version": "1.0",
+  "description": "A parallel fan-out of three conformance-delay children with maxConcurrency 2: at most two children run at once, and none is dropped (RFC 0243 \u00a7A.3).",
+  "nodes": [
+    {
+      "id": "supervisor",
+      "typeId": "core.orchestrator.supervisor",
+      "name": "Supervisor",
+      "position": {
+        "x": 0,
+        "y": 0
+      },
+      "config": {
+        "mockDispatchPlan": [
+          {
+            "kind": "next-worker",
+            "nextWorkerIds": [
+              "conformance-delay",
+              "conformance-delay",
+              "conformance-delay"
+            ]
+          },
+          {
+            "kind": "terminate",
+            "reason": "goal-reached"
+          }
+        ]
+      },
+      "inputs": {}
+    },
+    {
+      "id": "dispatch",
+      "typeId": "core.dispatch",
+      "name": "Dispatch",
+      "position": {
+        "x": 200,
+        "y": 0
+      },
+      "config": {
+        "workerDispatchModel": "child-run",
+        "fanOutPolicy": "parallel",
+        "maxConcurrency": 2,
+        "joinPolicy": {
+          "mode": "wait-all",
+          "onChildFailure": "collect"
+        }
+      },
+      "inputs": {}
+    }
+  ],
+  "edges": [
+    {
+      "id": "e1",
+      "sourceNodeId": "supervisor",
+      "targetNodeId": "dispatch"
+    },
+    {
+      "id": "e2",
+      "sourceNodeId": "dispatch",
+      "targetNodeId": "supervisor"
+    }
+  ],
+  "triggers": [
+    {
+      "id": "manual",
+      "type": "manual",
+      "enabled": true
+    }
+  ],
+  "variables": [],
+  "metadata": {
+    "tags": [
+      "conformance",
+      "dispatch",
+      "fan-out"
+    ]
+  },
+  "settings": {
+    "timeout": 60000,
+    "maxRetries": 0
+  }
+}

package/fixtures/conformance-dispatch-per-item-mismatch.json

@@ -0,0 +1,83 @@
+{
+  "id": "conformance-dispatch-per-item-mismatch",
+  "name": "Conformance: Dispatch Per-Item Length Mismatch",
+  "version": "1.0",
+  "description": "A next-worker decision whose nextWorkerInputs is shorter than nextWorkerIds. Every host fails the dispatch node with validation_error and dispatches no child (RFC 0126, orchestrator-decision.schema.json nextWorkerInputs).",
+  "nodes": [
+    {
+      "id": "supervisor",
+      "typeId": "core.orchestrator.supervisor",
+      "name": "Supervisor",
+      "position": {
+        "x": 0,
+        "y": 0
+      },
+      "config": {
+        "mockDispatchPlan": [
+          {
+            "kind": "next-worker",
+            "nextWorkerIds": [
+              "conformance-dispatch-input-mapping-child",
+              "conformance-dispatch-input-mapping-child"
+            ],
+            "nextWorkerInputs": [
+              {
+                "childGreeting": "item-a"
+              }
+            ]
+          },
+          {
+            "kind": "terminate",
+            "reason": "goal-reached"
+          }
+        ]
+      },
+      "inputs": {}
+    },
+    {
+      "id": "dispatch",
+      "typeId": "core.dispatch",
+      "name": "Dispatch",
+      "position": {
+        "x": 200,
+        "y": 0
+      },
+      "config": {
+        "workerDispatchModel": "child-run",
+        "fanOutPolicy": "sequential"
+      },
+      "inputs": {}
+    }
+  ],
+  "edges": [
+    {
+      "id": "e1",
+      "sourceNodeId": "supervisor",
+      "targetNodeId": "dispatch"
+    },
+    {
+      "id": "e2",
+      "sourceNodeId": "dispatch",
+      "targetNodeId": "supervisor"
+    }
+  ],
+  "triggers": [
+    {
+      "id": "manual",
+      "type": "manual",
+      "enabled": true
+    }
+  ],
+  "variables": [],
+  "metadata": {
+    "tags": [
+      "conformance",
+      "dispatch",
+      "per-item-input"
+    ]
+  },
+  "settings": {
+    "timeout": 60000,
+    "maxRetries": 0
+  }
+}

package/fixtures/conformance-dispatch-per-item.json

@@ -0,0 +1,86 @@
+{
+  "id": "conformance-dispatch-per-item",
+  "name": "Conformance: Dispatch Per-Item Input",
+  "version": "1.0",
+  "description": "One next-worker decision dispatching the same child twice with distinct nextWorkerInputs. A host advertising agents.fanOut.perItemInput true projects each item into its child; any other host fails the dispatch node with validation_error and dispatches no child (RFC 0243 \u00a7A.4).",
+  "nodes": [
+    {
+      "id": "supervisor",
+      "typeId": "core.orchestrator.supervisor",
+      "name": "Supervisor",
+      "position": {
+        "x": 0,
+        "y": 0
+      },
+      "config": {
+        "mockDispatchPlan": [
+          {
+            "kind": "next-worker",
+            "nextWorkerIds": [
+              "conformance-dispatch-input-mapping-child",
+              "conformance-dispatch-input-mapping-child"
+            ],
+            "nextWorkerInputs": [
+              {
+                "childGreeting": "item-a"
+              },
+              {
+                "childGreeting": "item-b"
+              }
+            ]
+          },
+          {
+            "kind": "terminate",
+            "reason": "goal-reached"
+          }
+        ]
+      },
+      "inputs": {}
+    },
+    {
+      "id": "dispatch",
+      "typeId": "core.dispatch",
+      "name": "Dispatch",
+      "position": {
+        "x": 200,
+        "y": 0
+      },
+      "config": {
+        "workerDispatchModel": "child-run",
+        "fanOutPolicy": "sequential"
+      },
+      "inputs": {}
+    }
+  ],
+  "edges": [
+    {
+      "id": "e1",
+      "sourceNodeId": "supervisor",
+      "targetNodeId": "dispatch"
+    },
+    {
+      "id": "e2",
+      "sourceNodeId": "dispatch",
+      "targetNodeId": "supervisor"
+    }
+  ],
+  "triggers": [
+    {
+      "id": "manual",
+      "type": "manual",
+      "enabled": true
+    }
+  ],
+  "variables": [],
+  "metadata": {
+    "tags": [
+      "conformance",
+      "dispatch",
+      "per-item-input"
+    ]
+  },
+  "settings": {
+    "timeout": 60000,
+    "maxRetries": 0
+  }
+}

package/fixtures.md

@@ -69,6 +69,9 @@ All fixtures MUST advertise:
 | Prompt All Four Kinds                     | `conformance-prompt-all-four-kinds`                                                             | RFC 0027 §A four-kind dispatch coverage with a MULTI-ENTRY `fewShotPromptRefs[]` array. Single `mock-ai` node with one ref per singular-kind slot (`systemPromptRef`, `userPromptRef`, `schemaHintPromptRef`) + two distinct templateIds in `fewShotPromptRefs[]`; host MUST emit 5 `agent.promptResolved` events (one per slot) AND 5 `prompt.composed` events. Multi-entry few-shot is the regression pin for `fewShotPromptRefs[slotIndex]` per-index resolution — a host that hard-codes `[0]` would emit the same template twice in the few-shot events and fail the per-templateId assertion. Capability-gated on `capabilities.prompts.supported`. | `completed`                                                                         | ≤ 10s                        |
 | Dispatch Loop                             | `conformance-dispatch-loop`                                                                     | Verifies `core.dispatch` loop mechanism                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `completed`                                                                         | ≤ 30s                        |
 | Dispatch Fan-Out Race | `conformance-dispatch-fanout-race` | RFC 0243 §A.2 — a `core.dispatch` node pinning `fanOutPolicy: 'parallel'` with a `race` join. A host that does not admit it refuses it at load, or at `createRun` with `400 validation_error` and `details.requiredCapability` (`v2-agents-fan-out`) | refused; no run | ≤ 5s |
+| Dispatch Fan-Out Waves | `conformance-dispatch-fanout-waves` | RFC 0243 §A.3 — a parallel `core.dispatch` (`maxConcurrency: 2`, `wait-all`/`collect`) whose supervisor's `mockDispatchPlan` names three `conformance-delay` children. At most `min(2, maxFanOut)` run at once and none is dropped. Gated on `agents.fanOut` admitting `wait-all` with `collect`. | `completed` | ≤ 30s |
+| Dispatch Per-Item Input | `conformance-dispatch-per-item` | RFC 0243 §A.4 — a sequential `core.dispatch` whose decision dispatches `conformance-dispatch-input-mapping-child` twice with `nextWorkerInputs` `item-a`, `item-b`. At `agents.fanOut.perItemInput: true` each child receives its item; otherwise the dispatch node fails `validation_error` and no child is dispatched. | `completed`, or `failed` without `perItemInput` | ≤ 30s |
+| Dispatch Per-Item Length Mismatch | `conformance-dispatch-per-item-mismatch` | `orchestrator-decision.schema.json` `nextWorkerInputs` — one item for two children. Every dispatch host fails the dispatch node `validation_error` and dispatches no child. | `failed` | ≤ 30s |
 | Interrupt — Quorum                        | `conformance-interrupt-quorum`                                                                  | Verifies `openwop-interrupt-quorum` profile (multi-approver, majority rejection)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `completed` after 3 accepts, `failed` after quorum reject (major 2: `approval_rejected`) | unbounded (suspends)         |
 | Interrupt — External Event                | `conformance-interrupt-external-event`                                                          | Verifies `openwop-interrupt-external-event` profile (correlation-matched callback)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | `completed` after matching POST, `failed` on timeout                                | ≤ 60s (timeoutMs configured) |
 | Interrupt — Auth Required                 | `conformance-interrupt-auth-required`                                                           | Verifies `openwop-interrupt-auth-required` profile (bearer-token resume only)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | `completed` after bearer resolve                                                    | unbounded (suspends)         |
@@ -396,6 +399,47 @@ The `messages`-mode stream fixture (AI token streaming) is covered by the determ
 ---
 
 
+### `conformance-dispatch-fanout-waves`
+
+- **Purpose**: observe the RFC 0243 §A.3 breadth rule: the effective concurrency is `min(config.maxConcurrency, maxFanOut)`, children beyond it run in waves, and none is dropped (`spec/v2/facets/agents.schema.json` §fanOut).
+- **Topology**: `core.orchestrator.supervisor` ⇄ `core.dispatch`. The supervisor's `config.mockDispatchPlan` is `next-worker` with `nextWorkerIds` three times `conformance-delay`, then `terminate`. The dispatch node is `{ workerDispatchModel: "child-run", fanOutPolicy: "parallel", maxConcurrency: 2, joinPolicy: { mode: "wait-all", onChildFailure: "collect" } }`.
+- **Inputs**: none. Each child sleeps its default `delayMs` (1000).
+- **Conformance test driver**:
+  1. Skip unless `agents.dispatch` is `true`, `agents.fanOut` lists `wait-all` and `collect`, and discovery `fixtures` lists this fixture and `conformance-delay`.
+  2. POST `/runs` with `{workflowId: "conformance-dispatch-fanout-waves"}`; poll until terminal.
+  3. **Assert** the run completed; one `dispatch.fanned-out` with `childCount` 3 and any `maxConcurrency` at most `min(2, maxFanOut)`; one `dispatch.joined` with `completedCount` 3, `failedCount` 0 and a `mergeOrder` of 3.
+  4. Read each child (`node.dispatched`, else `mergeOrder`). **Assert** three children, each `completed`, and that no more than `min(2, maxFanOut)` of their `startedAt`..`completedAt` windows overlap by more than 100 ms.
+- **Terminal status**: `completed`.
+- **Server prerequisites**: the supervisor emits the `mockDispatchPlan` verbatim, as for `conformance-dispatch-cross-worker-handoff`.
+
+---
+
+### `conformance-dispatch-per-item`
+
+- **Purpose**: observe the RFC 0243 §A.4 gate on `nextWorkerInputs`: honored at `agents.fanOut.perItemInput: true`, failed closed otherwise.
+- **Topology**: `core.orchestrator.supervisor` ⇄ `core.dispatch` (`fanOutPolicy: "sequential"`). The `mockDispatchPlan` is `next-worker` with `nextWorkerIds` twice `conformance-dispatch-input-mapping-child` and `nextWorkerInputs` `[{childGreeting: "item-a"}, {childGreeting: "item-b"}]`, then `terminate`.
+- **Inputs**: none.
+- **Conformance test driver**:
+  1. Skip unless `agents.dispatch` is `true` and discovery `fixtures` lists this fixture and `conformance-dispatch-input-mapping-child`.
+  2. POST `/runs`; poll until terminal; read each child found by `node.dispatched`.
+  3. At `perItemInput: true`, **assert** the run completed, two children were dispatched, and their `inputs.childGreeting` are `item-a` and `item-b`.
+  4. Otherwise, **assert** the dispatch node's `node.failed` carries `error.code: "validation_error"`, no child was dispatched, and the run ended `failed`. A `400 validation_error` at `createRun` also satisfies this step.
+- **Terminal status**: `completed` at `perItemInput: true`; otherwise `failed`.
+- **Server prerequisites**: as `conformance-dispatch-fanout-waves`.
+
+---
+
+### `conformance-dispatch-per-item-mismatch`
+
+- **Purpose**: observe the length rule on `nextWorkerInputs` (`orchestrator-decision.schema.json`): a length that differs from `nextWorkerIds` fails the dispatch node with `validation_error` and dispatches no child.
+- **Topology**: as `conformance-dispatch-per-item`, with one item for two children.
+- **Inputs**: none.
+- **Conformance test driver**: steps 1, 2 and 4 of `conformance-dispatch-per-item`, on every dispatch host.
+- **Terminal status**: `failed`.
+- **Server prerequisites**: as `conformance-dispatch-fanout-waves`.
+
+---
+
 ### `conformance-dispatch-fanout-race`
 
 - **Purpose**: observe the RFC 0243 §A.2 refusal of a parallel fan-out the host does not admit (`spec/v2/facets/agents.schema.json` §fanOut).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openwop/openwop-conformance",
-  "version": "2.46.5",
+  "version": "2.46.7",
   "description": "Black-box conformance suite for OpenWOP hosts (v2 current; v1 scenarios retained for the frozen v1 tree).",
   "repository": {
     "type": "git",
@@ -56,6 +56,6 @@
     "@openwop/spec-artifacts": "file:../spec-artifacts"
   },
   "peerDependencies": {
-    "@openwop/spec-artifacts": "2.46.5"
+    "@openwop/spec-artifacts": "2.46.7"
   }
 }

package/requirements.json

@@ -2,11 +2,11 @@
   "$comment": "GENERATED by conformance/scripts/generate-requirement-registry.mjs — do not edit. One record per it()/test() in src/scenarios. Ids: openwop.it.<file-stem>.<title-slug>[~n] (src/lib/requirement-ids.ts). A record with id null has an interpolated title; its run-time row is keyed by the rendered title and maps here by file+line only. Renamed ids need a row in requirement-aliases.json.",
   "generatedFrom": "src/scenarios/*.test.ts",
   "counts": {
-    "files": 744,
-    "tests": 2797,
-    "withStableId": 2797,
+    "files": 745,
+    "tests": 2800,
+    "withStableId": 2800,
     "interpolatedTitles": 0,
-    "explicitIds": 2653
+    "explicitIds": 2673
   },
   "records": [
     {
@@ -28106,6 +28106,30 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-agents-fan-out-waves.children-beyond-the-effective-ceiling-are-dispatched-in-waves-and-none-is-droppe",
+      "file": "v2-agents-fan-out-waves.test.ts",
+      "line": 64,
+      "title": "children beyond the effective ceiling are dispatched in waves, and none is dropped",
+      "explicitId": "openwop.requirement.0243.max-fan-out-waves",
+      "citations": []
+    },
+    {
+      "id": "openwop.it.v2-agents-fan-out-waves.nextworkerinputs-reaches-each-child-at-periteminput-true-and-fails-closed-withou",
+      "file": "v2-agents-fan-out-waves.test.ts",
+      "line": 72,
+      "title": "nextWorkerInputs reaches each child at perItemInput: true, and fails closed without it",
+      "explicitId": "openwop.requirement.0243.per-item-input-gated",
+      "citations": []
+    },
+    {
+      "id": "openwop.it.v2-agents-fan-out-waves.a-nextworkerinputs-length-that-differs-from-nextworkerids-fails-the-dispatch-nod",
+      "file": "v2-agents-fan-out-waves.test.ts",
+      "line": 80,
+      "title": "a nextWorkerInputs length that differs from nextWorkerIds fails the dispatch node and dispatches no child",
+      "explicitId": "openwop.requirement.agents.dispatch-per-item-length-mismatch",
+      "citations": []
+    },
     {
       "id": "openwop.it.v2-agents-fan-out.a-host-advertising-agents-fanout-advertises-agents-dispatch-true",
       "file": "v2-agents-fan-out.test.ts",
@@ -30181,7 +30205,7 @@
       "file": "v2-dispatch-input-mapping.test.ts",
       "line": 59,
       "title": "inputMapping projects the parent variable into the dispatched child inputs",
-      "explicitId": null,
+      "explicitId": "openwop.requirement.agents.dispatch-input-mapping-projection",
       "citations": []
     },
     {
@@ -30189,7 +30213,7 @@
       "file": "v2-dispatch-input-mapping.test.ts",
       "line": 65,
       "title": "an unset parent variable projects to undefined: the child input is absent, never null",
-      "explicitId": null,
+      "explicitId": "openwop.requirement.agents.dispatch-input-mapping-unset-undefined",
       "citations": []
     },
     {
@@ -30197,7 +30221,7 @@
       "file": "v2-dispatch-loop.test.ts",
       "line": 63,
       "title": "each turn records its decision and terminate completes the run",
-      "explicitId": null,
+      "explicitId": "openwop.requirement.multi-agent.supervisor-loop-terminates",
       "citations": []
     },
     {
@@ -30205,7 +30229,7 @@
       "file": "v2-dispatch-loop.test.ts",
       "line": 69,
       "title": "every recorded decision is well-formed and the deciding agent never changes",
-      "explicitId": null,
+      "explicitId": "openwop.requirement.multi-agent.decision-recorded-well-formed",
       "citations": []
     },
     {
@@ -30213,7 +30237,7 @@
       "file": "v2-dispatch-loop.test.ts",
       "line": 75,
       "title": "at executionModel.version >= 5, iteration is 1-based and increments by exactly 1 per turn",
-      "explicitId": null,
+      "explicitId": "openwop.requirement.multi-agent.decision-iteration-monotonic",
       "citations": []
     },
     {
@@ -31433,7 +31457,7 @@
       "file": "v2-host-event-delivery.test.ts",
       "line": 174,
       "title": "an ephemeral host event has no id: and is not redelivered after Last-Event-ID",
-      "explicitId": null,
+      "explicitId": "openwop.requirement.0236.ephemeral.no-resume",
       "citations": []
     },
     {
@@ -31473,7 +31497,7 @@
       "file": "v2-host-event-delivery.test.ts",
       "line": 243,
       "title": "the same subscription never receives the ephemeral host event",
-      "explicitId": null,
+      "explicitId": "openwop.requirement.0236.ephemeral.no-fan-out",
       "citations": []
     },
     {
@@ -31481,7 +31505,7 @@
       "file": "v2-host-event-delivery.test.ts",
       "line": 256,
       "title": "emitTestHostEvent is served exactly for the listed host-test classes",
-      "explicitId": null,
+      "explicitId": "openwop.requirement.0241.trigger.bound-by-listing",
       "citations": []
     },
     {
@@ -31489,7 +31513,7 @@
       "file": "v2-host-event-delivery.test.ts",
       "line": 270,
       "title": "a second tenant receives nothing for the first tenant’s host event",
-      "explicitId": null,
+      "explicitId": "openwop.requirement.0236.host-event.tenant-isolation",
       "citations": []
     },
     {
@@ -36561,7 +36585,7 @@
       "file": "v2-safefetch-ssrf-refused.test.ts",
       "line": 166,
       "title": "an RFC 1918 target is refused egress_denied, ssrf-blocked",
-      "explicitId": null,
+      "explicitId": "openwop.requirement.httpClient.ssrf-rfc1918-refused",
       "citations": []
     },
     {
@@ -36569,7 +36593,7 @@
       "file": "v2-safefetch-ssrf-refused.test.ts",
       "line": 172,
       "title": "a link-local or cloud-metadata target is refused egress_denied, ssrf-blocked",
-      "explicitId": null,
+      "explicitId": "openwop.requirement.httpClient.ssrf-link-local-metadata-refused",
       "citations": []
     },
     {
@@ -37351,7 +37375,7 @@
       "file": "v2-subworkflow-input-mapping.test.ts",
       "line": 57,
       "title": "inputMapping seeds the child variable bag at creation",
-      "explicitId": null,
+      "explicitId": "openwop.requirement.sub-workflow.input-mapping-seeds-child",
       "citations": []
     },
     {
@@ -37359,7 +37383,7 @@
       "file": "v2-subworkflow-input-mapping.test.ts",
       "line": 63,
       "title": "the mapped parent value lands after and over the child defaultValue",
-      "explicitId": null,
+      "explicitId": "openwop.requirement.sub-workflow.input-mapping-overrides-default",
       "citations": []
     },
     {
@@ -37367,7 +37391,7 @@
       "file": "v2-subworkflow-input-mapping.test.ts",
       "line": 69,
       "title": "an unset parent variable arrives undefined, never an error or null",
-      "explicitId": null,
+      "explicitId": "openwop.requirement.sub-workflow.input-mapping-unset-undefined",
       "citations": []
     },
     {
@@ -37375,7 +37399,7 @@
       "file": "v2-subworkflow-linkage.test.ts",
       "line": 59,
       "title": "node.completed for the core.subWorkflow node carries outputs.childRunId and outputs.childStatus",
-      "explicitId": null,
+      "explicitId": "openwop.requirement.sub-workflow.node-completed-child-outputs",
       "citations": []
     },
     {
@@ -37383,7 +37407,7 @@
       "file": "v2-subworkflow-linkage.test.ts",
       "line": 65,
       "title": "outputMapping copies the child variable into the parent after the child completes",
-      "explicitId": null,
+      "explicitId": "openwop.requirement.sub-workflow.output-mapping-copied",
       "citations": []
     },
     {
@@ -37391,7 +37415,7 @@
       "file": "v2-subworkflow-linkage.test.ts",
       "line": 71,
       "title": "getRunAncestry names the parent run with cause core.subWorkflow",
-      "explicitId": null,
+      "explicitId": "openwop.requirement.sub-workflow.ancestry-parent-link",
       "citations": []
     },
     {

package/scenario-majors.json

@@ -1,9 +1,9 @@
 {
   "$comment": "GENERATED by conformance/scripts/generate-scenario-majors.mjs (RFC 0168 §D.3). Do not edit; add a file to BOTH_MAJORS in the generator to target both majors.",
   "counts": {
-    "files": 656,
+    "files": 657,
     "v1": 455,
-    "v2": 216
+    "v2": 217
   },
   "majors": {
     "a2a-1-0-agent-card.test.ts": [
@@ -1302,6 +1302,9 @@
     "v2-agent-runtime-advertisement.test.ts": [
       2
     ],
+    "v2-agents-fan-out-waves.test.ts": [
+      2
+    ],
     "v2-agents-fan-out.test.ts": [
       2
     ],

package/schemas/CORPUS-STAMP.json

@@ -1,17 +1,17 @@
 {
   "_comment": "Provenance of @openwop/spec-artifacts (RFC 0168 §D.2). files: SHA-256 per file; the conformance suite compares the installed peer against dist/spec-artifacts.lock.json at start.",
   "package": "@openwop/spec-artifacts",
-  "version": "2.46.5",
-  "corpusTag": "v2.46.5",
+  "version": "2.46.7",
+  "corpusTag": "v2.46.7",
   "files": {
     "api/.redocly.lint-ignore.yaml": "bf5a8350b88a72fa43f59605ed8d903ed24b6cfccda5e45509c9f6ed9ee4e712",
     "api/asyncapi.yaml": "d5ecb9ee6114582be3b1f662c84bfac9ae96dae7bacb853e461168f70a8e1c7d",
     "api/grpc/openwop.proto": "c3e72bb17cba514ee98feb6434e6c9b6ea6795bfd086489ec69fd882dd1ad977",
     "api/openapi.yaml": "ac6de5303872664b78ff419c035915593e01599e02835e777a0123de1baeb398",
     "api/redocly.yaml": "b0604c89b2ca6d5076ec25725c539dad44a741a811fe524439ee6daef8baa09f",
-    "api/seams-v2.yaml": "d24c33f8922c3013801ec951c81ea66f77060769b8cd9daad3b8d1f75b7c5eb7",
-    "api/v2/asyncapi.yaml": "13dcfe2684e3f12f47222c10b582731f0a72ce9d70758c208bd37e454041fc66",
-    "api/v2/openapi.yaml": "b7b485f7bab904669f25b8307b4b17fe88e971eb156d258f3cae73492ce5e6ff",
+    "api/seams-v2.yaml": "1f51bb8566237c46f9df4d262f218667143e72664a56403838787360f0e543fb",
+    "api/v2/asyncapi.yaml": "a4f623300eee3948f8debdf07cdf82c26ae7e6ceb9a6a15bd72a31adcd103690",
+    "api/v2/openapi.yaml": "f1229644f8d1fa6d9e9b7e3ed83595e45daaf20ba4c8cad6b52fbdfa335b3575",
     "api/v2/redocly.yaml": "1e66b60e6118ad11a823bb620678be464d99dfe50a40e3e6f93ec9429b88b34c",
     "schemas/README.md": "276fc1d51eb08e14e9127b9fd27761d7046ee33c12000f3a64a801322db8bf58",
     "schemas/a2a-task-state.schema.json": "75d5049dea8bd873ff0e7546f1c60c8d36c219bec7084264360be54a8be30ae1",
@@ -208,14 +208,14 @@
     "schemas/workspace-file.schema.json": "464de85c2a068243084ee9c1d969bc7cd5d8f7948574e58450d6493c38a0e1e4",
     "spec/v1/alias-detectors.json": "22444c22bb88c568339ef512553f9fc38146e22b566d11ab8608f655d688d19c",
     "spec/v1/capability-declaration-classes.json": "e7729aed5c4b4e1dd02abab0530f14cc95f5d4070fe51fb139e7f5cccefa00c6",
-    "spec/v1/core-standard-manifest.json": "7a626658a36a5ab612b7ed0be33773c9b0f2e2e5f80cc7244dcb962d4a4bc62d",
+    "spec/v1/core-standard-manifest.json": "5c3946728d3bb64d4cf290e93156788445da37272d4e44a4da803be695f9b543",
     "spec/v1/deprecations.json": "e723bc11d7272c71789ad1303bb7f21809a8a024abf57594f9d5c35dc199ece9",
     "spec/v1/deprecations.schema.json": "3e393c405d2a41b467d8c5e3c468549078df1ce6a6d2588fc488097b95d9b55b",
     "spec/v1/end-of-support.json": "35f0bf3b70fe78b16e2a2fd81a153fc27e703f6c16376c6fe7cdf1f4f2c4e6d4",
     "spec/v1/event-codemap.json": "3da60d884157793a360da532a9fcbbfb5285636db325a74cec94b34622186d97",
     "spec/v1/event-codemap.schema.json": "d05933b2e88103aff51a2f774df97b9bda065e0fc88dbd9b114cc47a32189174",
     "spec/v1/extensions.json": "79a60754aa16cbdbdb604f8e5c00038af535a1690a4d07bd5ff7c38f0256a7bc",
-    "spec/v1/gaps.json": "e99666a5b15814ee1e5a109924c992f3b15a4fdae70e3c1f0f790f2099137686",
+    "spec/v1/gaps.json": "e31dd0a2c440ff38469a8033e3324f372278ee94d209e0f84207d2111123f506",
     "spec/v1/gaps.schema.json": "8fd83259f556553c9df0f53e7a82ca8c2a4771d471197f69b4e2ae0ceeacfd66",
     "spec/v1/migrations.json": "4c50760be70cb644d02427bcaf5749606700edf4513f423903cf3b1d12f5c300",
     "spec/v1/migrations.schema.json": "886779aa6c22e646db097f5df210adb018a4dd14a7b815465a18c8a7056c8f72",
@@ -313,9 +313,9 @@
     "spec/v2/path-manifest.json": "7b5679a4dad98c80d855361d88a98c8a4e045af15e310862a05b285b815dc9fc",
     "spec/v2/peer-dependency-aliases.json": "d10299280abee08258502925bc327293ee413e0108cd6e6ec75ff6110653308d",
     "spec/v2/profiles.json": "b382b261c7844798575f7c1b37c934f0da19846016a2337d883d4f5ef6e05479",
-    "spec/v2/release.json": "5a677aeedc38b41d42e2e8bd4dbe56f98cefc23673fd9f718787d22c176ef0fc",
+    "spec/v2/release.json": "1348d062c28c19897650cecb1f968c61adece3a61fdc4ecb8b7d8675468b7f65",
     "spec/v2/retention-floors.json": "eaf3722d95c79947af1d4269ef85117e126518c588cfcf1a2b21b97269f51624",
-    "spec/v2/surface-baseline.json": "4e0350c79c6415b758386f19b7d52971d4bc27dd79984b2cf11d5906ca45df86"
+    "spec/v2/surface-baseline.json": "185c226ce4868f6d435275b1005890c9328c18f2f86163f4622cce8b0dec63e3"
   },
-  "corpusCommit": "89ee5f47a9c41ffa3a1e12531492125e97bc7df9"
+  "corpusCommit": "b7f55b6d06df56983be5a9e9d518dd5a8fae8b29"
 }

package/src/lib/fan-out-witness.ts

@@ -0,0 +1,233 @@
+/**
+ * RFC 0243 G2: the `agents.fanOut` breadth and per-item witnesses, fixture
+ * runs through `POST /runs`, `events/poll` and `GET /runs/{runId}`. No seam:
+ * each fixture's supervisor carries a `mockDispatchPlan`, so the decision is
+ * the fixture's, not a model's.
+ *
+ * Waves (`spec/v2/facets/agents.schema.json` §fanOut `maxFanOut`: "the
+ * effective concurrency is `min(config.maxConcurrency ?? ∞, maxFanOut ?? ∞)`,
+ * children beyond it are dispatched in waves and none is dropped"), on
+ * `conformance-dispatch-fanout-waves` (three `conformance-delay` children,
+ * `maxConcurrency: 2`):
+ *   the parallel path records one `dispatch.fanned-out` (`childCount` 3, any
+ *   `maxConcurrency` within the effective ceiling) and one `dispatch.joined`
+ *   (3 completed, none failed, `mergeOrder` of 3); three child runs complete;
+ *   and no more than the ceiling of them are in flight at once, judged from
+ *   each child's `startedAt`..`completedAt`.
+ *
+ * Per-item input (the facet's `perItemInput`; `orchestrator-decision.schema.json`
+ * `nextWorkerInputs`), on `conformance-dispatch-per-item` (one child workflow
+ * twice, items `item-a` and `item-b`):
+ *   honored      at `perItemInput: true`, two children are dispatched and
+ *                their `inputs.childGreeting` are the two items;
+ *   fail closed  otherwise, the dispatch node fails `validation_error` and no
+ *                child is dispatched.
+ * Length mismatch (`nextWorkerInputs`: "`nextWorkerInputs.length` MUST equal
+ * `nextWorkerIds.length`"), on `conformance-dispatch-per-item-mismatch`: on
+ * every dispatch host, the dispatch node fails `validation_error` and no child
+ * is dispatched.
+ *
+ * Fail closed is also read as satisfied by a `400 validation_error` at
+ * `createRun` with no run: either way no child exists, which is the hazard.
+ *
+ * The drivers observe and assert nothing; the judges are pure, proven in
+ * `fan-out-witness.test.ts`.
+ */
+
+import { isFixtureAdvertised } from './fixtures.js';
+import type { MajorProfile } from './major-profile.js';
+import {
+  finding, isRecord, observed, observeRun, readRun, runCompleted, skip,
+  type Ev, type Finding, type ObservedRun, type ObserveOpts, type Outcome, type RunRead, type Skip,
+} from './fixture-run-observer.js';
+
+export const WAVES_FIXTURE = 'conformance-dispatch-fanout-waves';
+export const WAVES_CHILD = 'conformance-delay';
+export const PER_ITEM_FIXTURE = 'conformance-dispatch-per-item';
+export const PER_ITEM_MISMATCH_FIXTURE = 'conformance-dispatch-per-item-mismatch';
+export const PER_ITEM_CHILD = 'conformance-dispatch-input-mapping-child';
+export const PER_ITEM_VALUES = ['item-a', 'item-b'] as const;
+export const DISPATCH_NODE = 'dispatch';
+/** The fixture's `maxConcurrency`. */
+export const WAVES_MAX_CONCURRENCY = 2;
+export const WAVES_CHILDREN = 3;
+/**
+ * Two child windows that touch within this many milliseconds are not counted as
+ * overlapping: a host stamps a child's `completedAt` and the next child's
+ * `startedAt` from separate clocks reads. A real breach overlaps by a whole
+ * `conformance-delay` (1000 ms by default).
+ */
+export const OVERLAP_TOLERANCE_MS = 100;
+
+const DOC_FANOUT = 'agents.schema.json §fanOut';
+const DOC_ITEMS = 'orchestrator-decision.schema.json nextWorkerInputs';
+
+export interface FanOutObservation {
+  readonly run: ObservedRun;
+  /** Child run ids in dispatch order, from `node.dispatched` (else the join's `mergeOrder`). */
+  readonly childRunIds: readonly string[];
+  readonly children: readonly RunRead[];
+  /** `fannedType` / `joinedType` / `dispatchedType`: this major's event names. */
+  readonly types: { readonly fanned: string; readonly joined: string; readonly dispatched: string };
+}
+
+export interface WavesObservation extends FanOutObservation {
+  /** `min(maxConcurrency, maxFanOut ?? ∞)`. */
+  readonly ceiling: number;
+}
+
+export interface PerItemObservation extends FanOutObservation {
+  /** The host advertises `agents.fanOut.perItemInput: true`. */
+  readonly perItemInput: boolean;
+  /** The `createRun` body, for a refusal there. */
+  readonly createBody: unknown;
+}
+
+function eventTypes(profile: MajorProfile): Skip | FanOutObservation['types'] {
+  const fanned = profile.eventType('core.dispatch.fanOut');
+  const joined = profile.eventType('core.dispatch.join');
+  if (fanned === undefined || joined === undefined) return skip('blocked', 'the event codemap is not on disk in this layout — the suite will not guess an event name');
+  return { fanned, joined, dispatched: profile.eventType('node.dispatched') ?? 'node.dispatched' };
+}
+
+/** `agents.dispatch: true`, and the fixtures. */
+function dispatchGate(profile: MajorProfile, doc: unknown, fixtures: readonly string[]): Skip | { readonly agents: Record<string, unknown> } {
+  const agents = profile.family(doc, 'agents');
+  if (agents === null || agents['dispatch'] !== true) return skip('inapplicable', 'the host does not advertise agents.dispatch: true, so core.dispatch does not bind it');
+  for (const id of fixtures) if (!isFixtureAdvertised(id)) return skip('inapplicable', `fixture ${id} is not advertised — the fixture is the opt-in`);
+  return { agents };
+}
+
+/** `agents.fanOut` admitting a `wait-all` join with `collect`, and the fixtures. */
+export function wavesGate(profile: MajorProfile, doc: unknown): Skip | { ceiling: number } {
+  const g = dispatchGate(profile, doc, [WAVES_FIXTURE, WAVES_CHILD]);
+  if ('kind' in g) return g;
+  const f = g.agents['fanOut'];
+  if (!isRecord(f)) return skip('inapplicable', 'the host does not advertise agents.fanOut, so it runs no parallel fan-out (the race fixture witnesses its refusal)');
+  const has = (k: string, v: string): boolean => Array.isArray(f[k]) && (f[k] as unknown[]).includes(v);
+  if (!has('joinModes', 'wait-all') || !has('onChildFailureModes', 'collect')) return skip('inapplicable', 'agents.fanOut does not admit a wait-all join with collect, which this fixture pins');
+  const max = typeof f['maxFanOut'] === 'number' && f['maxFanOut'] >= 1 ? f['maxFanOut'] : Infinity;
+  return { ceiling: Math.min(WAVES_MAX_CONCURRENCY, max) };
+}
+
+/** `agents.dispatch: true` and the per-item fixture (or the mismatch fixture) plus its child. */
+export function perItemGate(profile: MajorProfile, doc: unknown, fixture: string): Skip | { perItemInput: boolean } {
+  const g = dispatchGate(profile, doc, [fixture, PER_ITEM_CHILD]);
+  if ('kind' in g) return g;
+  const f = g.agents['fanOut'];
+  return { perItemInput: isRecord(f) && f['perItemInput'] === true };
+}
+
+/** The dispatched children of one workflow, in log order: `node.dispatched`, else the join's `mergeOrder`. */
+export function locateChildren(events: readonly Ev[], types: FanOutObservation['types'], childWorkflowId: string): string[] {
+  const ids = events
+    .filter((e) => e.type === types.dispatched && e.payload['childWorkflowId'] === childWorkflowId && typeof e.payload['childRunId'] === 'string')
+    .map((e) => e.payload['childRunId'] as string);
+  if (ids.length > 0) return [...new Set(ids)];
+  const join = events.find((e) => e.type === types.joined);
+  const mo = join?.payload['mergeOrder'];
+  return Array.isArray(mo) ? [...new Set(mo.filter((x): x is string => typeof x === 'string'))] : [];
+}
+
+async function follow(profile: MajorProfile, workflowId: string, child: string, types: FanOutObservation['types'], opts: ObserveOpts): Promise<FanOutObservation & { createBody: unknown }> {
+  const run = await observeRun(profile, workflowId, { timeoutMs: 45_000, ...opts });
+  const childRunIds = locateChildren(run.events, types, child);
+  const children = await Promise.all(childRunIds.map((id) => readRun(profile, id)));
+  return { run, childRunIds, children, types, createBody: run.createBody };
+}
+
+/** Run the waves fixture and read its children. Asserts nothing. */
+export async function driveWaves(profile: MajorProfile, doc: unknown, opts: ObserveOpts = {}): Promise<Skip | WavesObservation> {
+  const g = wavesGate(profile, doc);
+  if ('kind' in g) return g;
+  const types = eventTypes(profile);
+  if ('kind' in types) return types;
+  return { ...(await follow(profile, WAVES_FIXTURE, WAVES_CHILD, types, opts)), ceiling: g.ceiling };
+}
+
+/** Run a per-item fixture and read its children. Asserts nothing. */
+export async function drivePerItem(profile: MajorProfile, doc: unknown, fixture: string, opts: ObserveOpts = {}): Promise<Skip | PerItemObservation> {
+  const g = perItemGate(profile, doc, fixture);
+  if ('kind' in g) return g;
+  const types = eventTypes(profile);
+  if ('kind' in types) return types;
+  return { ...(await follow(profile, fixture, PER_ITEM_CHILD, types, opts)), perItemInput: g.perItemInput };
+}
+
+const ofType = (o: FanOutObservation, t: string): Ev[] => o.run.events.filter((e) => e.type === t && (e.nodeId === undefined || e.nodeId === DISPATCH_NODE));
+const time = (v: unknown): number | undefined => (typeof v === 'string' && !Number.isNaN(Date.parse(v)) ? Date.parse(v) : undefined);
+
+/** The largest number of `[start, end]` windows in flight at once, ignoring touches within `tolerance`. Pure. */
+export function maxInFlight(windows: ReadonlyArray<readonly [number, number]>, tolerance = OVERLAP_TOLERANCE_MS): number {
+  if (windows.length === 0) return 0;
+  // A window counts from `tolerance` after its start; one shorter than that cannot overlap anything.
+  const points = windows.filter(([s, e]) => s + tolerance < e).flatMap(([s, e]) => [[s + tolerance, 1], [e, -1]] as const);
+  // At the same instant an end closes before a start opens, so touching windows never overlap.
+  points.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  let cur = 0;
+  let best = 1;
+  for (const [, d] of points) { cur += d; best = Math.max(best, cur); }
+  return best;
+}
+
+/** Leg: waves within the ceiling, none dropped. Pure. */
+export function judgeWaves(o: WavesObservation): Outcome {
+  const fanned = ofType(o, o.types.fanned);
+  const joined = ofType(o, o.types.joined);
+  const f = fanned[0]?.payload ?? {};
+  const j = joined[0]?.payload ?? {};
+  const mc = f['maxConcurrency'];
+  const windows = o.children.map((c) => [time(c.snapshot['startedAt']), time(c.snapshot['completedAt'])] as const);
+  const timed = windows.every(([s, e]) => s !== undefined && e !== undefined);
+  const findings: Finding[] = [
+    ...runCompleted(o.run),
+    finding(fanned.length === 1, `${DOC_FANOUT} (run-event-payloads dispatchFanOut)`, `a parallel dispatch MUST record one ${o.types.fanned} (got ${fanned.length})`),
+    finding(f['childCount'] === WAVES_CHILDREN, `${DOC_FANOUT} (none is dropped)`, `${o.types.fanned}.childCount MUST be ${WAVES_CHILDREN}, every child the decision named (got ${JSON.stringify(f['childCount'])})`),
+    finding(mc === undefined || (typeof mc === 'number' && mc <= o.ceiling), `${DOC_FANOUT} (effective concurrency is min(maxConcurrency, maxFanOut))`, `${o.types.fanned}.maxConcurrency MUST NOT exceed ${o.ceiling} (got ${JSON.stringify(mc)})`),
+    finding(joined.length === 1, `${DOC_FANOUT} (run-event-payloads dispatchJoin)`, `the wait-all join MUST record one ${o.types.joined} (got ${joined.length})`),
+    finding(j['completedCount'] === WAVES_CHILDREN && j['failedCount'] === 0, `${DOC_FANOUT} (none is dropped)`, `${o.types.joined} MUST count ${WAVES_CHILDREN} completed and 0 failed (got ${JSON.stringify({ completedCount: j['completedCount'], failedCount: j['failedCount'] })})`),
+    finding(Array.isArray(j['mergeOrder']) && j['mergeOrder'].length === WAVES_CHILDREN, `${DOC_FANOUT} (run-event-payloads dispatchJoin.mergeOrder)`, `${o.types.joined}.mergeOrder MUST list all ${WAVES_CHILDREN} children (got ${JSON.stringify(j['mergeOrder'])})`),
+    finding(o.childRunIds.length === WAVES_CHILDREN, `${DOC_FANOUT} (none is dropped)`, `${WAVES_CHILDREN} distinct ${WAVES_CHILD} child runs MUST be dispatched (found ${o.childRunIds.length})`),
+    ...o.children.map((c, i) => finding(c.status === 200 && c.snapshot['status'] === 'completed', `fixtures.md ${WAVES_CHILD}`, `child run ${o.childRunIds[i]} MUST be readable and end completed (GET ${c.status}, status ${JSON.stringify(c.snapshot['status'])})`)),
+  ];
+  if (timed && o.children.length > 0) {
+    const n = maxInFlight(windows as ReadonlyArray<readonly [number, number]>);
+    findings.push(finding(n <= o.ceiling, `${DOC_FANOUT} (children beyond the ceiling are dispatched in waves)`, `no more than ${o.ceiling} children may be in flight at once (${n} overlapped by more than ${OVERLAP_TOLERANCE_MS} ms)`));
+  }
+  return observed(findings);
+}
+
+/** The dispatch node failed `validation_error` and no child exists — at run time, or by a `400` at `createRun`. Pure. */
+export function judgeFailClosed(o: FanOutObservation & { createBody: unknown }, doc: string, why: string): Outcome {
+  const r = o.run;
+  if (r.createStatus === 400) {
+    const err = isRecord(o.createBody) ? o.createBody['error'] : undefined;
+    return observed([finding(err === 'validation_error', doc, `${why}: a refusal at createRun MUST be 400 validation_error (got ${JSON.stringify(err)})`)]);
+  }
+  const failed = r.events.filter((e) => e.type === 'node.failed' && e.nodeId === DISPATCH_NODE);
+  const code = isRecord(failed[0]?.payload['error']) ? failed[0]!.payload['error']['code'] : undefined;
+  return observed([
+    finding(r.createStatus === 201 || r.createStatus === 202, 'runs.md createRun', `createRun of ${r.workflowId} MUST be accepted or refused 400 validation_error (got ${r.createStatus})`),
+    finding(code === 'validation_error', doc, `${why}: the dispatch node MUST fail with validation_error (node.failed ${failed.length === 0 ? 'absent' : `code ${JSON.stringify(code)}`})`),
+    finding(o.childRunIds.length === 0 && ofType(o, o.types.dispatched).length === 0, doc, `${why}: no child may be dispatched (found ${o.childRunIds.length})`),
+    finding(r.terminalStatus === 'failed', doc, `the run MUST end failed (got ${String(r.terminalStatus)})`),
+  ]);
+}
+
+/** Leg: at `perItemInput: true` each child receives its own item; otherwise fail closed. Pure. */
+export function judgePerItem(o: PerItemObservation): Outcome {
+  if (!o.perItemInput) return judgeFailClosed(o, `${DOC_FANOUT} perItemInput; ${DOC_ITEMS}`, 'a host without agents.fanOut.perItemInput: true receiving non-empty nextWorkerInputs');
+  const got = o.children.map((c) => (isRecord(c.snapshot['inputs']) ? c.snapshot['inputs']['childGreeting'] : undefined));
+  const sorted = [...got].map(String).sort();
+  return observed([
+    ...runCompleted(o.run),
+    finding(o.childRunIds.length === PER_ITEM_VALUES.length, `${DOC_ITEMS} (index-aligned with nextWorkerIds)`, `${PER_ITEM_VALUES.length} ${PER_ITEM_CHILD} child runs MUST be dispatched (found ${o.childRunIds.length})`),
+    ...o.children.map((c, i) => finding(c.status === 200, 'runs.md getRun', `child run ${o.childRunIds[i]} MUST be readable (GET ${c.status})`)),
+    finding(JSON.stringify(sorted) === JSON.stringify([...PER_ITEM_VALUES]), `${DOC_FANOUT} perItemInput; ${DOC_ITEMS}`, `each child MUST receive its own nextWorkerInputs[i]: inputs.childGreeting MUST be ${JSON.stringify(PER_ITEM_VALUES)} across the children (got ${JSON.stringify(got)})`),
+  ]);
+}
+
+/** Leg: a length mismatch fails the dispatch node and dispatches no child. Pure. */
+export function judgeLengthMismatch(o: PerItemObservation): Outcome {
+  return judgeFailClosed(o, DOC_ITEMS, 'nextWorkerInputs.length differs from nextWorkerIds.length');
+}

package/src/lib/fixture-run-observer.ts

@@ -35,6 +35,8 @@ export interface RunRead { readonly status: number; readonly snapshot: Record<st
 export interface ObservedRun {
   readonly workflowId: string;
   readonly createStatus: number;
+  /** The `createRun` response body. */
+  readonly createBody?: unknown;
   readonly runId: string | undefined;
   readonly terminalStatus: string | undefined;
   /** The last `GET /runs/{runId}` body. */
@@ -78,11 +80,11 @@ export async function observeRun(profile: MajorProfile, workflowId: string, opts
   const created = await driver.post(profile.runsPath, { workflowId });
   const runId = isRecord(created.json) && typeof created.json['runId'] === 'string' ? created.json['runId'] : undefined;
   if ((created.status !== 201 && created.status !== 202) || runId === undefined) {
-    return { workflowId, createStatus: created.status, runId: undefined, terminalStatus: undefined, snapshot: {}, events: [] };
+    return { workflowId, createStatus: created.status, createBody: created.json, runId: undefined, terminalStatus: undefined, snapshot: {}, events: [] };
   }
   const r = await pollTerminal(profile, runId, opts);
   const status = r.snapshot['status'];
-  return { workflowId, createStatus: created.status, runId, terminalStatus: typeof status === 'string' ? status : undefined, snapshot: r.snapshot, events: await readEvents(profile, runId) };
+  return { workflowId, createStatus: created.status, createBody: created.json, runId, terminalStatus: typeof status === 'string' ? status : undefined, snapshot: r.snapshot, events: await readEvents(profile, runId) };
 }
 
 /** The create was accepted and the fixture run ended `completed`, as its catalog entry says. */

package/src/lib/run-graph-double.ts

@@ -30,6 +30,10 @@ export interface DoubleRun {
   readonly status: string;
   readonly variables?: Record<string, unknown> | undefined;
   readonly inputs?: Record<string, unknown> | undefined;
+  /** Further snapshot members (`startedAt`, `completedAt`, …). */
+  readonly snapshot?: Record<string, unknown> | undefined;
+  /** Refuse the create with this answer instead of making the run. */
+  readonly refuse?: { readonly status: number; readonly body: unknown } | undefined;
   readonly events?: readonly DoubleEvent[];
   /** The `GET /runs/{runId}/ancestry` answer, given the run's own id. Unset: 404. */
   readonly ancestry?: ((self: string) => { readonly status: number; readonly body: unknown }) | undefined;
@@ -103,6 +107,7 @@ export class RunGraphDouble {
       const self = this.mint();
       const run = this.opts.onCreate?.(workflowId, (child) => { const id = this.mint(); this.runs.set(id, child); return id; }, self);
       if (run === undefined) return this.send(res, 404, { error: 'not_found', message: `no workflow ${workflowId}` });
+      if (run.refuse !== undefined) return this.send(res, run.refuse.status, run.refuse.body);
       this.runs.set(self, { workflowId, ...run });
       return this.send(res, 201, { runId: self, status: 'running' });
     }
@@ -128,6 +133,7 @@ export class RunGraphDouble {
         runId: id, workflowId: run.workflowId ?? 'double', status: run.status,
         ...(run.variables === undefined ? {} : { variables: run.variables }),
         ...(run.inputs === undefined ? {} : { inputs: run.inputs }),
+        ...(run.snapshot ?? {}),
       });
     }
 

package/src/scenarios/v2-agents-fan-out-waves.test.ts

@@ -0,0 +1,87 @@
+/**
+ * v2 — `agents.fanOut` breadth and per-item input (RFC 0243 §A.3, §A.4; gap
+ * G2). The facet (`spec/v2/facets/agents.schema.json` §fanOut) states both:
+ * "children beyond [`maxFanOut`] are dispatched in waves and none is dropped",
+ * and "without [`perItemInput: true`], a non-empty `nextWorkerInputs` MUST fail
+ * the dispatch node with `validation_error` and dispatch no child".
+ * `orchestrator-decision.schema.json` `nextWorkerInputs` adds the length rule.
+ * The v1 twins are `dispatch-fanout-parallel` and `dispatch-per-item-input`,
+ * which drive a v1 seam; these legs need none. Each fixture's supervisor
+ * carries a `mockDispatchPlan`, and the legs live in `lib/fan-out-witness.ts`.
+ *
+ *   waves       `conformance-dispatch-fanout-waves`: three `conformance-delay`
+ *               children under `maxConcurrency: 2` all complete, the
+ *               fan-out and join events count three, and no more than
+ *               `min(2, maxFanOut)` children are in flight at once;
+ *   per-item    `conformance-dispatch-per-item`: at `perItemInput: true` each
+ *               child receives its own item; otherwise the dispatch node
+ *               fails `validation_error` and no child is dispatched;
+ *   mismatch    `conformance-dispatch-per-item-mismatch`: one item for two
+ *               children fails the dispatch node `validation_error`, no child.
+ *
+ * Dispositions: `agents.dispatch` not `true`, or a fixture (or its child) not
+ * in `fixtures[]` ⇒ `inapplicable`; for waves, `agents.fanOut` absent or not
+ * admitting `wait-all` with `collect` ⇒ `inapplicable`; discovery unreadable ⇒
+ * `blocked`.
+ *
+ * Proven against doubles in `lib/fan-out-witness.test.ts`.
+ *
+ * @see spec/v2/facets/agents.schema.json §fanOut
+ * @see schemas/v2/orchestrator-decision.schema.json §nextWorkerInputs
+ * @see RFCS/0243-dispatch-fan-out-seat.md
+ */
+
+import { describe, it, expect } from 'vitest';
+import { v2Discovery } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { majorProfile } from '../lib/major-profile.js';
+import type { Outcome, Skip } from '../lib/fixture-run-observer.js';
+import {
+  PER_ITEM_FIXTURE, PER_ITEM_MISMATCH_FIXTURE, drivePerItem, driveWaves, judgeLengthMismatch, judgePerItem, judgeWaves,
+  type PerItemObservation, type WavesObservation,
+} from '../lib/fan-out-witness.js';
+
+const PROFILE = majorProfile(2);
+const ID_WAVES = 'openwop.requirement.0243.max-fan-out-waves';
+const ID_PER_ITEM = 'openwop.requirement.0243.per-item-input-gated';
+const ID_MISMATCH = 'openwop.requirement.agents.dispatch-per-item-length-mismatch';
+
+async function discovery(): Promise<Record<string, unknown> | (() => undefined)> {
+  if (!process.env['OPENWOP_BASE_URL']) return () => softSkip('inapplicable', 'no target: OPENWOP_BASE_URL is unset');
+  let doc: Record<string, unknown> | null;
+  try { doc = await v2Discovery(); } catch { doc = null; }
+  return doc ?? (() => softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0'));
+}
+function assert(id: string, out: Outcome): undefined {
+  if (out.kind === 'skip') return softSkip(out.disposition, out.reason);
+  for (const x of out.findings) expect(x.ok, req(id, x.doc, x.message)).toBe(true);
+  return undefined;
+}
+const unwrap = <T,>(o: Skip | T): T | (() => undefined) => (o !== null && typeof o === 'object' && 'kind' in o && (o as Skip).kind === 'skip' ? () => softSkip((o as Skip).disposition, (o as Skip).reason) : (o as T));
+
+describe('v2 agents.fanOut: waves and per-item input (RFC 0243 §A.3, §A.4)', () => {
+  it('children beyond the effective ceiling are dispatched in waves, and none is dropped', async () => {
+    const doc = await discovery();
+    if (typeof doc === 'function') return doc();
+    const o = unwrap<WavesObservation>(await driveWaves(PROFILE, doc));
+    if (typeof o === 'function') return o();
+    return assert(ID_WAVES, judgeWaves(o));
+  }, 90_000);
+
+  it('nextWorkerInputs reaches each child at perItemInput: true, and fails closed without it', async () => {
+    const doc = await discovery();
+    if (typeof doc === 'function') return doc();
+    const o = unwrap<PerItemObservation>(await drivePerItem(PROFILE, doc, PER_ITEM_FIXTURE));
+    if (typeof o === 'function') return o();
+    return assert(ID_PER_ITEM, judgePerItem(o));
+  }, 90_000);
+
+  it('a nextWorkerInputs length that differs from nextWorkerIds fails the dispatch node and dispatches no child', async () => {
+    const doc = await discovery();
+    if (typeof doc === 'function') return doc();
+    const o = unwrap<PerItemObservation>(await drivePerItem(PROFILE, doc, PER_ITEM_MISMATCH_FIXTURE));
+    if (typeof o === 'function') return o();
+    return assert(ID_MISMATCH, judgeLengthMismatch(o));
+  }, 90_000);
+});