machinaos 0.0.76 → 0.0.78

package/server/tests/services/cli_agent/test_providers.py

@@ -0,0 +1,358 @@
+"""Unit tests for `AnthropicClaudeProvider` and `OpenAICodexProvider`.
+
+Covers:
+  - `headless_argv` shape (every flag in the right place, defaults
+    applied, optional fields omitted when unset)
+  - `parse_event` round-trips JSON correctly, returns None for garbage
+  - `is_final_event` matches the right event types
+  - `event_to_session_result` reconstructs cost / session_id /
+    canonical_usage / response from vendored NDJSON
+  - `detect_auth_error` matches "not logged in" stderr patterns
+  - `supports()` flags align with `ai_cli_providers.json`
+  - Factory raises NotImplementedError for gemini
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from services.cli_agent import (
+    ClaudeTaskSpec,
+    CodexTaskSpec,
+    create_cli_provider,
+)
+from services.cli_agent.factory import is_supported
+from services.cli_agent.protocol import AICliProvider, CanonicalUsage
+
+
+# ---------------------------------------------------------------------------
+# Factory contract
+# ---------------------------------------------------------------------------
+
+class TestFactory:
+    def test_claude_creates_provider(self):
+        p = create_cli_provider("claude")
+        assert p.name == "claude"
+        assert isinstance(p, AICliProvider)
+
+    def test_codex_creates_provider(self):
+        p = create_cli_provider("codex")
+        assert p.name == "codex"
+        assert isinstance(p, AICliProvider)
+
+    def test_gemini_raises_not_implemented(self):
+        with pytest.raises(NotImplementedError, match="deferred to v2"):
+            create_cli_provider("gemini")
+
+    def test_unknown_raises_value_error(self):
+        with pytest.raises(ValueError, match="Unknown CLI provider"):
+            create_cli_provider("openai")
+
+    def test_is_supported(self):
+        assert is_supported("claude") is True
+        assert is_supported("codex") is True
+        assert is_supported("gemini") is False
+        assert is_supported("nope") is False
+
+
+# ---------------------------------------------------------------------------
+# Claude provider
+# ---------------------------------------------------------------------------
+
+@pytest.fixture
+def claude_provider():
+    return create_cli_provider("claude")
+
+
+class TestClaudeArgv:
+    def test_minimum_required_flags(self, claude_provider):
+        task = ClaudeTaskSpec(prompt="hello world")
+        argv = claude_provider.headless_argv(task, defaults={})
+        # `-p hello world` must be present
+        assert "-p" in argv
+        assert "hello world" in argv
+        # stream-json output format
+        assert "--output-format" in argv
+        assert "stream-json" in argv
+        # Defaults applied
+        assert "--model" in argv
+        assert "claude-sonnet-4-6" in argv  # default_model from JSON
+        assert "--max-turns" in argv
+        assert "10" in argv  # default_max_turns
+        assert "--max-budget-usd" in argv
+        assert "5.0" in argv  # default_max_budget_usd
+        assert "--allowedTools" in argv
+        assert "--permission-mode" in argv
+
+    def test_session_id_flag(self, claude_provider):
+        task = ClaudeTaskSpec(prompt="x", session_id="sess-abc-123")
+        argv = claude_provider.headless_argv(task, defaults={})
+        assert "--session-id" in argv
+        assert "sess-abc-123" in argv
+        assert "--resume" not in argv
+
+    def test_resume_wins_over_session_id(self, claude_provider):
+        task = ClaudeTaskSpec(
+            prompt="x",
+            session_id="new-sess",
+            resume_session_id="prior-sess",
+        )
+        argv = claude_provider.headless_argv(task, defaults={})
+        assert "--resume" in argv
+        assert "prior-sess" in argv
+        assert "--session-id" not in argv
+
+    def test_zero_budget_omits_flag(self, claude_provider):
+        task = ClaudeTaskSpec(prompt="x", max_budget_usd=0.0)
+        argv = claude_provider.headless_argv(task, defaults={})
+        assert "--max-budget-usd" not in argv
+
+    def test_system_prompt_propagates(self, claude_provider):
+        task = ClaudeTaskSpec(prompt="x", system_prompt="be concise")
+        argv = claude_provider.headless_argv(task, defaults={})
+        assert "--append-system-prompt" in argv
+        assert "be concise" in argv
+
+    def test_wrong_task_type_raises(self, claude_provider):
+        codex_task = CodexTaskSpec(prompt="x")
+        with pytest.raises(TypeError, match="ClaudeTaskSpec"):
+            claude_provider.headless_argv(codex_task, defaults={})
+
+
+class TestClaudeParseEvent:
+    def test_valid_json_round_trips(self, claude_provider):
+        line = json.dumps({"type": "result", "result": "42", "session_id": "abc"})
+        event = claude_provider.parse_event(line)
+        assert event is not None
+        assert event["type"] == "result"
+        assert event["result"] == "42"
+
+    def test_garbage_returns_none(self, claude_provider):
+        assert claude_provider.parse_event("not json") is None
+        assert claude_provider.parse_event("") is None
+        assert claude_provider.parse_event("   ") is None
+
+    def test_is_final_event(self, claude_provider):
+        assert claude_provider.is_final_event({"type": "result"}) is True
+        assert claude_provider.is_final_event({"type": "assistant"}) is False
+        assert claude_provider.is_final_event({"type": "system"}) is False
+
+
+class TestClaudeEventToSessionResult:
+    """Vendored Claude stream-json fixture verified end-to-end."""
+
+    @pytest.fixture
+    def fixture_events(self):
+        return [
+            {"type": "system", "subtype": "init", "session_id": "sess-1"},
+            {
+                "type": "assistant",
+                "message": {
+                    "content": [
+                        {"type": "text", "text": "Sure, here's..."},
+                        {"type": "tool_use", "id": "t1", "name": "Read", "input": {}},
+                    ],
+                },
+                "session_id": "sess-1",
+            },
+            {
+                "type": "tool_use",
+                "tool_name": "Edit",
+                "tool_input": {"file_path": "x.py"},
+            },
+            {
+                "type": "result",
+                "subtype": "success",
+                "result": "Done — refactored to async.",
+                "total_cost_usd": 0.4231,
+                "duration_ms": 18234,
+                "num_turns": 7,
+                "session_id": "sess-1",
+                "usage": {
+                    "input_tokens": 12000,
+                    "output_tokens": 3500,
+                    "cache_creation_input_tokens": 500,
+                    "cache_read_input_tokens": 8000,
+                },
+            },
+        ]
+
+    def test_reconstructs_response(self, claude_provider, fixture_events):
+        result = claude_provider.event_to_session_result(fixture_events, "", 0)
+        assert result["response"] == "Done — refactored to async."
+
+    def test_reconstructs_cost(self, claude_provider, fixture_events):
+        result = claude_provider.event_to_session_result(fixture_events, "", 0)
+        assert result["cost_usd"] == pytest.approx(0.4231)
+
+    def test_reconstructs_session_id(self, claude_provider, fixture_events):
+        result = claude_provider.event_to_session_result(fixture_events, "", 0)
+        assert result["session_id"] == "sess-1"
+
+    def test_reconstructs_duration_and_turns(self, claude_provider, fixture_events):
+        result = claude_provider.event_to_session_result(fixture_events, "", 0)
+        assert result["duration_ms"] == 18234
+        assert result["num_turns"] == 7
+
+    def test_canonical_usage_normalises(self, claude_provider, fixture_events):
+        cu: CanonicalUsage = claude_provider.canonical_usage(fixture_events)
+        assert cu.input_tokens == 12000
+        assert cu.output_tokens == 3500
+        assert cu.cache_read == 8000  # remapped from cache_read_input_tokens
+        assert cu.cache_write == 500  # remapped from cache_creation_input_tokens
+        assert cu.request_count == 7  # from num_turns
+
+    def test_counts_tool_calls(self, claude_provider, fixture_events):
+        # Two tool_use events: one inside an assistant message, one standalone
+        result = claude_provider.event_to_session_result(fixture_events, "", 0)
+        assert result["tool_calls"] >= 2
+
+    def test_success_on_zero_exit_with_result_event(self, claude_provider, fixture_events):
+        result = claude_provider.event_to_session_result(fixture_events, "", 0)
+        assert result["success"] is True
+        assert result["error"] is None
+
+    def test_failure_on_non_zero_exit(self, claude_provider, fixture_events):
+        result = claude_provider.event_to_session_result(
+            fixture_events, "exploded", 1,
+        )
+        assert result["success"] is False
+        assert "exploded" in (result["error"] or "")
+
+    def test_failure_on_missing_result_event(self, claude_provider):
+        events = [
+            {"type": "system", "subtype": "init", "session_id": "s"},
+            {"type": "assistant", "message": {}, "session_id": "s"},
+        ]
+        result = claude_provider.event_to_session_result(events, "", 0)
+        assert result["success"] is False
+        assert "no result event" in (result["error"] or "")
+
+
+class TestClaudeAuthDetection:
+    def test_logged_out_marker(self, claude_provider):
+        assert claude_provider.detect_auth_error(
+            "Please run 'claude login' first.", 1,
+        ) is True
+
+    def test_clean_run_not_auth_error(self, claude_provider):
+        assert claude_provider.detect_auth_error("", 0) is False
+
+    def test_unrelated_stderr_not_auth_error(self, claude_provider):
+        assert claude_provider.detect_auth_error(
+            "git: pathspec 'x' did not match any files\n", 1,
+        ) is False
+
+
+class TestClaudeSupports:
+    def test_supports_full_feature_set(self, claude_provider):
+        for feature in (
+            "max_budget", "max_turns", "session_id", "resume",
+            "mcp_runtime", "json_cost", "ide_lockfile",
+        ):
+            assert claude_provider.supports(feature), feature
+
+    def test_does_not_support_sandbox(self, claude_provider):
+        assert claude_provider.supports("sandbox") is False
+
+
+# ---------------------------------------------------------------------------
+# Codex provider
+# ---------------------------------------------------------------------------
+
+@pytest.fixture
+def codex_provider():
+    return create_cli_provider("codex")
+
+
+class TestCodexArgv:
+    def test_no_session_no_budget_no_turns(self, codex_provider):
+        task = CodexTaskSpec(prompt="hello")
+        argv = codex_provider.headless_argv(task, defaults={})
+        assert "--max-turns" not in argv
+        assert "--max-budget-usd" not in argv
+        assert "--session-id" not in argv
+        assert "--resume" not in argv
+        assert "--allowedTools" not in argv
+
+    def test_sandbox_flag(self, codex_provider):
+        task = CodexTaskSpec(prompt="x", sandbox="read-only")
+        argv = codex_provider.headless_argv(task, defaults={})
+        assert "--sandbox" in argv
+        assert "read-only" in argv
+
+    def test_ask_for_approval_flag(self, codex_provider):
+        task = CodexTaskSpec(prompt="x", ask_for_approval="on-request")
+        argv = codex_provider.headless_argv(task, defaults={})
+        assert "--ask-for-approval" in argv
+        assert "on-request" in argv
+
+    def test_default_sandbox_workspace_write(self, codex_provider):
+        task = CodexTaskSpec(prompt="x")
+        argv = codex_provider.headless_argv(task, defaults={})
+        idx = argv.index("--sandbox")
+        assert argv[idx + 1] == "workspace-write"
+
+    def test_system_prompt_prepended(self, codex_provider):
+        task = CodexTaskSpec(prompt="user thing", system_prompt="be careful")
+        argv = codex_provider.headless_argv(task, defaults={})
+        # Codex has no --system-prompt flag; we prepend with <system> tags
+        prompt_arg = argv[-1]  # last arg is the prompt
+        assert "<system>" in prompt_arg
+        assert "be careful" in prompt_arg
+        assert "user thing" in prompt_arg
+
+    def test_wrong_task_type_raises(self, codex_provider):
+        claude_task = ClaudeTaskSpec(prompt="x")
+        with pytest.raises(TypeError, match="CodexTaskSpec"):
+            codex_provider.headless_argv(claude_task, defaults={})
+
+
+class TestCodexEventReconstruction:
+    @pytest.fixture
+    def fixture_events(self):
+        # Codex has no public stream-json schema; this is a plausible
+        # synthetic stream that exercises our best-effort matchers.
+        return [
+            {"type": "message", "text": "Working on it..."},
+            {"type": "assistant", "text": "Final answer is X."},
+            {"type": "complete", "duration_ms": 5000, "stats": {"turns": 3}},
+        ]
+
+    def test_extracts_response_from_final_event(self, codex_provider, fixture_events):
+        result = codex_provider.event_to_session_result(fixture_events, "", 0)
+        # Response comes from final event's `text`/`response`/`result`/`content`
+        # if present; otherwise the last assistant message.
+        assert "Final answer is X." in result["response"]
+
+    def test_cost_always_none_for_codex(self, codex_provider, fixture_events):
+        result = codex_provider.event_to_session_result(fixture_events, "", 0)
+        assert result["cost_usd"] is None
+
+    def test_canonical_usage_zeros(self, codex_provider, fixture_events):
+        cu = codex_provider.canonical_usage(fixture_events)
+        assert cu.input_tokens == 0
+        assert cu.output_tokens == 0
+
+
+class TestCodexAuthDetection:
+    def test_openai_api_key_missing(self, codex_provider):
+        assert codex_provider.detect_auth_error(
+            "Error: OPENAI_API_KEY not set.\n", 1,
+        ) is True
+
+    def test_401_marker(self, codex_provider):
+        assert codex_provider.detect_auth_error("HTTP 401 Unauthorized\n", 1) is True
+
+
+class TestCodexSupports:
+    def test_supports_only_sandbox(self, codex_provider):
+        assert codex_provider.supports("sandbox") is True
+        for feature in (
+            "max_budget", "max_turns", "session_id", "resume",
+            "json_cost", "ide_lockfile",
+        ):
+            assert codex_provider.supports(feature) is False, feature

package/server/tests/services/cli_agent/test_service.py

@@ -0,0 +1,298 @@
+"""`AICliService` tests — fail-fast paths that don't spawn the CLI.
+
+The full subprocess-driven path is covered by live verification (see
+`docs-internal/cli_agent_framework.md` → Verification §5–7). These unit
+tests cover:
+  - `working_directory_not_git_repo` abort (no pool constructed)
+  - resolver contract: explicit `repo_root` doesn't fall back to cwd
+  - factory NotImplementedError surfaces cleanly
+  - cancel_workflow / cancel_node return zero when nothing's running
+"""
+
+from __future__ import annotations
+
+import asyncio
+import tempfile
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from services.cli_agent import ClaudeTaskSpec, CodexTaskSpec
+from services.cli_agent.service import AICliService, get_ai_cli_service
+
+
+@pytest.mark.asyncio
+async def test_not_git_repo_returns_structured_failure():
+    """Caller-supplied repo_root that isn't a git repo → fail-fast,
+    every task surfaces `working_directory_not_git_repo`."""
+    svc = AICliService()
+    with tempfile.TemporaryDirectory() as tmp:
+        result = await svc.run_batch(
+            "claude",
+            tasks=[
+                ClaudeTaskSpec(prompt="task A"),
+                ClaudeTaskSpec(prompt="task B"),
+            ],
+            node_id="n",
+            workflow_id="wf",
+            workspace_dir=Path(tmp),
+            broadcaster=None,
+            repo_root=Path(tmp),  # explicit non-git
+        )
+
+    assert result.n_tasks == 2
+    assert result.n_succeeded == 0
+    assert result.n_failed == 2
+    assert all(t.error == "working_directory_not_git_repo" for t in result.tasks)
+    assert result.total_cost_usd is None
+
+
+@pytest.mark.asyncio
+async def test_explicit_repo_root_does_not_fallback_to_cwd():
+    """When the caller passes an explicit `repo_root`, the resolver
+    must NOT walk to cwd. This is the bug we fixed during Phase 5
+    smoke-testing."""
+    # cwd is the framework worktree (a git repo). If the resolver fell
+    # back, it would silently succeed — bad.
+    svc = AICliService()
+    with tempfile.TemporaryDirectory() as tmp:
+        result = await svc.run_batch(
+            "claude",
+            tasks=[ClaudeTaskSpec(prompt="x")],
+            node_id="n",
+            workflow_id="wf",
+            workspace_dir=Path(tmp),
+            broadcaster=None,
+            repo_root=Path(tmp),
+        )
+    assert result.n_failed == 1
+    assert result.tasks[0].error == "working_directory_not_git_repo"
+
+
+@pytest.mark.asyncio
+async def test_codex_provider_works():
+    """Codex factory must build a provider; happy-path argv was already
+    covered in test_providers.py."""
+    svc = AICliService()
+    with tempfile.TemporaryDirectory() as tmp:
+        # Same not-git-repo path with Codex — confirms the provider
+        # discrim works through the service.
+        result = await svc.run_batch(
+            "codex",
+            tasks=[CodexTaskSpec(prompt="x", sandbox="read-only")],
+            node_id="n",
+            workflow_id="wf",
+            workspace_dir=Path(tmp),
+            broadcaster=None,
+            repo_root=Path(tmp),
+        )
+    assert result.provider == "codex"
+    assert result.tasks[0].provider == "codex"
+
+
+@pytest.mark.asyncio
+async def test_gemini_factory_raises_not_implemented():
+    svc = AICliService()
+    with tempfile.TemporaryDirectory() as tmp:
+        with pytest.raises(NotImplementedError, match="deferred to v2"):
+            await svc.run_batch(
+                "gemini",
+                tasks=[],  # spec irrelevant — factory raises before construction
+                node_id="n",
+                workflow_id="wf",
+                workspace_dir=Path(tmp),
+                broadcaster=None,
+                repo_root=Path(tmp),
+            )
+
+
+@pytest.mark.asyncio
+async def test_cancel_when_no_active_pools():
+    svc = AICliService()
+    assert await svc.cancel_workflow("nothing") == 0
+    assert await svc.cancel_node("nothing") == 0
+
+
+def test_singleton_accessor_returns_same_instance():
+    a = get_ai_cli_service()
+    b = get_ai_cli_service()
+    assert a is b
+
+
+@pytest.mark.asyncio
+async def test_resolver_walks_upward_to_find_git():
+    """Without `override`, the resolver tries workspace_dir then cwd.
+
+    The cli-agent-framework worktree is a git repo. A deep child path
+    should resolve via `git rev-parse --show-toplevel` to the worktree root.
+    """
+    deep = Path(__file__).resolve().parent / "deep" / "deeper"
+    root = await AICliService._resolve_repo_root(workspace_dir=deep, override=None)
+    assert root is not None
+    assert (root / ".git").exists()
+
+
+@pytest.mark.asyncio
+async def test_resolver_returns_none_when_override_not_git():
+    import tempfile
+    with tempfile.TemporaryDirectory() as tmp:
+        root = await AICliService._resolve_repo_root(
+            workspace_dir=Path(tmp),  # ignored when override is set
+            override=Path(tmp),
+        )
+        assert root is None
+
+
+# ---------------------------------------------------------------------------
+# Execution-engine integration: drive the real `run_batch` (via the DI
+# accessor) and assert the `[CC-Agent ...]` log lines fire at the right
+# transitions. This replaces direct contextvar pokes — every assertion
+# walks the same resolver / register_batch / session-start path the
+# production code does.
+#
+# The top-level `tests/conftest.py` stubs `core.logging.get_logger` with
+# a shared MagicMock, so we can't use `caplog`. Instead each module's
+# module-level ``logger`` IS that shared MagicMock — we inspect its
+# ``info``/``warning`` ``call_args_list`` to verify the diagnostic
+# chain fires.
+# ---------------------------------------------------------------------------
+
+
+def _logger_messages(*module_loggers) -> str:
+    """Concatenate every ``.info`` / ``.warning`` / ``.error`` call's
+    rendered template+args across one or more module-level loggers."""
+    out: list[str] = []
+    for lg in module_loggers:
+        for level in ("info", "warning", "error", "exception", "debug"):
+            method = getattr(lg, level, None)
+            if method is None or not hasattr(method, "call_args_list"):
+                continue
+            for call in method.call_args_list:
+                args = call.args or ()
+                if not args:
+                    continue
+                template = args[0]
+                if not isinstance(template, str):
+                    out.append(repr(template))
+                    continue
+                try:
+                    out.append(template % args[1:] if len(args) > 1 else template)
+                except (TypeError, ValueError):
+                    out.append(template + " | " + repr(args[1:]))
+    return "\n".join(out)
+
+
+@pytest.mark.asyncio
+async def test_run_batch_emits_diagnostic_logs_when_workspace_not_git(monkeypatch):
+    """Abort path: `run_batch` enters, fails the resolver, returns
+    structured failure. The `[CC-Agent run_batch] enter` and
+    `[CC-Agent run_batch] aborting` log lines must fire so the operator
+    sees WHY the batch never reached `register_batch`."""
+    # Force the module-level logger to a Mock for THIS test, regardless of
+    # whether conftest's `core.logging.get_logger` stub was active at the
+    # moment the service module was first imported. In the full-suite
+    # ordering some sibling test imports `core.logging` after the stub is
+    # placed, leaving the cli_agent module with a real structlog
+    # BoundLogger that has no `reset_mock`. Locally patching makes the test
+    # robust to import-order pollution.
+    from services.cli_agent import service as svc_mod
+    svc_logger = MagicMock()
+    monkeypatch.setattr(svc_mod, "logger", svc_logger)
+
+    svc = get_ai_cli_service()  # DI singleton — same accessor production uses
+    import tempfile
+    with tempfile.TemporaryDirectory() as tmp:
+        result = await svc.run_batch(
+            "claude",
+            tasks=[ClaudeTaskSpec(prompt="hello")],
+            node_id="ccode_test_abort",
+            workflow_id="wf_abort",
+            workspace_dir=Path(tmp),
+            broadcaster=None,
+            repo_root=Path(tmp),
+            connected_tools=[
+                {"node_id": "ddg_1", "node_type": "duckduckgoSearch",
+                 "label": "DDG", "parameters": {}},
+            ],
+        )
+
+    text = _logger_messages(svc_logger)
+    assert "[CC-Agent run_batch] enter" in text, text
+    assert "duckduckgoSearch" in text, text
+    assert "[CC-Agent run_batch] aborting" in text, text
+    # The abort path MUST NOT register a batch (no MCP tokens leaked):
+    assert "[CC-Agent MCP register_batch]" not in text, text
+    assert result.n_failed == 1
+
+
+@pytest.mark.asyncio
+async def test_run_batch_registers_mcp_batch_on_happy_path(monkeypatch):
+    """Happy path: real resolver, real `register_batch`, but
+    `AICliSession.start` is short-circuited so we don't spawn `claude`.
+    Asserts the `[CC-Agent MCP register_batch]` log fires with the
+    expected tool list — proving the diagnostic chain is intact
+    end-to-end and the spawned CLI WOULD see the MCP server registered
+    for it."""
+    from services.cli_agent import session as session_mod
+    from services.cli_agent import service as svc_mod
+    from services.cli_agent import mcp_server as mcp_mod
+    from services.cli_agent.protocol import SessionResult
+
+    # See the abort-path test for the rationale — patch the module-level
+    # logger directly so the test does not depend on conftest's
+    # `core.logging.get_logger` stub being active at import time.
+    svc_logger = MagicMock()
+    mcp_logger = MagicMock()
+    monkeypatch.setattr(svc_mod, "logger", svc_logger)
+    monkeypatch.setattr(mcp_mod, "logger", mcp_logger)
+
+    started = {"count": 0}
+
+    async def _fake_start(self):  # noqa: ANN001
+        started["count"] += 1
+        self._completed = True
+
+    async def _fake_wait(self, timeout):  # noqa: ANN001, ARG002
+        return SessionResult(
+            task_id=self.task_id, provider=self._provider.name,
+            prompt=getattr(self._task, "prompt", ""),
+            success=True, response="stub",
+        )
+
+    async def _fake_cleanup(self):  # noqa: ANN001
+        pass
+
+    monkeypatch.setattr(session_mod.AICliSession, "start", _fake_start)
+    monkeypatch.setattr(session_mod.AICliSession, "wait_for_completion", _fake_wait)
+    monkeypatch.setattr(session_mod.AICliSession, "cleanup", _fake_cleanup)
+
+    svc = get_ai_cli_service()
+    workspace = Path(__file__).resolve().parents[3]  # the repo root (a git repo)
+    result = await svc.run_batch(
+        "claude",
+        tasks=[ClaudeTaskSpec(prompt="ping")],
+        node_id="ccode_test_happy",
+        workflow_id="wf_happy",
+        workspace_dir=workspace,
+        broadcaster=None,
+        repo_root=None,  # let the resolver find the parent .git
+        connected_tools=[
+            {"node_id": "ddg_1", "node_type": "duckduckgoSearch",
+             "label": "DDG", "parameters": {}},
+        ],
+        connected_skill_names=["duckduckgo-search-skill"],
+    )
+
+    text = _logger_messages(svc_logger, mcp_logger)
+    # Engine-entry log:
+    assert "[CC-Agent run_batch] enter" in text, text
+    assert "duckduckgoSearch" in text, text
+    # Resolver succeeded:
+    assert "[CC-Agent run_batch] resolved repo_root=" in text, text
+    # MCP token registered with our connected tool:
+    assert "[CC-Agent MCP register_batch]" in text, text
+    # Session was actually exercised (proves the engine ran the inner
+    # gather, not just the abort path):
+    assert started["count"] == 1
+    assert result.n_succeeded == 1