steerdev 1.0.39__tar.gz → 1.0.52__tar.gz

{steerdev-1.0.39 → steerdev-1.0.52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerdev
-Version: 1.0.39
+Version: 1.0.52
 Summary: Backend task runner for steerdev.com - orchestrates CLI coding agents with activity reporting
 Project-URL: Homepage, https://github.com/pentoai/steerdev-agent
 Project-URL: Repository, https://github.com/pentoai/steerdev-agent

{steerdev-1.0.39 → steerdev-1.0.52}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "steerdev"
-version = "1.0.39"
+version = "1.0.52"
 description = "Backend task runner for steerdev.com - orchestrates CLI coding agents with activity reporting"
 readme = "README.md"
 authors = [

{steerdev-1.0.39 → steerdev-1.0.52}/src/steerdev_agent/agent_loop.py

@@ -36,9 +36,11 @@ from steerdev_agent.api.sessions import SessionCreateRequest, SessionsClient
 from steerdev_agent.api.tasks import TasksClient
 from steerdev_agent.config.models import (
     AgentLoopConfig,
+    EvidenceConfig,
     ExecutorConfig,
     RetryConfig,
     WorkspaceConfig,
+    WorktreeConfig,
 )
 from steerdev_agent.executor import ExecutorFactory
 from steerdev_agent.executor.base import EventType
@@ -60,7 +62,7 @@ class CommandExecutor:
     """Shared command execution dispatch for both project and workspace agents.
 
     Subclasses provide: _api_key, agent_type, agent_name, model, max_turns,
-    _executor_config, _workflow_id, _enable_worktrees, _agent_loop_config,
+    _executor_config, _workflow_id, _worktree_config, _agent_loop_config,
     _commands_client, _sessions_client, _shutdown_event, and the stats counters.
     """
 
@@ -75,7 +77,8 @@ class CommandExecutor:
     _workflow_id: str | None
     _enable_waves: bool
     _enable_canals: bool
-    _enable_worktrees: bool
+    _worktree_config: WorktreeConfig
+    _evidence_config: EvidenceConfig
     _agent_loop_config: AgentLoopConfig
     _commands_client: CommandsClient | None
     _sessions_client: SessionsClient | None
@@ -171,7 +174,8 @@ class CommandExecutor:
             max_turns=self.max_turns,
             enable_waves=self._enable_waves,
             enable_canals=self._enable_canals,
-            enable_worktrees=self._enable_worktrees,
+            worktree_config=self._worktree_config,
+            evidence_config=self._evidence_config,
             executor_config=self._executor_config,
             force_workflow_id=None,
             shutdown_event=self._shutdown_event,
@@ -434,7 +438,8 @@ class AgentLoop(CommandExecutor):
         force_workflow_id: str | None = None,
         enable_waves: bool = True,
         enable_canals: bool = False,
-        enable_worktrees: bool = False,
+        worktree_config: WorktreeConfig | None = None,
+        evidence_config: EvidenceConfig | None = None,
         retry_config: RetryConfig | None = None,
     ) -> None:
         self.project_id = project_id
@@ -450,7 +455,8 @@ class AgentLoop(CommandExecutor):
         self._workflow_id = force_workflow_id
         self._enable_waves = enable_waves
         self._enable_canals = enable_canals
-        self._enable_worktrees = enable_worktrees
+        self._worktree_config = worktree_config or WorktreeConfig()
+        self._evidence_config = evidence_config or EvidenceConfig()
 
         # State
         self._agent_id: str | None = None
@@ -475,7 +481,11 @@ class AgentLoop(CommandExecutor):
         workflow_status = self._workflow_id or "single-phase"
         waves_status = "enabled" if self._enable_waves else "disabled"
         canals_status = "enabled" if self._enable_canals else "disabled"
-        worktree_status = "enabled" if self._enable_worktrees else "disabled"
+        worktree_status = (
+            f"enabled ({self._worktree_config.provider})"
+            if self._worktree_config.enabled
+            else "disabled"
+        )
 
         console.print(
             Panel(
@@ -795,7 +805,8 @@ class WorkspaceAgentLoop(CommandExecutor):
         force_workflow_id: str | None = None,
         enable_waves: bool = True,
         enable_canals: bool = False,
-        enable_worktrees: bool = False,
+        worktree_config: WorktreeConfig | None = None,
+        evidence_config: EvidenceConfig | None = None,
         retry_config: RetryConfig | None = None,
     ) -> None:
         self.workspace_path = Path(workspace_path)
@@ -811,7 +822,8 @@ class WorkspaceAgentLoop(CommandExecutor):
         self._workflow_id = force_workflow_id
         self._enable_waves = enable_waves
         self._enable_canals = enable_canals
-        self._enable_worktrees = enable_worktrees
+        self._worktree_config = worktree_config or WorktreeConfig()
+        self._evidence_config = evidence_config or EvidenceConfig()
 
         # State
         self._agent_id: str | None = None
@@ -841,7 +853,11 @@ class WorkspaceAgentLoop(CommandExecutor):
 
         waves_status = "enabled" if self._enable_waves else "disabled"
         canals_status = "enabled" if self._enable_canals else "disabled"
-        worktree_status = "enabled" if self._enable_worktrees else "disabled"
+        worktree_status = (
+            f"enabled ({self._worktree_config.provider})"
+            if self._worktree_config.enabled
+            else "disabled"
+        )
 
         console.print(
             Panel(
@@ -1211,7 +1227,8 @@ async def run_agent_loop(
     force_workflow_id: str | None = None,
     enable_waves: bool = True,
     enable_canals: bool = False,
-    enable_worktrees: bool = False,
+    worktree_config: WorktreeConfig | None = None,
+    evidence_config: EvidenceConfig | None = None,
     retry_config: RetryConfig | None = None,
 ) -> None:
     """Run the project-scoped agent loop.
@@ -1231,7 +1248,8 @@ async def run_agent_loop(
         force_workflow_id=force_workflow_id,
         enable_waves=enable_waves,
         enable_canals=enable_canals,
-        enable_worktrees=enable_worktrees,
+        worktree_config=worktree_config,
+        evidence_config=evidence_config,
         retry_config=retry_config,
     )
     await agent.start()
@@ -1250,7 +1268,8 @@ async def run_workspace_agent_loop(
     force_workflow_id: str | None = None,
     enable_waves: bool = True,
     enable_canals: bool = False,
-    enable_worktrees: bool = False,
+    worktree_config: WorktreeConfig | None = None,
+    evidence_config: EvidenceConfig | None = None,
     retry_config: RetryConfig | None = None,
 ) -> None:
     """Run the workspace (multi-project) agent loop.
@@ -1270,7 +1289,8 @@ async def run_workspace_agent_loop(
         force_workflow_id=force_workflow_id,
         enable_waves=enable_waves,
         enable_canals=enable_canals,
-        enable_worktrees=enable_worktrees,
+        worktree_config=worktree_config,
+        evidence_config=evidence_config,
         retry_config=retry_config,
     )
     await agent.start()

{steerdev-1.0.39 → steerdev-1.0.52}/src/steerdev_agent/api/__init__.py

@@ -4,6 +4,7 @@ from steerdev_agent.api.client import SteerDevClient, get_api_key, get_project_i
 from steerdev_agent.api.configs import ConfigsClient
 from steerdev_agent.api.events import EventData, EventsClient
 from steerdev_agent.api.hooks import HooksClient
+from steerdev_agent.api.reports import ReportsClient
 from steerdev_agent.api.runs import RunCreateRequest, RunResponse, RunsClient
 from steerdev_agent.api.sessions import (
     SessionCreateRequest,
@@ -18,6 +19,7 @@ __all__ = [
     "EventData",
     "EventsClient",
     "HooksClient",
+    "ReportsClient",
     "RunCreateRequest",
     "RunResponse",
     "RunsClient",

steerdev-1.0.52/src/steerdev_agent/api/reports.py

@@ -0,0 +1,82 @@
+"""Evidence reports API client for SteerDev Agent.
+
+Submits evidence reports to the platform after task/workflow completion,
+making work visible on the project review dashboard.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from loguru import logger
+from rich.console import Console
+
+from steerdev_agent.api.client import SteerDevClient
+
+console = Console()
+
+
+class ReportsClient(SteerDevClient):
+    """Client for submitting evidence reports to the platform.
+
+    Evidence reports capture task completion summaries, making agent work
+    visible on the project review page (/projects/[id]/review).
+    """
+
+    def submit(
+        self,
+        *,
+        project_id: str,
+        summary: str,
+        blocks: list[dict[str, Any]],
+        task_id: str | None = None,
+        wave_id: str | None = None,
+        agent_id: str | None = None,
+        evaluation_steps: list[dict[str, Any]] | None = None,
+    ) -> dict[str, Any] | None:
+        """Submit an evidence report for a completed task or workflow.
+
+        Args:
+                project_id: SteerDev project ID.
+                summary: Report title/summary (required for reviewability).
+                blocks: List of report blocks (type, content, order).
+                task_id: Associated task ID.
+                wave_id: Associated wave ID.
+                agent_id: Associated agent ID.
+                evaluation_steps: Optional evaluation steps (title, result, order).
+
+        Returns:
+                Response dict with report_id and is_reviewable, or None on failure.
+        """
+        payload: dict[str, Any] = {
+            "project_id": project_id,
+            "summary": summary,
+            "blocks": blocks,
+        }
+        if task_id:
+            payload["task_id"] = task_id
+        if wave_id:
+            payload["wave_id"] = wave_id
+        if agent_id:
+            payload["agent_id"] = agent_id
+        if evaluation_steps:
+            payload["evaluation_steps"] = evaluation_steps
+
+        try:
+            response = self.post("/reports", json=payload)
+            if response.status_code in (200, 201):
+                data = response.json()
+                report_id = data.get("report_id", "unknown")
+                is_reviewable = data.get("is_reviewable", False)
+                console.print(
+                    f"[dim]Evidence report submitted: {report_id} "
+                    f"(reviewable: {is_reviewable})[/dim]"
+                )
+                return data
+            logger.warning(
+                f"Evidence report submission failed: {response.status_code} - {response.text}"
+            )
+            return None
+        except Exception:
+            logger.debug("Evidence report submission error", exc_info=True)
+            return None

{steerdev-1.0.39 → steerdev-1.0.52}/src/steerdev_agent/cli.py

@@ -1509,7 +1509,10 @@ def _resolve_run_config(
     resolved_model = model if model is not None else config.agent.model
     resolved_max_turns = max_turns if max_turns is not None else config.agent.max_turns
     resolved_timeout = timeout if timeout is not None else config.agent.timeout_seconds
-    resolved_worktrees = worktrees if worktrees is not None else config.worktrees.enabled
+    # Resolve worktree config: CLI flag overrides config file enabled state
+    resolved_worktree_config = config.worktrees.model_copy()
+    if worktrees is not None:
+        resolved_worktree_config.enabled = worktrees
 
     resolved_api_key = api_key
     if not resolved_api_key:
@@ -1528,7 +1531,7 @@ def _resolve_run_config(
         "timeout_seconds": resolved_timeout,
         "enable_waves": waves,
         "enable_canals": canals,
-        "enable_worktrees": resolved_worktrees,
+        "worktree_config": resolved_worktree_config,
         "force_workflow_id": resolved_workflow_id,
         "dry_run": dry_run,
     }
@@ -1612,6 +1615,13 @@ def run(
             help="Enable git worktree isolation (default: from config or disabled)",
         ),
     ] = None,
+    evidence: Annotated[
+        bool | None,
+        typer.Option(
+            "--evidence/--no-evidence",
+            help="Submit evidence reports after task completion (default: from config or disabled)",
+        ),
+    ] = None,
     dry_run: Annotated[
         bool,
         typer.Option(
@@ -1700,7 +1710,14 @@ def run(
     resolved_model = model if model is not None else config.agent.model
     resolved_max_turns = max_turns if max_turns is not None else config.agent.max_turns
     resolved_timeout = timeout if timeout is not None else config.agent.timeout_seconds
-    resolved_worktrees = worktrees if worktrees is not None else config.worktrees.enabled
+    # Resolve worktree config: CLI flag overrides config file enabled state
+    resolved_worktree_config = config.worktrees.model_copy()
+    if worktrees is not None:
+        resolved_worktree_config.enabled = worktrees
+    # Resolve evidence config: CLI flag overrides config file enabled state
+    resolved_evidence_config = config.evidence.model_copy()
+    if evidence is not None:
+        resolved_evidence_config.enabled = evidence
 
     # API key: CLI > env (via envvar) > config env var
     resolved_api_key = api_key
@@ -1711,7 +1728,12 @@ def run(
     if not resolved_workflow_id:
         resolved_workflow_id = config.agent.workflow_id
 
-    worktree_status = "enabled" if resolved_worktrees else "disabled"
+    worktree_status = (
+        f"enabled ({resolved_worktree_config.provider})"
+        if resolved_worktree_config.enabled
+        else "disabled"
+    )
+    evidence_status = "enabled" if resolved_evidence_config.enabled else "disabled"
     dry_run_status = "enabled" if dry_run else "disabled"
     waves_status = "enabled" if waves else "disabled"
     canals_status = "enabled" if canals else "disabled"
@@ -1732,6 +1754,7 @@ def run(
             f"Waves: {waves_status}\n"
             f"Canals: {canals_status}\n"
             f"Worktrees: {worktree_status}\n"
+            f"Evidence: {evidence_status}\n"
             f"Dry Run: {dry_run_status}",
             title="Starting",
         )
@@ -1762,7 +1785,8 @@ def run(
                 timeout_seconds=resolved_timeout,
                 enable_waves=waves,
                 enable_canals=canals,
-                enable_worktrees=resolved_worktrees,
+                worktree_config=resolved_worktree_config,
+                evidence_config=resolved_evidence_config,
                 force_workflow_id=resolved_workflow_id,
                 dry_run=dry_run,
                 retry_config=retry_config,
@@ -1911,6 +1935,13 @@ def agent(
             help="Enable canal merge flow selection (default: disabled)",
         ),
     ] = False,
+    evidence: Annotated[
+        bool | None,
+        typer.Option(
+            "--evidence/--no-evidence",
+            help="Submit evidence reports after task completion (default: from config or disabled)",
+        ),
+    ] = None,
 ) -> None:
     """Run the agent in persistent mode.
 
@@ -1970,7 +2001,10 @@ def agent(
     if gap_seconds is not None:
         agent_loop_config.gap_seconds = gap_seconds
 
-    resolved_worktrees = config.worktrees.enabled
+    resolved_worktree_config = config.worktrees.model_copy()
+    resolved_evidence_config = config.evidence.model_copy()
+    if evidence is not None:
+        resolved_evidence_config.enabled = evidence
 
     # Resolve retry config: CLI > config > default
     retry_config = config.retry.model_copy()
@@ -2002,7 +2036,8 @@ def agent(
                     force_workflow_id=workflow_id,
                     enable_waves=waves,
                     enable_canals=canals,
-                    enable_worktrees=resolved_worktrees,
+                    worktree_config=resolved_worktree_config,
+                    evidence_config=resolved_evidence_config,
                     retry_config=retry_config,
                 )
             )
@@ -2042,7 +2077,8 @@ def agent(
                     force_workflow_id=resolved_workflow_id,
                     enable_waves=waves,
                     enable_canals=canals,
-                    enable_worktrees=resolved_worktrees,
+                    worktree_config=resolved_worktree_config,
+                    evidence_config=resolved_evidence_config,
                     retry_config=retry_config,
                 )
             )
@@ -2207,6 +2243,32 @@ def _setup_repos(
     )
 
 
+def _display_dependency_check(deps: list) -> None:
+    """Display CLI dependency check results as a table."""
+    from rich.table import Table
+
+    table = Table(title="CLI Dependencies", show_header=True, header_style="bold")
+    table.add_column("Tool", style="cyan")
+    table.add_column("Status")
+    table.add_column("Details", style="dim")
+
+    for dep in deps:
+        if dep.found:
+            status = "[green]Found[/green]"
+            details = dep.version or dep.path or ""
+        elif dep.required:
+            status = "[red]Missing (required)[/red]"
+            details = f"Install: {dep.install_hint}"
+        else:
+            status = "[yellow]Missing (optional)[/yellow]"
+            details = f"Install: {dep.install_hint}"
+        table.add_row(dep.name, status, details)
+
+    console.print()
+    console.print(table)
+    console.print()
+
+
 def _prompt_install_target() -> str:
     """Prompt the user to choose where to install Claude configs."""
     choices = {
@@ -2324,9 +2386,21 @@ def setup(
     - user: ~/.claude/ in your home directory (shared across all projects)
     """
     from steerdev_agent.setup import ClaudeSetup
+    from steerdev_agent.setup.claude_setup import check_cli_dependencies
 
     target_dir = project_dir or Path.cwd()
 
+    # ── Check CLI dependencies ──
+    deps = check_cli_dependencies()
+    _display_dependency_check(deps)
+
+    missing_required = [d for d in deps if d.required and not d.found]
+    if missing_required:
+        console.print(
+            "\n[red]Missing required dependencies. Install them before running setup.[/red]"
+        )
+        raise typer.Exit(1)
+
     # Prompt for install target if not provided
     if install_target is None:
         install_target = _prompt_install_target()

{steerdev-1.0.39 → steerdev-1.0.52}/src/steerdev_agent/config/models.py

@@ -10,15 +10,45 @@ from steerdev_agent.api.client import DEFAULT_API_ENDPOINT
 
 
 class WorktreeConfig(BaseModel):
-    """Git worktree isolation configuration.
+    """Worktree isolation configuration using worktrunk.dev (wt CLI).
 
-    When enabled, the Claude CLI --worktree flag is used to run each task
-    in an isolated git worktree. Worktree lifecycle is managed by Claude CLI.
+    When enabled with provider "worktrunk", `wt switch --create <branch>`
+    provisions isolated worktrees with lifecycle hooks (env setup, pre-merge checks).
+    Legacy provider "claude" uses Claude CLI's --worktree flag directly.
     """
 
     enabled: Annotated[
         bool,
-        Field(default=False, description="Enable Claude CLI --worktree isolation per task"),
+        Field(default=False, description="Enable worktree isolation per task/wave"),
+    ]
+    provider: Annotated[
+        str,
+        Field(
+            default="worktrunk",
+            description='Worktree provider: "worktrunk" (recommended) or "claude" (legacy --worktree flag)',
+        ),
+    ]
+    cleanup_on_complete: Annotated[
+        bool,
+        Field(default=True, description="Remove worktree after successful task completion"),
+    ]
+    cleanup_on_failure: Annotated[
+        bool,
+        Field(default=False, description="Remove worktree after task failure"),
+    ]
+    copy_gitignored: Annotated[
+        list[str],
+        Field(
+            default_factory=lambda: [".env", ".env.local"],
+            description="Gitignored files to copy into new worktrees (via wt step)",
+        ),
+    ]
+    pre_merge_checks: Annotated[
+        list[str],
+        Field(
+            default_factory=list,
+            description='Commands to run in pre-merge hook (e.g., ["pnpm check", "pnpm typecheck"])',
+        ),
     ]
 
 
@@ -216,6 +246,19 @@ class CanalConfig(BaseModel):
     ]
 
 
+class EvidenceConfig(BaseModel):
+    """Evidence report configuration.
+
+    When enabled, the agent submits evidence reports to the platform after
+    completing tasks or workflow phases. Reports appear on the project review page.
+    """
+
+    enabled: Annotated[
+        bool,
+        Field(default=False, description="Submit evidence reports after task completion"),
+    ]
+
+
 class RetryConfig(BaseModel):
     """Retry configuration for failed task/session execution."""
 
@@ -295,6 +338,13 @@ class SteerDevConfig(BaseModel):
         WorkspaceConfig,
         Field(default_factory=WorkspaceConfig, description="Workspace agent configuration"),
     ]
+    evidence: Annotated[
+        EvidenceConfig,
+        Field(
+            default_factory=EvidenceConfig,
+            description="Evidence report configuration for project review",
+        ),
+    ]
     retry: Annotated[
         RetryConfig,
         Field(default_factory=RetryConfig, description="Retry configuration for failed tasks"),

steerdev-1.0.52/src/steerdev_agent/evidence.py

@@ -0,0 +1,156 @@
+"""Evidence collection: run a verification session after task completion.
+
+After a task or workflow finishes, this module spawns a short agent session
+that reviews what was done — checking git changes, using agent-browser for
+visual verification, and writing a structured review.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+from typing import Any
+
+from loguru import logger
+from rich.console import Console
+
+from steerdev_agent.executor import ExecutorFactory
+from steerdev_agent.executor.base import EventType
+
+console = Console()
+
+# Maximum turns for the evidence-collection session.  Enough for:
+# git diff/log (2), optional file reads (3), agent-browser (4), summary (1)
+EVIDENCE_MAX_TURNS = 25
+
+
+def build_evidence_prompt(
+    task: dict[str, Any],
+    success: bool,
+    phase_summaries: list[dict[str, Any]] | None = None,
+    evidence_messages: list[str] | None = None,
+) -> str:
+    """Build the prompt sent to the agent for evidence collection.
+
+    Args:
+        task: The completed task dict.
+        success: Whether the task succeeded.
+        phase_summaries: Per-phase summaries (workflow tasks only).
+        evidence_messages: Assistant messages collected during execution
+            (non-workflow tasks only).
+    """
+    task_title = task.get("title", "Unknown Task")
+    task_prompt = task.get("prompt", "")
+    status = "Completed successfully" if success else "Failed"
+
+    sections: list[str] = [
+        "# Evidence Collection\n",
+        "You have just completed a task. Your job now is to **review and document "
+        "what was accomplished** so a human reviewer can verify the work.\n",
+        f"## Task\n- **Title:** {task_title}\n- **Status:** {status}\n",
+    ]
+
+    if task_prompt:
+        sections.append(f"## Original Requirement\n{task_prompt[:2000]}\n")
+
+    # Include work output from the execution
+    if phase_summaries:
+        lines = ["## Workflow Phase Results\n"]
+        for ps in phase_summaries:
+            name = ps.get("phase_name", "Phase")
+            ok = "Pass" if ps.get("success") else "Fail"
+            text = ps.get("summary", "")
+            lines.append(f"### {name} ({ok})\n{text[:1500]}\n")
+        sections.append("\n".join(lines))
+    elif evidence_messages:
+        last = evidence_messages[-1][:3000]
+        sections.append(f"## Agent Output (last message)\n{last}\n")
+
+    sections.append(
+        "## Your Instructions\n\n"
+        "Collect evidence that the work is correct. Follow these steps:\n\n"
+        "### 1. File Changes\n"
+        "Run `git diff --stat` and `git log --oneline -5` to see what changed.\n"
+        "Summarize the key modifications.\n\n"
+        "### 2. Visual Verification\n"
+        "If the task involved **UI or frontend changes**:\n"
+        "- Use `agent-browser open <url>` to navigate to the relevant page\n"
+        "- Use `agent-browser screenshot` to capture it\n"
+        "- Describe what you see and whether it matches the acceptance criteria\n\n"
+        "If the task was backend-only, verify via tests or logs instead.\n\n"
+        "### 3. Tests\n"
+        "If there are relevant tests, run them and report the results.\n\n"
+        "### 4. Review Summary\n"
+        "Write a structured review covering:\n"
+        "- What was implemented or changed\n"
+        "- Key files modified and why\n"
+        "- Visual verification or test results\n"
+        "- Any concerns, edge cases, or issues found\n\n"
+        "Be specific and factual. Include code snippets or file paths where relevant.\n"
+    )
+
+    return "\n".join(sections)
+
+
+async def collect_evidence(
+    *,
+    task: dict[str, Any],
+    success: bool,
+    working_directory: str,
+    executor_config: Any,
+    model: str | None,
+    api_key: str | None,
+    dry_run: bool = False,
+    phase_summaries: list[dict[str, Any]] | None = None,
+    evidence_messages: list[str] | None = None,
+) -> list[str]:
+    """Run a short agent session to collect evidence of completed work.
+
+    Returns a list of assistant messages produced during the evidence session.
+    Best-effort: returns an empty list on any failure.
+    """
+    prompt = build_evidence_prompt(
+        task,
+        success=success,
+        phase_summaries=phase_summaries,
+        evidence_messages=evidence_messages,
+    )
+
+    if dry_run:
+        console.print("[dim]Evidence collection (dry run): would run evidence prompt[/dim]")
+        return []
+
+    executor = ExecutorFactory.create(
+        config=executor_config,
+        working_directory=working_directory,
+        model=model,
+        max_turns=EVIDENCE_MAX_TURNS,
+        dry_run=False,
+    )
+
+    collected: list[str] = []
+
+    try:
+        await executor.start(prompt)
+        console.print("[dim]Evidence collection started...[/dim]")
+
+        async for event in executor.stream_events():
+            if event.event_type == EventType.ASSISTANT:
+                message = event.data.get("message", {})
+                content = message.get("content", "") if isinstance(message, dict) else str(message)
+                if isinstance(content, str) and content.strip():
+                    collected.append(content)
+
+        await executor.wait()
+        console.print(f"[dim]Evidence collection done ({len(collected)} messages)[/dim]")
+
+    except Exception:
+        logger.debug("Evidence collection session failed", exc_info=True)
+        console.print("[dim]Evidence collection failed, using fallback[/dim]")
+
+    finally:
+        if executor.is_running:
+            with contextlib.suppress(asyncio.CancelledError, TimeoutError, Exception):
+                await asyncio.wait_for(executor.stop(), timeout=3.0)
+
+    return collected