aicortexpy 0.1.0__py3-none-any.whl

aicortexpy/runner.py

@@ -0,0 +1,969 @@
+"""Agent launcher: execenv, cancel, stream, pin, repos."""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Callable
+
+from .acp_conn import (
+    ACP_ONESHOT_PROVIDERS,
+    ACPPromptResult,
+    choose_cursor_invocation,
+    run_acp_oneshot,
+)
+from .agent_env import build_agent_environ
+from .attachments import materialize_attachments
+from .chat_acp_pool import (
+    ChatACPPool,
+    agent_id_from_task,
+    pool_key,
+    skip_cursor_chat_session_resume,
+)
+from .client import DaemonClient, Task
+from .config import AgentEntry, Config
+from .execenv import Environment, prepare_environment, provider_needs_inline_system_prompt
+from .procutil import kill_process_tree, popen_kwargs_for_killable_group
+from .repo import ensure_repos_for_task
+from .sandbox import apply_plan_to_command, cleanup_plan, prepare_provider_sandbox
+from .stream import STREAM_JSON_PROVIDERS, StreamCollector
+
+log = logging.getLogger("aicortexpy.runner")
+
+MessageFlush = Callable[[list[dict]], None]
+SessionPin = Callable[[str, str], None]  # session_id, work_dir
+
+
+@dataclass
+class RunResult:
+    ok: bool
+    output: str
+    work_dir: str
+    error: str = ""
+    sandbox_label: str = ""
+    cancelled: bool = False
+    session_id: str = ""
+    messages: list[dict] = field(default_factory=list)
+    usage: list[dict] = field(default_factory=list)
+
+
+def _custom_args(agent: dict | None) -> list[str]:
+    if not agent:
+        return []
+    args = agent.get("custom_args")
+    if isinstance(args, list):
+        return [str(a) for a in args]
+    return []
+
+
+def _resolve_model(entry: AgentEntry, task: Task) -> str:
+    if entry.model:
+        return entry.model
+    agent = task.agent or {}
+    return str(agent.get("model") or "")
+
+
+def _custom_args_has(extra: list[str], flag: str) -> bool:
+    prefix = flag + "="
+    return any(a == flag or a.startswith(prefix) for a in extra)
+
+
+def _pi_session_path(task: Task) -> str:
+    resume = (task.prior_session_id or "").strip()
+    if resume:
+        path = Path(resume)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        if not path.exists():
+            path.touch()
+        return str(path)
+    base = Path.home() / ".aicortex" / "pi-sessions"
+    base.mkdir(parents=True, exist_ok=True)
+    name = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%S.%f") + ".jsonl"
+    path = base / name
+    path.touch()
+    return str(path)
+
+
+def _split_pi_model(model: str) -> tuple[str, str]:
+    model = (model or "").strip()
+    if "/" in model:
+        provider, mid = model.split("/", 1)
+        return provider.strip(), mid.strip()
+    return "", model
+
+
+def _build_command(
+    provider: str,
+    entry: AgentEntry,
+    prompt: str,
+    task: Task,
+    *,
+    work_dir: Path | None = None,
+    system_prompt: str = "",
+) -> list[str]:
+    path = entry.path
+    agent = task.agent
+    extra = _custom_args(agent)
+    model = _resolve_model(entry, task)
+
+    if provider == "claude":
+        cmd = [
+            path,
+            "-p",
+            prompt,
+            "--output-format",
+            "stream-json",
+            "--verbose",
+            "--permission-mode",
+            "bypassPermissions",
+            "--strict-mcp-config",
+        ]
+        if model:
+            cmd.extend(["--model", model])
+        if task.prior_session_id:
+            cmd.extend(["--resume", task.prior_session_id])
+        # Filter blocked custom args that daemon owns.
+        filtered = _filter_blocked_args(
+            extra, {"--mcp-config", "--output-format", "--permission-mode", "--strict-mcp-config"}
+        )
+        cmd.extend(filtered)
+        return cmd
+
+    if provider == "codex":
+        cmd = [path, "exec", "--skip-git-repo-check", prompt]
+        if model:
+            cmd.extend(["-m", model])
+        cmd.extend(extra)
+        return cmd
+
+    if provider == "gemini":
+        cmd = [path, "-p", prompt, "--yolo", "-o", "stream-json"]
+        if model:
+            cmd.extend(["-m", model])
+        if task.prior_session_id:
+            cmd.extend(["-r", task.prior_session_id])
+        cmd.extend(extra)
+        return cmd
+
+    if provider == "cursor":
+        cmd = [path, "-p", prompt, "--output-format", "stream-json", "--yolo"]
+        if work_dir is not None:
+            cmd.extend(["--workspace", str(work_dir)])
+        if model:
+            cmd.extend(["--model", model])
+        if task.prior_session_id and not task.chat_session_id:
+            cmd.extend(["--resume", task.prior_session_id])
+        cmd.extend(extra)
+        return cmd
+
+    if provider == "openclaw":
+        session_id = task.prior_session_id or f"aicortex-{uuid.uuid4().hex}"
+        msg = prompt
+        if system_prompt:
+            msg = system_prompt + "\n\n" + prompt
+        cmd = [path, "agent", "--local", "--json", "--session-id", session_id]
+        if model and not _custom_args_has(extra, "--agent"):
+            cmd.extend(["--agent", model])
+        cmd.extend(extra)
+        cmd.extend(["--message", msg])
+        return cmd
+
+    if provider == "pi":
+        session_path = _pi_session_path(task)
+        cmd = [path, "-p", "--mode", "json", "--session", session_path]
+        if model:
+            pi_provider, pi_model = _split_pi_model(model)
+            if pi_provider:
+                cmd.extend(["--provider", pi_provider])
+            if pi_model:
+                cmd.extend(["--model", pi_model])
+        if system_prompt:
+            cmd.extend(["--append-system-prompt", system_prompt])
+        cmd.extend(extra)
+        cmd.append(prompt)
+        return cmd
+
+    if provider == "opencode":
+        cmd = [path, "run", "--format", "json"]
+        if model:
+            cmd.extend(["--model", model])
+        if system_prompt:
+            cmd.extend(["--prompt", system_prompt])
+        if task.prior_session_id:
+            cmd.extend(["--session", task.prior_session_id])
+        cmd.extend(_filter_blocked_args(extra, {"--format"}))
+        cmd.append(prompt)
+        return cmd
+
+    if provider == "copilot":
+        cmd = [
+            path,
+            "-p",
+            prompt,
+            "--output-format",
+            "json",
+            "--allow-all",
+            "--no-ask-user",
+        ]
+        if model:
+            cmd.extend(["--model", model])
+        if task.prior_session_id:
+            cmd.extend(["--resume", task.prior_session_id])
+        cmd.extend(
+            _filter_blocked_args(
+                extra,
+                {
+                    "-p",
+                    "--output-format",
+                    "--allow-all",
+                    "--yolo",
+                    "--no-ask-user",
+                    "--resume",
+                    "--acp",
+                },
+            )
+        )
+        return cmd
+
+    return [path, prompt, *extra]
+
+
+def _filter_blocked_args(args: list[str], blocked: set[str]) -> list[str]:
+    """Drop daemon-owned flags (and their values) from custom_args."""
+    out: list[str] = []
+    skip_next = False
+    for a in args:
+        if skip_next:
+            skip_next = False
+            continue
+        name = a.split("=", 1)[0]
+        if name in blocked or a in blocked:
+            if "=" not in a and name in blocked:
+                skip_next = True
+            continue
+        out.append(a)
+    return out
+
+
+def _hide_window_kwargs() -> dict:
+    if sys.platform != "win32":
+        return {}
+    startup = subprocess.STARTUPINFO()
+    startup.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+    return {"startupinfo": startup}
+
+
+def _cleanup_mcp_tmp(path: str | None) -> None:
+    if not path:
+        return
+    try:
+        os.unlink(path)
+    except OSError:
+        pass
+
+
+def run_agent(
+    task: Task,
+    provider: str,
+    entry: AgentEntry,
+    workspaces_root: Path,
+    timeout: float,
+    *,
+    client: DaemonClient | None = None,
+    cfg: Config | None = None,
+    task_slot: int = 0,
+    cancel_event: threading.Event | None = None,
+    on_messages: MessageFlush | None = None,
+    on_session: SessionPin | None = None,
+    acp_pool: ChatACPPool | None = None,
+    idle_watchdog: float = 0,
+) -> RunResult:
+    env_info: Environment = prepare_environment(workspaces_root, task, provider)
+    work_dir = env_info.work_dir
+
+    # Design→dev handoff zip (Priority 1b in Go runTask).
+    if task.handoff_bundle_url:
+        try:
+            from .handoff_bundle import materialize_handoff_bundle
+
+            materialize_handoff_bundle(
+                work_dir,
+                task.handoff_bundle_url,
+                token=(cfg.token if cfg else ""),
+                server_base=(cfg.server_base_url if cfg else ""),
+            )
+        except Exception as e:
+            return RunResult(
+                ok=False,
+                output="",
+                work_dir=str(work_dir),
+                error=f"handoff bundle: {e}",
+            )
+
+    if task.design_example_id:
+        try:
+            from .design_seed import seed_example_workdir
+
+            seed_example_workdir(
+                work_dir,
+                task.design_example_id,
+                task.design_example_bundles,
+                design_studio=bool(task.design_mode),
+            )
+        except Exception as e:
+            log.warning("design seed: %s", e)
+
+    if client is not None:
+        try:
+            materialize_attachments(client, task, work_dir)
+            # refresh prompt if attachments arrived for design/chat
+            if task.design_incoming_rel_paths:
+                from .prompt import build_prompt
+
+                (work_dir / "PROMPT.md").write_text(
+                    build_prompt(task, provider), encoding="utf-8"
+                )
+        except Exception as e:
+            log.warning("attachments: %s", e)
+
+    try:
+        ensure_repos_for_task(workspaces_root, task, work_dir)
+    except Exception as e:
+        log.warning("repo prepare: %s", e)
+
+    prompt = (work_dir / "PROMPT.md").read_text(encoding="utf-8")
+    system_prompt = ""
+    if provider_needs_inline_system_prompt(provider):
+        system_prompt = env_info.runtime_brief or ""
+    plan = prepare_provider_sandbox(provider, work_dir)
+    if env_info.codex_home:
+        plan.env_updates["CODEX_HOME"] = str(env_info.codex_home)
+    if env_info.env_updates:
+        plan.env_updates.update(env_info.env_updates)
+    for n in plan.notes or []:
+        log.info("sandbox: %s", n)
+
+    if cfg is not None:
+        environ = build_agent_environ(
+            os.environ.copy(),
+            cfg=cfg,
+            task=task,
+            task_slot=task_slot,
+            extra=plan.env_updates,
+        )
+    else:
+        environ = os.environ.copy()
+        environ.update(plan.env_updates)
+    if provider == "gemini":
+        environ.setdefault("GEMINI_CLI_TRUST_WORKSPACE", "true")
+    if provider == "opencode":
+        environ.setdefault("OPENCODE_PERMISSION", '{"*":"allow"}')
+
+    mcp_tmp: str | None = None
+    agent = task.agent or {}
+    mcp_raw = agent.get("mcp_config")
+    if provider == "claude" and mcp_raw:
+        try:
+            if isinstance(mcp_raw, (dict, list)):
+                payload = json.dumps(mcp_raw, ensure_ascii=False)
+            else:
+                payload = str(mcp_raw)
+            fd, mcp_tmp = tempfile.mkstemp(prefix="aicortex-mcp-", suffix=".json")
+            with os.fdopen(fd, "w", encoding="utf-8") as fh:
+                fh.write(payload)
+        except OSError as e:
+            log.warning("mcp config tempfile failed: %s", e)
+            mcp_tmp = None
+
+    # Chat + Cursor/Kiro: prefer long-lived ACP pool; fall back to one-shot CLI.
+    if (
+        acp_pool is not None
+        and task.chat_session_id
+        and acp_pool.enabled_for(provider)
+    ):
+        acp_result = _run_via_acp_pool(
+            task=task,
+            provider=provider,
+            entry=entry,
+            work_dir=work_dir,
+            prompt=prompt,
+            timeout=timeout,
+            environ=environ,
+            plan_label=plan.policy_label,
+            acp_pool=acp_pool,
+            cancel_event=cancel_event,
+            on_messages=on_messages,
+            on_session=on_session,
+            idle_watchdog=idle_watchdog,
+            system_prompt=system_prompt,
+        )
+        if acp_result is not None:
+            cleanup_plan(plan)
+            _cleanup_mcp_tmp(mcp_tmp)
+            return acp_result
+        log.warning("%s chat acp pool failed, falling back to one-shot backend", provider)
+
+    # Non-chat ACP providers (kiro/hermes/kimi/dsh) — always JSON-RPC, not argv prompt.
+    if provider in ACP_ONESHOT_PROVIDERS:
+        oneshot = _run_via_acp_oneshot(
+            task=task,
+            provider=provider,
+            entry=entry,
+            work_dir=work_dir,
+            prompt=prompt,
+            timeout=timeout,
+            environ=environ,
+            plan_label=plan.policy_label,
+            cancel_event=cancel_event,
+            on_messages=on_messages,
+            on_session=on_session,
+            idle_watchdog=idle_watchdog,
+            system_prompt=system_prompt,
+        )
+        cleanup_plan(plan)
+        _cleanup_mcp_tmp(mcp_tmp)
+        return oneshot
+
+    cmd = _build_command(
+        provider, entry, prompt, task, work_dir=work_dir, system_prompt=system_prompt
+    )
+    if mcp_tmp and provider == "claude":
+        cmd.extend(["--mcp-config", mcp_tmp])
+    if sys.platform == "win32" and sum(len(a) for a in cmd) > 7000:
+        short = (
+            f"Read and follow {work_dir / 'PROMPT.md'}. "
+            "Complete the AICortex task described there."
+        )
+        cmd = _build_command(
+            provider, entry, short, task, work_dir=work_dir, system_prompt=system_prompt
+        )
+    if provider == "cursor" and cmd:
+        argv0, args = choose_cursor_invocation(cmd[0], cmd[1:])
+        cmd = [argv0, *args]
+    cmd = apply_plan_to_command(plan, cmd)
+
+    log.info(
+        "spawn agent provider=%s sandbox=%s cwd=%s cmd0=%s",
+        provider,
+        plan.policy_label,
+        work_dir,
+        cmd[0],
+    )
+
+    collector = StreamCollector(provider=provider)
+    if provider == "pi":
+        for i, a in enumerate(cmd):
+            if a == "--session" and i + 1 < len(cmd):
+                collector.session_id = cmd[i + 1]
+                break
+    elif provider == "openclaw":
+        for i, a in enumerate(cmd):
+            if a == "--session-id" and i + 1 < len(cmd):
+                collector.session_id = cmd[i + 1]
+                break
+    pending_msgs: list[dict] = []
+    last_flush = time.time()
+    pinned_once = False
+    parse_stream = provider in STREAM_JSON_PROVIDERS
+
+    def flush_messages(force: bool = False) -> None:
+        nonlocal pending_msgs, last_flush
+        if not on_messages or not pending_msgs:
+            return
+        if not force and len(pending_msgs) < 5 and time.time() - last_flush < 2.0:
+            return
+        batch = pending_msgs
+        pending_msgs = []
+        last_flush = time.time()
+        try:
+            on_messages(batch)
+        except Exception as e:
+            log.warning("flush messages failed: %s", e)
+
+    def maybe_pin() -> None:
+        nonlocal pinned_once
+        if on_session and collector.session_id and not pinned_once:
+            pinned_once = True
+            try:
+                on_session(collector.session_id, str(work_dir))
+            except Exception as e:
+                log.warning("pin session failed: %s", e)
+
+    popen_kw = {
+        "cwd": str(work_dir),
+        "env": environ,
+        "stdout": subprocess.PIPE,
+        "stderr": subprocess.PIPE,
+        "text": True,
+        "bufsize": 1,
+        **popen_kwargs_for_killable_group(),
+        **_hide_window_kwargs(),
+    }
+
+    try:
+        proc = subprocess.Popen(cmd, **popen_kw)
+    except FileNotFoundError:
+        cleanup_plan(plan)
+        _cleanup_mcp_tmp(mcp_tmp)
+        return RunResult(
+            ok=False,
+            output="",
+            work_dir=str(work_dir),
+            error=f"agent executable not found: {entry.path}",
+            sandbox_label=plan.policy_label,
+        )
+    except OSError as e:
+        cleanup_plan(plan)
+        _cleanup_mcp_tmp(mcp_tmp)
+        return RunResult(
+            ok=False,
+            output="",
+            work_dir=str(work_dir),
+            error=str(e),
+            sandbox_label=plan.policy_label,
+        )
+
+    # Early pin of work_dir even without session
+    if on_session:
+        try:
+            on_session("", str(work_dir))
+        except Exception:
+            pass
+
+    stdout_chunks: list[str] = []
+    stderr_chunks: list[str] = []
+    cancelled = False
+    semantic_timeout = 0.0
+    if provider == "codex" and cfg is not None:
+        semantic_timeout = float(cfg.codex_semantic_inactivity or 0)
+    last_activity = time.time()
+    last_activity_desc = "spawn"
+    activity_lock = threading.Lock()
+    semantic_killed = False
+
+    def _touch_activity(desc: str) -> None:
+        nonlocal last_activity, last_activity_desc
+        with activity_lock:
+            last_activity = time.time()
+            last_activity_desc = desc
+
+    def _reader(stream, sink: list[str], parse: bool, label: str) -> None:
+        assert stream is not None
+        for line in stream:
+            sink.append(line)
+            _touch_activity(label)
+            if parse:
+                before = len(collector.messages)
+                collector.feed_line(line)
+                if len(collector.messages) > before:
+                    pending_msgs.extend(collector.messages[before:])
+                    flush_messages()
+                maybe_pin()
+
+    t_out = threading.Thread(
+        target=_reader,
+        args=(proc.stdout, stdout_chunks, parse_stream, "stdout"),
+        name="agent-stdout",
+        daemon=True,
+    )
+    t_err = threading.Thread(
+        target=_reader,
+        args=(proc.stderr, stderr_chunks, False, "stderr"),
+        name="agent-stderr",
+        daemon=True,
+    )
+    t_out.start()
+    t_err.start()
+
+    deadline = time.time() + timeout
+    while True:
+        if cancel_event is not None and cancel_event.is_set():
+            cancelled = True
+            log.info("cancel requested; killing agent pid=%s", proc.pid)
+            kill_process_tree(proc.pid)
+            break
+        rc = proc.poll()
+        if rc is not None:
+            break
+        now = time.time()
+        if now >= deadline:
+            log.info("agent timeout; killing pid=%s", proc.pid)
+            kill_process_tree(proc.pid)
+            break
+        if semantic_timeout > 0:
+            with activity_lock:
+                idle = now - last_activity
+                idle_desc = last_activity_desc
+            if idle >= semantic_timeout:
+                semantic_killed = True
+                log.warning(
+                    "codex semantic inactivity timeout after %.0fs (last=%s idle=%.1fs); killing pid=%s",
+                    semantic_timeout,
+                    idle_desc,
+                    idle,
+                    proc.pid,
+                )
+                kill_process_tree(proc.pid)
+                break
+        time.sleep(0.2)
+
+    try:
+        proc.wait(timeout=10)
+    except subprocess.TimeoutExpired:
+        kill_process_tree(proc.pid)
+        proc.wait(timeout=5)
+
+    t_out.join(timeout=5)
+    t_err.join(timeout=5)
+    cleanup_plan(plan)
+    _cleanup_mcp_tmp(mcp_tmp)
+    maybe_pin()
+
+    stdout = "".join(stdout_chunks)
+    stderr = "".join(stderr_chunks)
+    if not parse_stream:
+        collector.finalize_plain_output(stdout if stdout.strip() else stderr)
+        pending_msgs.extend(
+            m for m in collector.messages if m not in pending_msgs
+        )
+    flush_messages(force=True)
+
+    usage_list = [collector.usage.as_dict()] if collector.usage.any else []
+    output = collector.output_text() or (stdout if stdout.strip() else stderr)
+
+    common = dict(
+        work_dir=str(work_dir),
+        sandbox_label=plan.policy_label,
+        session_id=collector.session_id,
+        messages=list(collector.messages),
+        usage=usage_list,
+    )
+
+    if cancelled:
+        return RunResult(ok=False, output=output, error="cancelled", cancelled=True, **common)
+
+    if semantic_killed:
+        with activity_lock:
+            desc = last_activity_desc
+        return RunResult(
+            ok=False,
+            output=output,
+            error=(
+                f"codex semantic inactivity timeout after {semantic_timeout:.0f}s "
+                f"without agent progress (last activity: {desc})"
+            ),
+            **common,
+        )
+
+    if proc.returncode is None:
+        return RunResult(
+            ok=False,
+            output=output,
+            error=f"agent timeout after {timeout:.0f}s",
+            **common,
+        )
+
+    if proc.returncode != 0:
+        err = f"agent exited {proc.returncode}"
+        if stderr.strip():
+            err = f"{err}: {stderr.strip()[:2000]}"
+        return RunResult(ok=False, output=output, error=err, **common)
+
+    return RunResult(ok=True, output=output or "(no output)", **common)
+
+
+def _acp_message_flusher(on_messages: MessageFlush | None) -> tuple[list[dict], Any]:
+    """Return (messages_acc, on_message_cb) that streams batches to the server."""
+    messages: list[dict] = []
+    pending: list[dict] = []
+    last_flush = time.time()
+
+    def flush(force: bool = False) -> None:
+        nonlocal pending, last_flush
+        if not on_messages or not pending:
+            return
+        if not force and len(pending) < 3 and time.time() - last_flush < 0.5:
+            return
+        batch = pending
+        pending = []
+        last_flush = time.time()
+        try:
+            on_messages(batch)
+        except Exception as e:
+            log.warning("flush acp messages failed: %s", e)
+
+    def on_message(msg: dict) -> None:
+        messages.append(msg)
+        pending.append(msg)
+        flush()
+
+    on_message.flush = flush  # type: ignore[attr-defined]
+    return messages, on_message
+
+
+def _acp_result_to_run_result(
+    *,
+    result: ACPPromptResult,
+    provider: str,
+    model: str,
+    work: str,
+    plan_label: str,
+    timeout: float,
+    messages: list[dict],
+    on_session: SessionPin | None,
+) -> RunResult:
+    if result.session_id and on_session:
+        try:
+            on_session(result.session_id, work)
+        except Exception as e:
+            log.warning("pin acp session failed: %s", e)
+
+    usage_list = []
+    if result.usage and any(result.usage.values()):
+        usage_list.append(
+            {
+                "provider": provider,
+                "model": model,
+                "input_tokens": int(result.usage.get("input_tokens") or 0),
+                "output_tokens": int(result.usage.get("output_tokens") or 0),
+                "cache_read_tokens": int(result.usage.get("cache_read_tokens") or 0),
+                "cache_write_tokens": 0,
+            }
+        )
+    msgs = messages or list(result.messages or [])
+    common = dict(
+        work_dir=work,
+        sandbox_label=plan_label,
+        session_id=result.session_id,
+        messages=msgs,
+        usage=usage_list,
+    )
+    if result.status in ("aborted", "cancelled"):
+        return RunResult(
+            ok=False,
+            output=result.output,
+            error=result.error or "cancelled",
+            cancelled=True,
+            **common,
+        )
+    if result.status in ("timeout", "idle_watchdog"):
+        return RunResult(
+            ok=False,
+            output=result.output,
+            error=result.error or f"agent {result.status} after {timeout:.0f}s",
+            **common,
+        )
+    if result.status != "completed":
+        return RunResult(
+            ok=False,
+            output=result.output,
+            error=result.error or f"acp status={result.status}",
+            **common,
+        )
+    return RunResult(ok=True, output=result.output or "(no output)", **common)
+
+
+def _run_via_acp_pool(
+    *,
+    task: Task,
+    provider: str,
+    entry: AgentEntry,
+    work_dir: Path,
+    prompt: str,
+    timeout: float,
+    environ: dict[str, str],
+    plan_label: str,
+    acp_pool: ChatACPPool,
+    cancel_event: threading.Event | None,
+    on_messages: MessageFlush | None,
+    on_session: SessionPin | None,
+    idle_watchdog: float = 0,
+    system_prompt: str = "",
+) -> RunResult | None:
+    """Returns RunResult on ACP success/terminal status, or None to fall back."""
+    model = _resolve_model(entry, task)
+    agent_id = agent_id_from_task(task)
+    resume = ""
+    if not skip_cursor_chat_session_resume(provider, task.chat_session_id):
+        resume = task.prior_session_id
+    custom_args = _custom_args(task.agent)
+    work = str(work_dir)
+    messages, on_message = _acp_message_flusher(on_messages)
+
+    if on_session:
+        try:
+            on_session("", work)
+        except Exception:
+            pass
+
+    result = acp_pool.run_prompt(
+        provider=provider,
+        chat_session_id=task.chat_session_id,
+        agent_id=agent_id,
+        work_dir=work,
+        model=model,
+        prompt=prompt,
+        resume_session_id=resume,
+        custom_args=custom_args,
+        timeout=timeout,
+        env=environ,
+        cancel_event=cancel_event,
+        on_message=on_message,
+        idle_watchdog=idle_watchdog,
+        system_prompt=system_prompt,
+    )
+
+    # Open failed → caller falls back to one-shot.
+    if result.status == "failed" and "chat acp open failed" in (result.error or ""):
+        return None
+
+    # Resume failed before a session was established → retry fresh once.
+    if result.status == "failed" and resume and not result.session_id:
+        log.warning(
+            "%s chat acp resume failed, retrying with fresh session: %s",
+            provider,
+            result.error,
+        )
+        acp_pool.remove_entry(pool_key(provider, task.chat_session_id, agent_id, work))
+        first_usage = result.usage
+        result = acp_pool.run_prompt(
+            provider=provider,
+            chat_session_id=task.chat_session_id,
+            agent_id=agent_id,
+            work_dir=work,
+            model=model,
+            prompt=prompt,
+            resume_session_id="",
+            custom_args=custom_args,
+            timeout=timeout,
+            env=environ,
+            cancel_event=cancel_event,
+            on_message=on_message,
+            idle_watchdog=idle_watchdog,
+            system_prompt=system_prompt,
+        )
+        if result.status == "failed" and "chat acp open failed" in (result.error or ""):
+            return None
+        if first_usage and result.usage:
+            result.usage = {
+                "input_tokens": int(first_usage.get("input_tokens") or 0)
+                + int(result.usage.get("input_tokens") or 0),
+                "output_tokens": int(first_usage.get("output_tokens") or 0)
+                + int(result.usage.get("output_tokens") or 0),
+                "cache_read_tokens": int(first_usage.get("cache_read_tokens") or 0)
+                + int(result.usage.get("cache_read_tokens") or 0),
+            }
+        elif first_usage and not result.usage:
+            result.usage = first_usage
+
+    on_message.flush(force=True)  # type: ignore[attr-defined]
+    return _acp_result_to_run_result(
+        result=result,
+        provider=provider,
+        model=model,
+        work=work,
+        plan_label=plan_label,
+        timeout=timeout,
+        messages=messages,
+        on_session=on_session,
+    )
+
+
+def _run_via_acp_oneshot(
+    *,
+    task: Task,
+    provider: str,
+    entry: AgentEntry,
+    work_dir: Path,
+    prompt: str,
+    timeout: float,
+    environ: dict[str, str],
+    plan_label: str,
+    cancel_event: threading.Event | None,
+    on_messages: MessageFlush | None,
+    on_session: SessionPin | None,
+    idle_watchdog: float = 0,
+    system_prompt: str = "",
+) -> RunResult:
+    model = _resolve_model(entry, task)
+    work = str(work_dir)
+    messages, on_message = _acp_message_flusher(on_messages)
+    resume = task.prior_session_id
+    if on_session:
+        try:
+            on_session("", work)
+        except Exception:
+            pass
+
+    result = run_acp_oneshot(
+        provider,
+        entry.path,
+        cwd=work,
+        prompt=prompt,
+        model=model,
+        resume_session_id=resume,
+        custom_args=_custom_args(task.agent),
+        timeout=timeout,
+        env=environ,
+        system_prompt=system_prompt,
+        on_message=on_message,
+        cancel_event=cancel_event,
+        idle_watchdog=idle_watchdog,
+    )
+
+    # Resume failed before session → retry fresh once (matches Go daemon).
+    if result.status == "failed" and resume and not result.session_id:
+        log.warning(
+            "%s acp resume failed, retrying with fresh session: %s",
+            provider,
+            result.error,
+        )
+        first_usage = result.usage
+        result = run_acp_oneshot(
+            provider,
+            entry.path,
+            cwd=work,
+            prompt=prompt,
+            model=model,
+            resume_session_id="",
+            custom_args=_custom_args(task.agent),
+            timeout=timeout,
+            env=environ,
+            system_prompt=system_prompt,
+            on_message=on_message,
+            cancel_event=cancel_event,
+            idle_watchdog=idle_watchdog,
+        )
+        if first_usage and result.usage:
+            result.usage = {
+                "input_tokens": int(first_usage.get("input_tokens") or 0)
+                + int(result.usage.get("input_tokens") or 0),
+                "output_tokens": int(first_usage.get("output_tokens") or 0)
+                + int(result.usage.get("output_tokens") or 0),
+                "cache_read_tokens": int(first_usage.get("cache_read_tokens") or 0)
+                + int(result.usage.get("cache_read_tokens") or 0),
+            }
+        elif first_usage and not result.usage:
+            result.usage = first_usage
+
+    on_message.flush(force=True)  # type: ignore[attr-defined]
+    return _acp_result_to_run_result(
+        result=result,
+        provider=provider,
+        model=model,
+        work=work,
+        plan_label=plan_label,
+        timeout=timeout,
+        messages=messages,
+        on_session=on_session,
+    )