comate-cli 0.7.3__tar.gz → 0.7.4__tar.gz

{comate_cli-0.7.3 → comate_cli-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.7.3
+Version: 0.7.4
 Summary: Comate terminal CLI built on comate-agent-sdk
 Project-URL: Homepage, https://github.com/AndyLee1024/agent-sdk
 Project-URL: Repository, https://github.com/AndyLee1024/agent-sdk

{comate_cli-0.7.3 → comate_cli-0.7.4}/comate_cli/terminal_agent/status_bar.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import logging
 import subprocess
 import time
@@ -40,7 +41,7 @@ class StatusBar:
         self._session = session
         self._model_name: str = self._resolve_model_name(session)
         self._mode: str = "act"
-        self._git_branch: str = self._resolve_git_branch()
+        self._git_branch: str = "N/A"
         self._context_used_pct: float = 0.0
         self._context_left_pct: float = 100.0
         self._git_diff_stats: GitDiffStats | None = None
@@ -274,8 +275,20 @@ class StatusBar:
         self._context_used_pct = normalized
         self._context_left_pct = max(0.0, 100.0 - normalized)
 
-        self._git_branch = self._resolve_git_branch()
-        self._ensure_git_diff_stats()
+        branch_task = asyncio.to_thread(self._resolve_git_branch)
+        now = time.monotonic()
+        diff_is_stale = (
+            self._git_diff_stats is None
+            or now - self._git_diff_cache_time >= self._GIT_DIFF_CACHE_SECONDS
+        )
+        if diff_is_stale:
+            diff_task = asyncio.to_thread(self._resolve_git_diff_stats)
+            branch, diff_stats = await asyncio.gather(branch_task, diff_task)
+            self._git_diff_stats = diff_stats
+            self._git_diff_cache_time = time.monotonic()
+        else:
+            branch = await branch_task
+        self._git_branch = branch
 
         # Refresh token usage cache if any token-related items are enabled.
         cfg = self._config

{comate_cli-0.7.3 → comate_cli-0.7.4}/comate_cli/terminal_agent/tui.py

@@ -139,6 +139,16 @@ def _truncate_file_history(path: Path, max_entries: int = 200) -> None:
     path.write_bytes(rewritten_bytes)
 
 
+def _load_plugins_blocking(project_path: Path) -> tuple[list[Any], list[Any]]:
+    from comate_agent_sdk.plugins import PluginLoader, create_plugin_registry
+
+    loader = PluginLoader()
+    registry = create_plugin_registry()
+    data_dir = registry.base_dir / "data"
+    data_dir.mkdir(parents=True, exist_ok=True)
+    return loader.load_all(registry=registry, project_path=project_path)
+
+
 class TerminalAgentTUI(
     KeyBindingsMixin,
     InputBehaviorMixin,
@@ -266,6 +276,7 @@ class TerminalAgentTUI(
         self._ui_tick_task: asyncio.Task[None] | None = None
         self._mcp_init_task: asyncio.Task[None] | None = None
         self._plugin_init_task: asyncio.Task[None] | None = None
+        self._startup_status_refresh_task: asyncio.Task[None] | None = None
         self._plugin_init_cancel_timeout_s = 1.0
         self._interrupt_requested_at: float | None = None
         self._interrupt_force_window_seconds = 1.5
@@ -1801,6 +1812,24 @@ class TerminalAgentTUI(
             self._ui_tick(),
             name="terminal-ui-tick",
         )
+        status_bar = getattr(self, "_status_bar", None)
+        if status_bar is not None:
+            async def _do_startup_status_refresh() -> None:
+                try:
+                    await status_bar.refresh()
+                except asyncio.CancelledError:
+                    raise
+                except Exception:
+                    logger.debug("startup status refresh failed", exc_info=True)
+                finally:
+                    if not self._closing:
+                        self._refresh_layers()
+                        self._invalidate()
+
+            self._startup_status_refresh_task = asyncio.create_task(
+                _do_startup_status_refresh(),
+                name="terminal-startup-status-refresh",
+            )
         if hasattr(self, "_session") and self._session is not None:
             self._event_pump_task = asyncio.create_task(
                 self._consume_event_stream(),
@@ -1841,6 +1870,16 @@ class TerminalAgentTUI(
                 self._ui_tick_task.cancel()
                 with suppress(asyncio.CancelledError):
                     await self._ui_tick_task
+            startup_status_refresh_task = getattr(
+                self,
+                "_startup_status_refresh_task",
+                None,
+            )
+            if startup_status_refresh_task is not None:
+                startup_status_refresh_task.cancel()
+                with suppress(asyncio.CancelledError):
+                    await startup_status_refresh_task
+                self._startup_status_refresh_task = None
             event_pump_task = getattr(self, "_event_pump_task", None)
             if event_pump_task is not None:
                 event_pump_task.cancel()
@@ -1848,19 +1887,25 @@ class TerminalAgentTUI(
                     await event_pump_task
             self._renderer.close()
 
+    def _plugin_project_path(self) -> Path:
+        session = getattr(self, "_session", None)
+        session_cwd = getattr(session, "_cwd", None)
+        if session_cwd:
+            return Path(session_cwd).expanduser().resolve()
+        return Path.cwd().expanduser().resolve()
+
     async def _init_plugins(self) -> None:
         """Load and inject plugin resources at startup."""
-        from comate_agent_sdk.plugins import create_plugin_registry, PluginLoader
-
-        loader = PluginLoader()
-        registry = create_plugin_registry()
-        # Ensure plugin data directory exists
-        data_dir = registry.base_dir / "data"
-        data_dir.mkdir(parents=True, exist_ok=True)
-        self._loaded_plugins, self._plugin_errors = loader.load_all(
-            registry=registry,
-            project_path=Path.cwd(),
+        loaded_plugins, plugin_errors = await asyncio.to_thread(
+            _load_plugins_blocking,
+            self._plugin_project_path(),
         )
+        if self._closing:
+            logger.debug("Plugin load completed after TUI close; discarding results")
+            return
+
+        self._loaded_plugins = loaded_plugins
+        self._plugin_errors = plugin_errors
         self._plugin_command_names: set[str] = set()
         self._inject_plugin_resources(self._loaded_plugins)
         logger.info(

{comate_cli-0.7.3 → comate_cli-0.7.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "comate-cli"
-version = "0.7.3"
+version = "0.7.4"
 description = "Comate terminal CLI built on comate-agent-sdk"
 readme = "README.md"
 requires-python = ">=3.11"

{comate_cli-0.7.3 → comate_cli-0.7.4}/tests/test_status_bar.py

@@ -1,13 +1,15 @@
 from __future__ import annotations
 
+import asyncio
 import subprocess
+import time
 import unittest
 from pathlib import Path
 from types import SimpleNamespace
 from unittest.mock import patch
 
 from comate_agent_sdk.agent.goal_state import GoalSnapshot, GoalStatus
-from comate_cli.terminal_agent.status_bar import StatusBar
+from comate_cli.terminal_agent.status_bar import GitDiffStats, StatusBar
 from comate_cli.terminal_agent.statusline.model import StatuslineConfig
 
 
@@ -74,15 +76,14 @@ def _goal_snapshot(
 
 class TestStatusBar(unittest.IsolatedAsyncioTestCase):
     @patch("comate_cli.terminal_agent.status_bar.subprocess.run")
-    async def test_constructor_resolves_git_branch_immediately(self, mock_run) -> None:
-        mock_run.return_value = SimpleNamespace(returncode=0, stdout="my-branch\n")
+    async def test_constructor_does_not_resolve_git_branch_immediately(self, mock_run) -> None:
         session = _FakeSession(utilization_percent=0.0)
 
         status_bar = StatusBar(session)
 
-        # 构造时立即解析 git branch，不再等待首次 refresh
-        self.assertEqual(status_bar._git_branch, "my-branch")
-        self.assertIn("~my-branch", status_bar.footer_status_text())
+        mock_run.assert_not_called()
+        self.assertEqual(status_bar._git_branch, "N/A")
+        self.assertIn("~N/A", status_bar.footer_status_text())
 
     @patch("comate_cli.terminal_agent.status_bar.subprocess.run")
     async def test_refresh_updates_cached_context_percent(self, mock_run) -> None:
@@ -157,7 +158,6 @@ class TestStatusBar(unittest.IsolatedAsyncioTestCase):
     @patch("comate_cli.terminal_agent.status_bar.subprocess.run")
     async def test_render_uses_cached_git_diff_stats_without_new_subprocess(self, mock_run) -> None:
         mock_run.side_effect = [
-            SimpleNamespace(returncode=0, stdout="main\n"),
             SimpleNamespace(returncode=0, stdout="main\n"),
             SimpleNamespace(
                 returncode=0,
@@ -169,7 +169,7 @@ class TestStatusBar(unittest.IsolatedAsyncioTestCase):
         status_bar.apply_config(StatuslineConfig(show_git_diff=True))
 
         await status_bar.refresh()
-        self.assertEqual(mock_run.call_count, 3)
+        self.assertEqual(mock_run.call_count, 2)
 
         mock_run.reset_mock()
         footer = _join_fragments(status_bar.footer_toolbar())
@@ -178,6 +178,77 @@ class TestStatusBar(unittest.IsolatedAsyncioTestCase):
         self.assertIn("-1", footer)
         mock_run.assert_not_called()
 
+    async def test_refresh_git_commands_do_not_block_event_loop(self) -> None:
+        session = _FakeSession(utilization_percent=10.0)
+        status_bar = StatusBar(session)
+        git_done = False
+        ticked_before_git_done = False
+
+        def slow_branch() -> str:
+            time.sleep(0.05)
+            return "main"
+
+        def slow_diff() -> GitDiffStats | None:
+            nonlocal git_done
+            time.sleep(0.05)
+            git_done = True
+            return GitDiffStats(added=3, removed=1)
+
+        ticked = asyncio.Event()
+
+        async def ticker() -> None:
+            nonlocal ticked_before_git_done
+            await asyncio.sleep(0)
+            ticked_before_git_done = not git_done
+            ticked.set()
+
+        with (
+            patch.object(StatusBar, "_resolve_git_branch", side_effect=slow_branch),
+            patch.object(StatusBar, "_resolve_git_diff_stats", side_effect=slow_diff),
+        ):
+            await asyncio.gather(status_bar.refresh(), ticker())
+
+        self.assertTrue(ticked.is_set())
+        self.assertTrue(ticked_before_git_done)
+        self.assertEqual(status_bar._git_branch, "main")
+        self.assertEqual(status_bar._git_diff_stats, GitDiffStats(added=3, removed=1))
+
+    async def test_refresh_does_not_recompute_git_diff_when_cache_is_fresh(self) -> None:
+        session = _FakeSession(utilization_percent=10.0)
+        status_bar = StatusBar(session)
+        status_bar._git_diff_stats = GitDiffStats(added=1, removed=0)
+        status_bar._git_diff_cache_time = time.monotonic()
+
+        with (
+            patch.object(StatusBar, "_resolve_git_branch", return_value="main"),
+            patch.object(StatusBar, "_resolve_git_diff_stats") as diff_mock,
+        ):
+            await status_bar.refresh()
+
+        diff_mock.assert_not_called()
+        self.assertEqual(status_bar._git_diff_stats, GitDiffStats(added=1, removed=0))
+
+    async def test_refresh_recomputes_git_diff_when_cache_is_stale(self) -> None:
+        session = _FakeSession(utilization_percent=10.0)
+        status_bar = StatusBar(session)
+        status_bar._git_diff_stats = GitDiffStats(added=1, removed=0)
+        status_bar._git_diff_cache_time = (
+            time.monotonic() - StatusBar._GIT_DIFF_CACHE_SECONDS - 1
+        )
+
+        with (
+            patch.object(StatusBar, "_resolve_git_branch", return_value="main"),
+            patch.object(
+                StatusBar,
+                "_resolve_git_diff_stats",
+                return_value=GitDiffStats(added=2, removed=1),
+            ) as diff_mock,
+        ):
+            await status_bar.refresh()
+
+        diff_mock.assert_called_once()
+        self.assertEqual(status_bar._git_diff_stats, GitDiffStats(added=2, removed=1))
+
     @patch("comate_cli.terminal_agent.status_bar.subprocess.run")
     async def test_goal_budget_item_uses_cached_snapshot(self, mock_run) -> None:
         mock_run.return_value = SimpleNamespace(returncode=0, stdout="main\n")

comate_cli-0.7.4/tests/test_tui_startup_latency.py

@@ -0,0 +1,274 @@
+from __future__ import annotations
+
+import asyncio
+import threading
+import unittest
+from contextlib import contextmanager
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any
+from unittest.mock import patch
+
+from comate_cli.terminal_agent.tui import TerminalAgentTUI
+
+
+class _FakeRenderer:
+    def __init__(self) -> None:
+        self.closed = False
+
+    def close(self) -> None:
+        self.closed = True
+
+
+class _FakeApp:
+    def __init__(self, *, wait_for: asyncio.Event | None = None) -> None:
+        self.entered = asyncio.Event()
+        self._wait_for = wait_for
+        self.invalidated = False
+
+    async def run_async(self) -> None:
+        self.entered.set()
+        if self._wait_for is not None:
+            await asyncio.wait_for(self._wait_for.wait(), timeout=0.1)
+        else:
+            await asyncio.sleep(0)
+
+    def invalidate(self) -> None:
+        self.invalidated = True
+
+
+@contextmanager
+def _noop_patch_stdout(*args: Any, **kwargs: Any):
+    del args, kwargs
+    yield
+
+
+def _make_tui(app: _FakeApp) -> TerminalAgentTUI:
+    tui = TerminalAgentTUI.__new__(TerminalAgentTUI)
+    tui._app = app
+    tui._renderer = _FakeRenderer()
+    tui._refresh_layers = lambda: None
+    tui._busy = False
+    tui._closing = False
+    tui._mcp_init_cancel_timeout_s = 0.05
+    tui._mcp_init_task = None
+    tui._plugin_init_task = None
+    tui._plugin_init_cancel_timeout_s = 0.05
+    tui._ui_tick_task = None
+    tui._event_pump_task = None
+
+    async def _fake_ui_tick() -> None:
+        await asyncio.Event().wait()
+
+    async def _fake_event_pump() -> None:
+        await asyncio.Event().wait()
+
+    tui._ui_tick = _fake_ui_tick
+    tui._consume_event_stream = _fake_event_pump
+    return tui
+
+
+class TestTUIStartupLatency(unittest.IsolatedAsyncioTestCase):
+    async def test_plugin_init_pending_does_not_block_run_async(self) -> None:
+        plugin_started = asyncio.Event()
+        plugin_cancelled = asyncio.Event()
+        app = _FakeApp(wait_for=plugin_started)
+        tui = _make_tui(app)
+
+        async def _stuck_plugin_init() -> None:
+            plugin_started.set()
+            try:
+                await asyncio.Event().wait()
+            finally:
+                plugin_cancelled.set()
+
+        tui._init_plugins = _stuck_plugin_init
+
+        with patch("comate_cli.terminal_agent.tui.patch_stdout", _noop_patch_stdout):
+            await asyncio.wait_for(tui.run(), timeout=0.2)
+
+        self.assertTrue(plugin_started.is_set())
+        self.assertTrue(app.entered.is_set())
+        self.assertTrue(plugin_cancelled.is_set())
+        self.assertIsNone(tui._plugin_init_task)
+        self.assertTrue(tui._renderer.closed)
+
+    async def test_plugin_init_exception_is_logged_and_run_async_still_runs(self) -> None:
+        app = _FakeApp()
+        tui = _make_tui(app)
+
+        async def _failing_plugin_init() -> None:
+            raise RuntimeError("plugin boom")
+
+        tui._init_plugins = _failing_plugin_init
+
+        with (
+            patch("comate_cli.terminal_agent.tui.patch_stdout", _noop_patch_stdout),
+            self.assertLogs("comate_cli.terminal_agent.tui", level="ERROR") as logs,
+        ):
+            await asyncio.wait_for(tui.run(), timeout=0.2)
+
+        self.assertTrue(app.entered.is_set())
+        self.assertIn("Plugin init failed at startup", "\n".join(logs.output))
+
+    async def test_sync_plugin_loader_runs_off_event_loop(self) -> None:
+        load_started = threading.Event()
+        release_load = threading.Event()
+        app_release = asyncio.Event()
+        app = _FakeApp(wait_for=app_release)
+        tui = _make_tui(app)
+        tui._inject_plugin_resources = lambda plugins: None
+
+        def slow_load_all(*args, **kwargs):  # noqa: ANN001, ANN202
+            del args, kwargs
+            load_started.set()
+            release_load.wait(timeout=1.0)
+            return [], []
+
+        fake_registry = SimpleNamespace(base_dir=Path("/tmp/plugin-registry"))
+
+        with (
+            patch("comate_cli.terminal_agent.tui.patch_stdout", _noop_patch_stdout),
+            patch("comate_agent_sdk.plugins.create_plugin_registry", return_value=fake_registry),
+            patch("comate_agent_sdk.plugins.PluginLoader.load_all", side_effect=slow_load_all),
+        ):
+            run_task = asyncio.create_task(tui.run())
+            self.assertTrue(await asyncio.to_thread(load_started.wait, 0.2))
+            await asyncio.wait_for(app.entered.wait(), timeout=0.1)
+            self.assertFalse(run_task.done())
+            release_load.set()
+            app_release.set()
+            await asyncio.wait_for(run_task, timeout=0.5)
+
+    async def test_plugin_loader_uses_session_cwd_as_project_path(self) -> None:
+        app_release = asyncio.Event()
+        app = _FakeApp(wait_for=app_release)
+        tui = _make_tui(app)
+        tui._session = SimpleNamespace(_cwd="/tmp/session-project")
+        tui._inject_plugin_resources = lambda plugins: None
+        seen_project_paths: list[Path] = []
+        load_called = threading.Event()
+
+        def load_all(*, registry, project_path, **kwargs):  # noqa: ANN001, ANN202
+            del registry, kwargs
+            seen_project_paths.append(Path(project_path))
+            load_called.set()
+            return [], []
+
+        fake_registry = SimpleNamespace(base_dir=Path("/tmp/plugin-registry"))
+
+        with (
+            patch("comate_cli.terminal_agent.tui.patch_stdout", _noop_patch_stdout),
+            patch("comate_agent_sdk.plugins.create_plugin_registry", return_value=fake_registry),
+            patch("comate_agent_sdk.plugins.PluginLoader.load_all", side_effect=load_all),
+        ):
+            run_task = asyncio.create_task(tui.run())
+            self.assertTrue(await asyncio.to_thread(load_called.wait, 0.2))
+            app_release.set()
+            await asyncio.wait_for(run_task, timeout=0.5)
+
+        self.assertEqual(seen_project_paths, [Path("/tmp/session-project").resolve()])
+
+    async def test_cancelled_plugin_loader_does_not_inject_after_close(self) -> None:
+        load_started = threading.Event()
+        release_load = threading.Event()
+        app_release = asyncio.Event()
+        app = _FakeApp(wait_for=app_release)
+        tui = _make_tui(app)
+        injected: list[object] = []
+        tui._inject_plugin_resources = lambda plugins: injected.extend(plugins)
+
+        loaded_plugin = SimpleNamespace(
+            namespace="slow",
+            skills=[],
+            agents=[],
+            commands=[],
+            mcp_servers={},
+        )
+
+        def slow_load_all(*args, **kwargs):  # noqa: ANN001, ANN202
+            del args, kwargs
+            load_started.set()
+            release_load.wait(timeout=1.0)
+            return [loaded_plugin], []
+
+        fake_registry = SimpleNamespace(base_dir=Path("/tmp/plugin-registry"))
+
+        with (
+            patch("comate_cli.terminal_agent.tui.patch_stdout", _noop_patch_stdout),
+            patch("comate_agent_sdk.plugins.create_plugin_registry", return_value=fake_registry),
+            patch("comate_agent_sdk.plugins.PluginLoader.load_all", side_effect=slow_load_all),
+        ):
+            run_task = asyncio.create_task(tui.run())
+            self.assertTrue(await asyncio.to_thread(load_started.wait, 0.2))
+            await asyncio.wait_for(app.entered.wait(), timeout=0.1)
+            app_release.set()
+            await asyncio.sleep(0)
+            release_load.set()
+            await asyncio.wait_for(run_task, timeout=0.5)
+
+        self.assertEqual(injected, [])
+
+    async def test_startup_status_refresh_does_not_block_run_async(self) -> None:
+        refresh_started = asyncio.Event()
+        release_refresh = asyncio.Event()
+        app_release = asyncio.Event()
+        app = _FakeApp(wait_for=app_release)
+        tui = _make_tui(app)
+        tui._init_plugins = lambda: asyncio.sleep(0)
+
+        class _StatusBar:
+            def __init__(self) -> None:
+                self.refreshed = False
+
+            async def refresh(self) -> None:
+                refresh_started.set()
+                await release_refresh.wait()
+                self.refreshed = True
+
+        status_bar = _StatusBar()
+        tui._status_bar = status_bar
+
+        with patch("comate_cli.terminal_agent.tui.patch_stdout", _noop_patch_stdout):
+            run_task = asyncio.create_task(tui.run())
+            await asyncio.wait_for(app.entered.wait(), timeout=0.1)
+            await asyncio.wait_for(refresh_started.wait(), timeout=0.1)
+            self.assertFalse(run_task.done())
+            release_refresh.set()
+            app_release.set()
+            await asyncio.wait_for(run_task, timeout=0.5)
+
+        self.assertTrue(status_bar.refreshed)
+        self.assertTrue(app.invalidated)
+
+    async def test_pending_startup_status_refresh_is_cancelled_on_shutdown(self) -> None:
+        refresh_started = asyncio.Event()
+        refresh_cancelled = asyncio.Event()
+        app_release = asyncio.Event()
+        app = _FakeApp(wait_for=app_release)
+        tui = _make_tui(app)
+        tui._init_plugins = lambda: asyncio.sleep(0)
+
+        class _StatusBar:
+            async def refresh(self) -> None:
+                refresh_started.set()
+                try:
+                    await asyncio.Event().wait()
+                finally:
+                    refresh_cancelled.set()
+
+        tui._status_bar = _StatusBar()
+
+        with patch("comate_cli.terminal_agent.tui.patch_stdout", _noop_patch_stdout):
+            run_task = asyncio.create_task(tui.run())
+            await asyncio.wait_for(app.entered.wait(), timeout=0.1)
+            await asyncio.wait_for(refresh_started.wait(), timeout=0.1)
+            app_release.set()
+            await asyncio.wait_for(run_task, timeout=0.5)
+
+        self.assertTrue(refresh_cancelled.is_set())
+        self.assertIsNone(tui._startup_status_refresh_task)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

{comate_cli-0.7.3 → comate_cli-0.7.4}/uv.lock

@@ -389,7 +389,7 @@ wheels = [
 
 [[package]]
 name = "comate-agent-sdk"
-version = "0.8.3"
+version = "0.8.4"
 source = { editable = "../../" }
 dependencies = [
     { name = "aiohttp" },
@@ -463,7 +463,7 @@ dev = [
 
 [[package]]
 name = "comate-cli"
-version = "0.7.2"
+version = "0.7.3"
 source = { editable = "." }
 dependencies = [
     { name = "charset-normalizer" },

comate_cli-0.7.3/tests/test_tui_startup_latency.py

@@ -1,104 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import unittest
-from contextlib import contextmanager
-from typing import Any
-from unittest.mock import patch
-
-from comate_cli.terminal_agent.tui import TerminalAgentTUI
-
-
-class _FakeRenderer:
-    def __init__(self) -> None:
-        self.closed = False
-
-    def close(self) -> None:
-        self.closed = True
-
-
-class _FakeApp:
-    def __init__(self, *, wait_for: asyncio.Event | None = None) -> None:
-        self.entered = asyncio.Event()
-        self._wait_for = wait_for
-
-    async def run_async(self) -> None:
-        self.entered.set()
-        if self._wait_for is not None:
-            await asyncio.wait_for(self._wait_for.wait(), timeout=0.1)
-        else:
-            await asyncio.sleep(0)
-
-
-@contextmanager
-def _noop_patch_stdout(*args: Any, **kwargs: Any):
-    del args, kwargs
-    yield
-
-
-def _make_tui(app: _FakeApp) -> TerminalAgentTUI:
-    tui = TerminalAgentTUI.__new__(TerminalAgentTUI)
-    tui._app = app
-    tui._renderer = _FakeRenderer()
-    tui._refresh_layers = lambda: None
-    tui._busy = False
-    tui._closing = False
-    tui._mcp_init_cancel_timeout_s = 0.05
-    tui._mcp_init_task = None
-    tui._plugin_init_task = None
-    tui._plugin_init_cancel_timeout_s = 0.05
-    tui._ui_tick_task = None
-
-    async def _fake_ui_tick() -> None:
-        await asyncio.Event().wait()
-
-    tui._ui_tick = _fake_ui_tick
-    return tui
-
-
-class TestTUIStartupLatency(unittest.IsolatedAsyncioTestCase):
-    async def test_plugin_init_pending_does_not_block_run_async(self) -> None:
-        plugin_started = asyncio.Event()
-        plugin_cancelled = asyncio.Event()
-        app = _FakeApp(wait_for=plugin_started)
-        tui = _make_tui(app)
-
-        async def _stuck_plugin_init() -> None:
-            plugin_started.set()
-            try:
-                await asyncio.Event().wait()
-            finally:
-                plugin_cancelled.set()
-
-        tui._init_plugins = _stuck_plugin_init
-
-        with patch("comate_cli.terminal_agent.tui.patch_stdout", _noop_patch_stdout):
-            await asyncio.wait_for(tui.run(), timeout=0.2)
-
-        self.assertTrue(plugin_started.is_set())
-        self.assertTrue(app.entered.is_set())
-        self.assertTrue(plugin_cancelled.is_set())
-        self.assertIsNone(tui._plugin_init_task)
-        self.assertTrue(tui._renderer.closed)
-
-    async def test_plugin_init_exception_is_logged_and_run_async_still_runs(self) -> None:
-        app = _FakeApp()
-        tui = _make_tui(app)
-
-        async def _failing_plugin_init() -> None:
-            raise RuntimeError("plugin boom")
-
-        tui._init_plugins = _failing_plugin_init
-
-        with (
-            patch("comate_cli.terminal_agent.tui.patch_stdout", _noop_patch_stdout),
-            self.assertLogs("comate_cli.terminal_agent.tui", level="ERROR") as logs,
-        ):
-            await asyncio.wait_for(tui.run(), timeout=0.2)
-
-        self.assertTrue(app.entered.is_set())
-        self.assertIn("Plugin init failed at startup", "\n".join(logs.output))
-
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)