## Summary In a ReAct loop that is re-entered by a critic (Reflexion pattern), a round in which the agent answers **without calling a tool** fails the whole pipeline instead of skipping the tool branch. The Clause 2 verdict in `JobGenerationService::getUnsatisfiableJobs()` marks the in-loop consumer of the tool node FAILED with: ``` Job 4862 failed: port 'value' cannot be satisfied in round 2 — its only in-loop source 'flowdrop_node_processor_tool_invoke.1' can no longer produce a value for this round StateManager: marked state error for thread playground_session_185: Pipeline execution failed Job 4824 failed: Sub-workflow reflexion_agent_engine failed: Workflow execution failed Synchronous pipeline execution failed for pipeline 549: Sub-workflow reflexion_agent_engine failed: Workflow execution failed ``` The agent had already produced its revised answer in that round; nothing is emitted. Reproduced 3 times out of 12 runs across two models (Haiku 4.5 small + medium, Sonnet 4.6 small). Every run in which the agent called a tool in *every* round completed. The failure is decided by whether the model calls a tool on the revision round, which is not something a workflow author controls. ## Topology (sub-workflow `reflexion_agent_engine`) Standard ReAct body, plus a critic after the loop exit: ``` conversation_buffer.1 (loop head, input loop_back) → reason.1 ── has_tool_calls ──▶ boolean_gateway.1 True ──▶ tool_invoke.1 ── executed_any ──▶ boolean_gateway.2 ── True ──▶ conversation_buffer.2 ── appended_any ──▶ conversation_buffer.1.loop_back False ──▶ message_from_text.3 → … → message_assemble.2 → reason.2 (critic) ── text ──▶ if_else.1 if_else.1 True (ACCEPT) ──▶ text_output.1 if_else.1 False (REVISE) ──▶ conversation_buffer.6 → if_else.2 (count < 3) False ──▶ conversation_buffer.7 ── appended_any ──▶ conversation_buffer.1.loop_back ``` `boolean_gateway.2` has exactly one incoming edge: a **data** edge from `tool_invoke.1` (`executed_any` → `value`). No trigger edge, no error edge. ## Sequence 1. **Round 1.** `reason.1` emits a tool call → `gateway.1` True → `tool_invoke.1` runs → `gateway.2` gets `executed_any` → loop back. Round 1 jobs for `tool_invoke.1` and `gateway.2` are completed. 2. `reason.1` answers without a tool call → `gateway.1` False → critic → REVISE → `conversation_buffer.7` → `loop_back` → **round 2**. 3. **Round 2.** `reason.1` revises the answer **without calling a tool** (it already has the page). `gateway.1` False → `tool_invoke.1` is not dispatched this round. 4. `gateway.2` has an idle round-2 job. Its only source `tool_invoke.1` has a completed, branch-active job — from round 1. `dataEdgeIsRoundGated()` returns TRUE (the value exists, it is from an older round), so Clause 2 fires and the job is FAILED + error_routed. `gateway.2` has no error edge → pipeline fails → parent sub-workflow node fails. ## Why this looks like a bug rather than the intended Clause 2 verdict The docblock on `getUnsatisfiableJobs()` draws the line explicitly: > An edge that is unsatisfied for any older reason — the source never ran, or a gateway routed away from it in a round nobody is waiting on — means the node was not meant to run, and has always terminated through the end-of-run skip sweep. Clause 2 must not convert that second case into a failure. That is this case: `gateway.1` routed away from `tool_invoke.1` in round 2, so `gateway.2` was not meant to run in round 2. But the "only a port Clause 1 actually gated" restriction is evaluated against the source's **newest completed** job, and that job is the round-1 one — so a source that was legitimately skipped *this* round is indistinguishable from a source that is round-behind. The restriction that exists to keep Clause 2 from becoming "a general unfillable-port rule" is what fires here. Two smaller observations: - `unsatisfiablePortMessage()` returned the degraded wording ("can no longer produce a value") rather than "was skipped by gateway 'boolean_gateway.1'", although `tool_invoke.1`'s only trigger edge is the `True` branch of `gateway.1`, whose newest job completed with `False`. `gatewayThatRoutedAway()` did not find it, so the author is sent to the wrong place. - The same body works in a plain ReAct engine only because the loop exits on the first no-tool round; there is never a round in which the tool branch is skipped *and* a later consumer waits on it. ## Expected A node whose only in-loop source was routed away by a gateway in the consumer's own round should terminate via the BR-7 skip sweep (and cascade the skip to `conversation_buffer.2`), the same way it does when the source never ran at all. Only a source that is genuinely round-behind with no upstream gateway decision against it should fail under Clause 2. ## Environment - drupal/flowdrop `2.x-dev` (`41779a34ee`), synchronous orchestrator - Drupal 11, PHP 8.4, ddev - Parent workflow `bench_9_reflexion_with_tools_in_parent`, sub-workflow `reflexion_agent_engine` (both exported in https://github.com/d34dman/flowdrop-drupal-demo, `config/sync/`) - Runs: 3 failures / 12 (Haiku 4.5: small, medium; Sonnet 4.6: small; Sonnet 5: none, it called a tool in every round)