superqode 2.4.43__tar.gz → 2.4.44__tar.gz

{superqode-2.4.43 → superqode-2.4.44}/CHANGELOG.md

@@ -7,6 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.4.44] - 2026-10-02
+
+### Fixed
+
+- Show `:work programs`, `:work program-run`, `:work invocations`, `:work reconcile`, and `:benchmark compare` in the TUI command list.
+- Run `:benchmark compare` through the same CLI path as `:benchmark run`.
+
 ## [2.4.43] - 2026-10-02
 
 ### Added

{superqode-2.4.43 → superqode-2.4.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superqode
-Version: 2.4.43
+Version: 2.4.44
 Summary: The harness layer for coding agents
 Author-email: Shashi Jagtap <info@super-agentic.ai>
 Maintainer-email: Shashi Jagtap <info@super-agentic.ai>

{superqode-2.4.43 → superqode-2.4.44}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superqode"
-version = "2.4.43"
+version = "2.4.44"
 description = "The harness layer for coding agents"
 readme = "README.md"
 license = "Apache-2.0"

{superqode-2.4.43 → superqode-2.4.44}/src/superqode/__init__.py

@@ -38,7 +38,7 @@ __all__ = [
     "sidebar",
 ]
 
-__version__ = "2.4.43"
+__version__ = "2.4.44"
 
 # Stable, lightweight public extension surface.  Importing this package does
 # not discover or execute third-party extensions; discovery happens only when

{superqode-2.4.43 → superqode-2.4.44}/src/superqode/app/constants.py

@@ -704,6 +704,10 @@ COMMANDS = [
     ":work artifact-add",
     ":work artifacts",
     ":work events",
+    ":work programs",
+    ":work program-run",
+    ":work invocations",
+    ":work reconcile",
     ":work prepare",
     ":work diff",
     ":work approve",
@@ -731,6 +735,7 @@ COMMANDS = [
     ":compare",
     ":benchmark",
     ":benchmark run",
+    ":benchmark compare",
     ":sandbox",
     ":sandbox doctor",
     ":sandbox run",

{superqode-2.4.43 → superqode-2.4.44}/src/superqode/app/mixins/commands_impl.py

@@ -7459,7 +7459,7 @@ class CommandImplMixin:
         except ValueError as exc:
             log.add_error(f"Could not parse :benchmark arguments: {exc}")
             return
-        if tokens and tokens[0] == "run":
+        if tokens and tokens[0] in {"run", "compare"}:
             self._run_cli_passthrough(["benchmark", *tokens], log, "Benchmark command")
             return
 
@@ -7480,6 +7480,10 @@ class CommandImplMixin:
             "    superqode benchmark run tasks.json --target superqode --target opencode --target pi --target deepagents\n",
             style=THEME["cyan"],
         )
+        t.append(
+            "    superqode benchmark compare manifest.json\n",
+            style=THEME["cyan"],
+        )
         if args.strip():
             t.append(
                 "\n  TUI note: benchmark execution is CLI-backed for reproducible logs.\n",

{superqode-2.4.43 → superqode-2.4.44}/src/superqode/app/mixins/helper_mcp_attach.py

@@ -363,12 +363,15 @@ class HelperMcpAttachMixin:
             return None
         pure = getattr(self, "_pure_mode", None)
         if pure is not None and pure.session.connected:
-            if not getattr(self, "_chat_mode", False) and (
-                getattr(pure, "_harness_spec", None) is not None
-                or not getattr(pure, "_agent", None)
+            spec = getattr(pure, "_harness_spec", None)
+            pipy = getattr(getattr(spec, "runtime", None), "backend", None) == "pipy"
+            if (
+                not getattr(self, "_chat_mode", False)
+                and not pipy
+                and (spec is not None or not getattr(pure, "_agent", None))
             ):
                 log.add_error(
-                    "Image input is available in direct Chat, built-in coding, and image-capable ACP agents. Your attachments are still staged."
+                    "Image input is available in PiPy, direct Chat, built-in coding, and image-capable ACP agents. Your attachments are still staged."
                 )
                 return None
             if not self._model_supports_vision(pure.session.model):

{superqode-2.4.43 → superqode-2.4.44}/src/superqode/harness/backends/base.py

@@ -104,6 +104,7 @@ class HarnessBackendRequest:
     sandbox_backend: str = "local"
     system_level: SystemPromptLevel | None = None
     metadata: dict[str, Any] = field(default_factory=dict)
+    images: tuple[Any, ...] = ()
 
 
 @dataclass(frozen=True)

{superqode-2.4.43 → superqode-2.4.44}/src/superqode/harness/backends/pipy.py

@@ -107,7 +107,19 @@ class PiPyHarnessBackend:
         ref = await self.adapter.resume(_session_ref(request))
         self._active_ref = ref
         try:
-            async for event in self.adapter.send(ref, HarnessMessage("user", request.prompt)):
+            message = HarnessMessage(
+                "user",
+                request.prompt,
+                metadata={
+                    "images": [
+                        {"data": image.data, "mime_type": image.mime_type}
+                        for image in request.images
+                    ]
+                }
+                if request.images
+                else {},
+            )
+            async for event in self.adapter.send(ref, message):
                 yield event
         except Exception as exc:
             from ..pipy_recovery import PiPyRecoveryRequired

{superqode-2.4.43 → superqode-2.4.44}/src/superqode/harness/kernel.py

@@ -41,6 +41,7 @@ class HarnessRunRequest:
     system_level: SystemPromptLevel | None = None
     result_schema: Any | None = None
     metadata: dict[str, Any] = field(default_factory=dict)
+    images: tuple[Any, ...] = ()
 
 
 @dataclass(frozen=True)
@@ -155,6 +156,7 @@ class HarnessSession:
         system_level: SystemPromptLevel | None = None,
         result: Any | None = None,
         metadata: dict[str, Any] | None = None,
+        images: tuple[Any, ...] = (),
     ) -> HarnessRunResult:
         """Run one prompt through this harness session."""
         request = HarnessRunRequest(
@@ -168,6 +170,7 @@ class HarnessSession:
             system_level=system_level,
             result_schema=result,
             metadata=dict(metadata or {}),
+            images=tuple(images),
         )
         return await self.run(request)
 
@@ -182,6 +185,7 @@ class HarnessSession:
         sandbox_backend: str = "local",
         system_level: SystemPromptLevel | None = None,
         metadata: dict[str, Any] | None = None,
+        images: tuple[Any, ...] = (),
     ) -> AsyncIterator[HarnessEvent]:
         """Stream one prompt through this harness session as normalized events."""
         from superqode.governance import active_governance, governance_scope, load_governance
@@ -198,6 +202,7 @@ class HarnessSession:
                     sandbox_backend=sandbox_backend,
                     system_level=system_level,
                     metadata=metadata,
+                    images=images,
                 ):
                     yield event
             return
@@ -230,6 +235,7 @@ class HarnessSession:
             runtime=runtime,
             sandbox_backend=sandbox_backend,
             system_level=system_level,
+            images=tuple(images),
             metadata={
                 **dict(metadata or {}),
                 "_harness_store": self.kernel.store,
@@ -396,6 +402,7 @@ class HarnessSession:
             runtime=request.runtime,
             sandbox_backend=request.sandbox_backend,
             system_level=request.system_level,
+            images=request.images,
             metadata={
                 **request.metadata,
                 "_harness_store": self.kernel.store,

{superqode-2.4.43 → superqode-2.4.44}/src/superqode/harness/pipy_adapter.py

@@ -190,6 +190,15 @@ class PiPyHarnessProtocolAdapter:
         message: HarnessMessage,
     ) -> AsyncIterator[HarnessEvent]:
         coding_session = await self._require(session)
+        from superqode.pipy.messages import ImageContent
+        from superqode.pipy.ai.gateway import _gateway_content
+
+        images = [
+            ImageContent(data=entry["data"], mime_type=entry["mime_type"])
+            for entry in message.metadata.get("images", [])
+        ]
+        if images:
+            _gateway_content(images)  # Apply shared bounds before storing the prompt.
         model = coding_session.harness.get_model()
         yield HarnessEvent(
             type="model.requested",
@@ -211,10 +220,14 @@ class PiPyHarnessProtocolAdapter:
             from .pipy_recovery import PiPyRunRecovery
 
             recovery = PiPyRunRecovery(scope, coding_session, config)
-            await recovery.prepare(message.content)
+            await recovery.prepare(message.content, images=images)
         try:
             with recovery_scope(recovery.scope if recovery else scope):
-                stream = coding_session.prompt_events(message.content)
+                stream = (
+                    coding_session.prompt_events(message.content, images)
+                    if images
+                    else coding_session.prompt_events(message.content)
+                )
                 async for event in stream:
                     for translated in translate_event(event):
                         yield translated

{superqode-2.4.43 → superqode-2.4.44}/src/superqode/harness/pipy_recovery.py

@@ -77,7 +77,7 @@ class PiPyRunRecovery:
                 invocation_id=identity,
             )
 
-    async def prepare(self, prompt):
+    async def prepare(self, prompt, images=None):
         try:
             workspace = await check_recovery_workspace(self.scope)
             identity = "pipy.run.start"
@@ -85,6 +85,7 @@ class PiPyRunRecovery:
             fingerprint = input_fingerprint(
                 {
                     "prompt": prompt,
+                    **({"images": [asdict(image) for image in images]} if images else {}),
                     "config": self.config,
                     "model": asdict(self.coding.harness.get_model()),
                     "tools": {t.name: dict(t.parameters) for t in self.coding.harness.get_tools()},

{superqode-2.4.43 → superqode-2.4.44}/src/superqode/pure_mode.py

@@ -625,9 +625,12 @@ class PureMode:
         self, prompt: str, plan_mode: Optional[bool] = None, *, images=None
     ) -> AgentResponse:
         """Run a task in Pure Mode."""
-        if images and (self._harness_spec is not None or self._agent is None):
+        if images and (
+            (self._harness_spec is not None and self._harness_spec.runtime.backend != "pipy")
+            or (self._harness_spec is None and self._agent is None)
+        ):
             raise ValueError(
-                "This runtime does not support composer image input. Use built-in coding or direct Chat."
+                "This runtime does not support composer image input. Use PiPy, built-in coding or direct Chat."
             )
         if self._harness_spec is not None:
             provider, model = self._resolve_harness_route()
@@ -638,6 +641,7 @@ class PureMode:
                 model=model,
                 working_directory=self.session.working_directory,
                 runtime=self._harness_spec.runtime.backend,
+                **({"images": tuple(images)} if images else {}),
             )
             self.session.total_tool_calls += result.tool_calls_made
             self.session.total_iterations += result.iterations
@@ -689,9 +693,12 @@ class PureMode:
         # Never let a provider/runtime without usage metadata display figures
         # left over from the previous turn.
         self._last_stats = {}
-        if images and (self._harness_spec is not None or self._agent is None):
+        if images and (
+            (self._harness_spec is not None and self._harness_spec.runtime.backend != "pipy")
+            or (self._harness_spec is None and self._agent is None)
+        ):
             raise ValueError(
-                "This runtime does not support composer image input. Use built-in coding or direct Chat."
+                "This runtime does not support composer image input. Use PiPy, built-in coding or direct Chat."
             )
         self._cancel_requested = False
         if self._harness_spec is not None:
@@ -711,6 +718,7 @@ class PureMode:
                     model=model,
                     working_directory=self.session.working_directory,
                     runtime=self._harness_spec.runtime.backend,
+                    **({"images": tuple(images)} if images else {}),
                 ):
                     if self._cancel_requested:
                         break

{superqode-2.4.43 → superqode-2.4.44}/src/superqode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superqode
-Version: 2.4.43
+Version: 2.4.44
 Summary: The harness layer for coding agents
 Author-email: Shashi Jagtap <info@super-agentic.ai>
 Maintainer-email: Shashi Jagtap <info@super-agentic.ai>

{superqode-2.4.43 → superqode-2.4.44}/tests/test_catalog_freshness.py

@@ -38,16 +38,16 @@ class _StatusStub(ModelCatalogMixin):
 
 
 def test_the_registry_refreshes_on_the_same_schedule_as_models_dev():
-    """Both catalogues refresh on the same launch and interval timers."""
+    """Both catalogues refresh once per launch, not on an hourly interval."""
     source = pathlib.Path("src/superqode/app_main.py").read_text(encoding="utf-8")
 
     for call in (
         "self.set_timer(0.5, self._start_models_dev_refresh)",
-        "self.set_interval(60 * 60, self._start_models_dev_refresh)",
         "self.set_timer(0.5, self._start_acp_registry_refresh)",
-        "self.set_interval(60 * 60, self._start_acp_registry_refresh)",
     ):
         assert call in source, call
+    assert "set_interval(60 * 60, self._start_models_dev_refresh)" not in source
+    assert "set_interval(60 * 60, self._start_acp_registry_refresh)" not in source
 
 
 def test_refreshes_run_as_background_workers():

{superqode-2.4.43 → superqode-2.4.44}/tests/test_cli_contract.py

@@ -10,7 +10,7 @@ import click
 from superqode.main import cli_main
 
 
-EXPECTED_COMMAND_COUNT = 298
+EXPECTED_COMMAND_COUNT = 307
 # Rebaselined for `superqode update` (261 -> 262: exactly one command added),
 # and again for the `copilot-cli` / `grok-cli` subscription runtimes, which
 # widen the --runtime choice list without adding a Click command. The same work
@@ -147,7 +147,13 @@ EXPECTED_COMMAND_COUNT = 298
 # Gauge gate adds --require-ship to enforce recorded approval and L2 readiness.
 # No command is added or removed.
 # Rebaselined for interactive resume/fork and startup approval/interaction options.
-EXPECTED_HELP_TREE_SHA256 = "924133e9e1d889830df4cf8ee7ac4d5020f0f11ed38940b124f4112ab163f050"
+# Rebaselined for the command surface shipped after 2.4.38: `mcp list`,
+# `mcp login`, `mcp logout`, `mcp reconnect`, `work programs`,
+# `work program-run`, `work invocations`, `work reconcile`, and
+# `benchmark compare` (298 -> 307). The same releases added
+# `harness eval --recovery-store` and refreshed the registry-derived
+# `--connect` choice list. No previously shipped command was removed.
+EXPECTED_HELP_TREE_SHA256 = "d7ab559cc090732ed1347229b50436f407b542cb1e01ff5f806d07da34694a90"
 
 
 def _render_help_tree() -> tuple[int, str]:

{superqode-2.4.43 → superqode-2.4.44}/tests/test_dx_enhancements.py

@@ -136,6 +136,9 @@ def test_return_to_agent_restores_transcript_and_focus():
         def _reset_connect_selection_states(self):
             self.reset_connect = True
 
+        def _end_connection_view(self, _log):
+            return False
+
         def query_one(self, *_args, **_kwargs):
             return self.log
 

{superqode-2.4.43 → superqode-2.4.44}/tests/test_grok_cli_auth.py

@@ -419,6 +419,11 @@ def test_direct_grok_byok_connection_imports_cli_session_first():
             calls.append(on_login_success)
             return False
 
+        _connect_byok_mode_impl = SuperQodeApp._connect_byok_mode_impl
+
+        def _connection_attempt_failed(self, log, detail):
+            raise AssertionError(detail)
+
     SuperQodeApp._connect_byok_mode(_Stub(), "grok-cli", "grok-4.5", _Log())
 
     assert len(calls) == 1

{superqode-2.4.43 → superqode-2.4.44}/tests/test_mcp_oauth_generalized.py

@@ -20,7 +20,6 @@ from superqode.mcp.auth_storage import (
     MCPAuthStorage,
     TokenStorage,
     _FileTokenStorageAdapter,
-    _has_keyring,
     make_default_token_storage,
 )
 from superqode.mcp.hf_auth import (
@@ -307,46 +306,66 @@ def test_file_storage_adapter_satisfies_protocol(tmp_path, monkeypatch):
     assert adapter.delete_tokens("https://example.com") is True
 
 
-def test_make_default_token_storage_returns_a_storage():
+def test_make_default_token_storage_returns_a_storage(monkeypatch, tmp_path):
     """Whichever backend is preferred, the helper must return
     *something* — fallback chain is the whole point."""
+    monkeypatch.setenv("HOME", str(tmp_path))
+    monkeypatch.setattr("superqode.mcp.auth_storage._has_keyring", lambda: False)
     storage = make_default_token_storage()
     assert hasattr(storage, "save_tokens")
     assert hasattr(storage, "load_tokens")
     assert hasattr(storage, "delete_tokens")
 
+    pytest.importorskip("keyring")
+    monkeypatch.setattr("superqode.mcp.auth_storage._has_keyring", lambda: True)
+    keyed = make_default_token_storage()
+    assert isinstance(keyed, KeyringTokenStorage)
+
+
+def test_keyring_storage_round_trip(monkeypatch):
+    """Save, load, and delete must round-trip through the keyring adapter.
+
+    The OS keychain is not part of this contract. A desktop session can
+    deny or hang `SecItemAdd` for the test runner, and collection must
+    not write probe passwords into the login keychain.
+    """
+    pytest.importorskip("keyring")
 
-@pytest.mark.skipif(not _has_keyring(), reason="OS keyring backend not available")
-def test_keyring_storage_round_trip():
-    """When keyring is available, save/load/delete must round-trip.
-    Uses a unique service name per run so we don't trample real
-    user data if the test is run in a desktop session."""
-    import uuid
+    class _FakeKeyring:
+        def __init__(self):
+            self.store: dict[tuple[str, str], str] = {}
 
-    service = f"superqode-mcp-test-{uuid.uuid4().hex[:8]}"
-    storage = KeyringTokenStorage(service=service)
+        def set_password(self, service, identity, payload):
+            self.store[(service, identity)] = payload
+
+        def get_password(self, service, identity):
+            return self.store.get((service, identity))
+
+        def delete_password(self, service, identity):
+            self.store.pop((service, identity), None)
+
+    storage = KeyringTokenStorage(service="superqode-mcp-test")
+    monkeypatch.setattr(storage, "_keyring", _FakeKeyring())
 
     tokens = OAuthTokens(
         access_token="kr-access",
         refresh_token="kr-refresh",
         scope="read",
     )
-    try:
-        storage.save_tokens("https://example.com/mcp", tokens)
-        loaded = storage.load_tokens("https://example.com/mcp")
-        assert loaded is not None
-        assert loaded.access_token == "kr-access"
-        assert loaded.refresh_token == "kr-refresh"
-        assert loaded.scope == "read"
-
-        # Different URL = different entry — no cross-talk.
-        other = storage.load_tokens("https://other.example/mcp")
-        assert other is None
-    finally:
-        storage.delete_tokens("https://example.com/mcp")
-
-
-@pytest.mark.skipif(not _has_keyring(), reason="OS keyring backend not available")
+    storage.save_tokens("https://example.com/mcp", tokens)
+    loaded = storage.load_tokens("https://example.com/mcp")
+    assert loaded is not None
+    assert loaded.access_token == "kr-access"
+    assert loaded.refresh_token == "kr-refresh"
+    assert loaded.scope == "read"
+
+    other = storage.load_tokens("https://other.example/mcp")
+    assert other is None
+
+    assert storage.delete_tokens("https://example.com/mcp") is True
+    assert storage.load_tokens("https://example.com/mcp") is None
+
+
 def test_keyring_storage_identity_is_url_independent_per_server():
     """Two URLs must produce different identity slots — otherwise one
     server's token would shadow another's."""

{superqode-2.4.43 → superqode-2.4.44}/tests/test_tui_image_voice.py

@@ -566,3 +566,130 @@ async def test_coding_worker_restores_images_after_provider_rejection(screenshot
         assert app.query_one("#prompt-input", SelectionAwareInput).value == "Review screenshot"
         assert not app.is_busy
         app._pure_mode = None
+
+
+async def _pipy_image_mode(tmp_path, monkeypatch, seen):
+    """Real kernel/backend/PiPy loop with an offline provider boundary."""
+    from superqode.pure_mode import PureMode
+    from superqode.harness.kernel import HarnessKernel
+    from superqode.harness.store import MemoryHarnessStore
+    from superqode.harness.templates import pipy_template
+    from superqode.harness.backends.pipy import PiPyHarnessBackend
+    from superqode.harness.pipy_adapter import PiPyHarnessProtocolAdapter
+    from superqode.pipy import CodingSessionOptions, PiPyCodingSession, Model
+    from superqode.pipy.ai import FakeStream, text_response
+    from superqode.pipy.ai.gateway import _gateway_messages
+
+    async def stream(model, context, options):
+        seen.extend(_gateway_messages(context.system_prompt, context.messages))
+        return FakeStream([text_response("Image reviewed")])(model, context, options)
+
+    async def factory(request, cwd, path):
+        return await PiPyCodingSession.create(
+            CodingSessionOptions(
+                cwd=cwd,
+                model=Model(id="vision", provider="fixture"),
+                stream_fn=stream,
+                session_root=tmp_path / "sessions",
+            )
+        )
+
+    monkeypatch.setattr("superqode.harness.pipy_adapter._record_session_path", lambda *a: None)
+    adapter = PiPyHarnessProtocolAdapter(session_factory=factory)
+    monkeypatch.setattr(
+        "superqode.harness.kernel.create_harness_backend",
+        lambda *a: PiPyHarnessBackend(adapter=adapter),
+    )
+    pure = PureMode()
+    pure._harness_spec = pipy_template()
+    pure._harness_session = await HarnessKernel(
+        pure._harness_spec, store=MemoryHarnessStore()
+    ).session()
+    pure.session.connected = True
+    pure.session.provider = "fixture"
+    pure.session.model = "vision"
+    pure.session.working_directory = tmp_path
+    return pure
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("streaming", [False, True])
+async def test_pipy_harness_images_reach_provider_without_metadata_copy(
+    screenshot, tmp_path, monkeypatch, streaming
+):
+    seen = []
+    pure = await _pipy_image_mode(tmp_path, monkeypatch, seen)
+    image = load_image(screenshot)
+    if streaming:
+        text = "".join([chunk async for chunk in pure.run_streaming("Review", images=[image])])
+    else:
+        text = (await pure.run("Review", images=[image])).content
+    assert text == "Image reviewed"
+    user = next(message for message in seen if message.role == "user")
+    assert user.content == image_message("Review", [image])
+    store = pure._harness_session.kernel.store
+    runs = store.list_runs()
+    assert all("images" not in run.metadata for run in runs)
+
+
+@pytest.mark.asyncio
+async def test_pipy_composer_paste_sends_image_through_real_harness(
+    screenshot, tmp_path, monkeypatch
+):
+    seen = []
+    pure = await _pipy_image_mode(tmp_path, monkeypatch, seen)
+    app = SuperQodeApp()
+    async with app.run_test() as pilot:
+        app._pure_mode = pure
+        app._model_supports_vision = lambda model: True
+        log = app.query_one("#log", ConversationLog)
+        app._handle_paste_image(str(screenshot), log)
+        assert app._prepare_image_input(log)[0].path == screenshot.resolve()
+        deliveries = []
+        send = app._send_to_pure_mode
+        monkeypatch.setattr(
+            app, "_send_to_pure_mode", lambda text, log: deliveries.append(send(text, log))
+        )
+        app._handle_message("Review this screenshot", log)
+        await deliveries[-1].wait()
+        await pilot.pause()
+        user = next(message for message in seen if message.role == "user")
+        assert user.content[1]["image_url"]["url"].startswith("data:image/png;base64,")
+        assert not app._staged_images
+        assert not app.is_busy
+        app._pure_mode = None
+
+
+@pytest.mark.asyncio
+async def test_other_harness_still_rejects_composer_images(screenshot):
+    from superqode.pure_mode import PureMode
+    from superqode.harness.templates import rlm_template
+
+    pure = PureMode()
+    pure._harness_spec = rlm_template()
+    with pytest.raises(ValueError, match="does not support composer image"):
+        await pure.run("Review", images=[load_image(screenshot)])
+
+
+@pytest.mark.parametrize(
+    "command",
+    [
+        ":work programs example --json",
+        ":work invocations example --json",
+        ':work program-run example --code "read files.py"',
+        ':work reconcile example task call --actor operator --reason "Verified result"',
+        ':benchmark compare "example manifest.json" --repetitions 1',
+    ],
+)
+@pytest.mark.asyncio
+async def test_tui_work_and_benchmark_commands_dispatch_cli_arguments(monkeypatch, command):
+    import shlex
+
+    app = SuperQodeApp()
+    dispatched = []
+    async with app.run_test():
+        monkeypatch.setattr(
+            app, "_run_cli_passthrough", lambda parts, log, label: dispatched.append(parts)
+        )
+        app._handle_command(command, app.query_one("#log", ConversationLog))
+        assert dispatched == [shlex.split(command.removeprefix(":"))]