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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.7.4
+Version: 0.7.5
 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
@@ -13,7 +13,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.11
+Requires-Python: <3.14,>=3.11
 Requires-Dist: charset-normalizer==3.4.7
 Requires-Dist: comate-agent-sdk<0.9.0,>=0.8.0a1
 Requires-Dist: concurrent-log-handler>=0.9.25

{comate_cli-0.7.4 → comate_cli-0.7.5}/comate_cli/terminal_agent/app.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 import logging
 import os
-import random
+import random  # noqa: F401 - tests patch this module-level import for deterministic startup tips.
 import signal
 import sys
 import threading
@@ -49,8 +49,14 @@ def _resolve_cli_project_root() -> Path:
     return Path.cwd().expanduser().resolve()
 
 
-async def _check_update() -> UpdateInfo | None:
-    return await check_update(log=logger)
+async def _check_update(*, profiler: StartupProfiler | None = None) -> UpdateInfo | None:
+    if profiler is not None:
+        profiler.mark("impl.start")
+    try:
+        return await check_update(log=logger, profiler=profiler)
+    finally:
+        if profiler is not None:
+            profiler.mark("impl.done")
 
 
 async def _handle_update_on_launch(info: UpdateInfo) -> bool:
@@ -109,7 +115,7 @@ def _schedule_update_check_on_launch(
     async def _run() -> None:
         try:
             profiler.mark("update_check.start")
-            update_info = await _check_update()
+            update_info = await _check_update(profiler=profiler.child("update_check"))
             profiler.mark("update_check.done")
             if update_info is not None:
                 await _handle_background_update_on_launch(
@@ -228,35 +234,64 @@ async def add(a: int, b: int) -> int:
     return a + b
 
 
-def _build_agent(*, project_root: Path | None = None) -> Agent:
+def _build_agent(
+    *,
+    project_root: Path | None = None,
+    profiler: StartupProfiler | None = None,
+) -> Agent:
     from comate_agent_sdk.agent.compaction import CompactionConfig
     from comate_cli.terminal_agent.config import store
 
     resolved_project_root = project_root or _resolve_cli_project_root()
+    if profiler is not None:
+        profiler.mark("agent.config.load.start")
     snapshot = store.load()
-
-    return Agent(
-        config=AgentConfig(
-            role="software_engineering",
-            cwd=resolved_project_root,
-            env_options=EnvOptions(system_env=True, git_env=True),
-            use_streaming_task=True,
-            include_cost=bool(getattr(snapshot, "token_cost_enabled", False)),
-            memory_background_enabled=snapshot.memory_background_enabled,
-            memory_dreaming_enabled=snapshot.memory_dreaming_enabled,
-            compaction=CompactionConfig(
-                threshold_ratio=snapshot.compaction_threshold_ratio,
-            ),
-        )
+    if profiler is not None:
+        profiler.mark("agent.config.load.done")
+
+    agent_config = AgentConfig(
+        role="software_engineering",
+        cwd=resolved_project_root,
+        env_options=EnvOptions(system_env=True, git_env=True),
+        use_streaming_task=True,
+        include_cost=bool(getattr(snapshot, "token_cost_enabled", False)),
+        memory_background_enabled=snapshot.memory_background_enabled,
+        memory_dreaming_enabled=snapshot.memory_dreaming_enabled,
+        compaction=CompactionConfig(
+            threshold_ratio=snapshot.compaction_threshold_ratio,
+        ),
     )
+    if profiler is not None:
+        profiler.mark("agent.construct.start")
+    try:
+        return Agent(config=agent_config)
+    finally:
+        if profiler is not None:
+            profiler.mark("agent.construct.done")
 
 
 def _resolve_session(
-    agent: Agent, resume_session_id: str | None, *, cwd: Path | None = None
+    agent: Agent,
+    resume_session_id: str | None,
+    *,
+    cwd: Path | None = None,
+    profiler: StartupProfiler | None = None,
 ) -> tuple[ChatSession, str]:
     if resume_session_id:
-        return ChatSession.resume(agent, session_id=resume_session_id, cwd=cwd), "resume"
-    return ChatSession(agent, cwd=cwd), "new"
+        if profiler is not None:
+            profiler.mark("session.resume.construct.start")
+        try:
+            return ChatSession.resume(agent, session_id=resume_session_id, cwd=cwd), "resume"
+        finally:
+            if profiler is not None:
+                profiler.mark("session.resume.construct.done")
+    if profiler is not None:
+        profiler.mark("session.new.construct.start")
+    try:
+        return ChatSession(agent, cwd=cwd), "new"
+    finally:
+        if profiler is not None:
+            profiler.mark("session.new.construct.done")
 
 
 def _format_exit_usage_line(usage: object) -> str:
@@ -287,23 +322,47 @@ def _format_resume_hint(session_id: str | None) -> str | None:
     )
 
 
-async def _preload_mcp_in_tui(session: ChatSession) -> None:
+async def _preload_mcp_in_tui(
+    session: ChatSession,
+    *,
+    profiler: StartupProfiler | None = None,
+) -> None:
     """在 TUI 内异步加载 MCP，初始化阶段不输出 scrollback 文案。"""
+    if profiler is not None:
+        profiler.mark("preload.start")
     runtime = session.runtime
     if not bool(runtime.config.mcp_enabled):
+        if profiler is not None:
+            profiler.mark("preload.skip_disabled")
         return
 
     try:
+        if profiler is not None:
+            profiler.mark("start_preload.start")
         preload_task = runtime.start_mcp_preload()
+        if profiler is not None:
+            profiler.mark("start_preload.done")
         if preload_task is None:
+            if profiler is not None:
+                profiler.mark("preload.no_task")
             return
+        if profiler is not None:
+            profiler.mark("await_preload.start")
         await preload_task
+        if profiler is not None:
+            profiler.mark("await_preload.done")
     except Exception as e:
         logger.debug(f"MCP init failed: {e}", exc_info=True)
+        if profiler is not None:
+            profiler.mark("preload.failed")
         return
 
+    if profiler is not None:
+        profiler.mark("inspect_manager.start")
     mgr = runtime._mcp_manager
     if mgr is None:
+        if profiler is not None:
+            profiler.mark("inspect_manager.no_manager")
         return
 
     for alias, reason in mgr.failed_servers:
@@ -314,6 +373,8 @@ async def _preload_mcp_in_tui(session: ChatSession) -> None:
         count = len(loaded)
         aliases = sorted({i.server_alias for i in loaded})
         logger.info(f"MCP Server loaded: {', '.join(aliases)} ({count} tools)")
+    if profiler is not None:
+        profiler.mark("inspect_manager.done")
 
 
 async def _run_print_mode(
@@ -404,7 +465,7 @@ async def run(
                 return
 
     profiler.mark("agent.build.start")
-    agent = _build_agent(project_root=project_root)
+    agent = _build_agent(project_root=project_root, profiler=profiler)
     profiler.mark("agent.build.done")
 
     if rpc_stdio and resume_select and not resume_session_id:
@@ -412,7 +473,12 @@ async def run(
         return
 
     if rpc_stdio:
-        session, _mode = _resolve_session(agent, resume_session_id, cwd=project_root)
+        session, _mode = _resolve_session(
+            agent,
+            resume_session_id,
+            cwd=project_root,
+            profiler=profiler,
+        )
         bridge = StdioRPCBridge(session)
         try:
             await bridge.run()
@@ -441,7 +507,12 @@ async def run(
     profiler.mark("logging.setup.done")
 
     profiler.mark("session.resolve.start")
-    session, mode = _resolve_session(agent, resume_session_id, cwd=project_root)
+    session, mode = _resolve_session(
+        agent,
+        resume_session_id,
+        cwd=project_root,
+        profiler=profiler,
+    )
     profiler.mark("session.resolve.done")
     # setup_tui_logging 在 _resolve_session 前安装，用于捕获 session 初始化期 warning/error。
     # 这些日志没有交互 anchor，需在恢复历史或首次用户输入前落为 standalone log。
@@ -469,7 +540,7 @@ async def run(
     )
 
     async def _mcp_loader() -> None:
-        await _preload_mcp_in_tui(session)
+        await _preload_mcp_in_tui(session, profiler=profiler.child("mcp"))
         mgr = session.runtime._mcp_manager
         if mgr and mgr.failed_servers:
             aliases = [alias for alias, _ in mgr.failed_servers]

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

@@ -206,6 +206,25 @@ class StatusBar:
         turn = getattr(agent, "_turn_number", None)
         return f"#{turn}" if turn is not None else "-"
 
+    def _context_percent_refresh_started(self) -> bool:
+        for owner in (
+            self._session,
+            getattr(self._session, "_agent", None),
+            getattr(getattr(self._session, "_agent", None), "_context", None),
+        ):
+            if owner is None:
+                continue
+            turn = getattr(owner, "_turn_number", None)
+            if turn is None:
+                turn = getattr(owner, "turn_number", None)
+            if turn is None:
+                continue
+            try:
+                return int(turn) > 0
+            except (TypeError, ValueError):
+                continue
+        return True
+
     def _resolve_project_cwd(self) -> str:
         cwd = getattr(self._session, "_cwd", None)
         if cwd is None:
@@ -260,21 +279,22 @@ class StatusBar:
         return " ".join(parts) if parts else "-"
 
     async def refresh(self) -> None:
-        try:
-            ctx_info = await self._session.get_context_info()
-            utilization = float(getattr(ctx_info, "utilization_percent", 0.0))
-        except Exception:
-            return
+        if self._context_percent_refresh_started():
+            try:
+                ctx_info = await self._session.get_context_info()
+                utilization = float(getattr(ctx_info, "utilization_percent", 0.0))
+            except Exception:
+                return
+
+            normalized = max(0.0, min(utilization, 100.0))
+            self._context_used_pct = normalized
+            self._context_left_pct = max(0.0, 100.0 - normalized)
 
         try:
             self._mode = str(self._session.get_mode()).strip().lower() or "act"
         except Exception:
             pass
 
-        normalized = max(0.0, min(utilization, 100.0))
-        self._context_used_pct = normalized
-        self._context_left_pct = max(0.0, 100.0 - normalized)
-
         branch_task = asyncio.to_thread(self._resolve_git_branch)
         now = time.monotonic()
         diff_is_stale = (
@@ -338,7 +358,7 @@ class StatusBar:
         return max(24, min(width - 6, 72))
 
     def context_left_text(self) -> str:
-        return f"{self._context_left_pct:.0f}%  left"
+        return f"Context {self._context_left_pct:.0f}% left"
 
     def _status_text_for_width(self, width: int) -> str:
         mode_text = f"[{self._mode}]"

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

@@ -1770,7 +1770,7 @@ class TerminalAgentTUI(
             try:
                 if profiler is not None:
                     profiler.mark("plugins.init.start")
-                await self._init_plugins()
+                await self._init_plugins(profiler=profiler.child("plugins") if profiler is not None else None)
                 if profiler is not None:
                     profiler.mark("plugins.init.done")
             except asyncio.CancelledError:
@@ -1784,6 +1784,8 @@ class TerminalAgentTUI(
             finally:
                 self._refresh_layers()
 
+        if profiler is not None:
+            profiler.mark("plugins.task.create")
         self._plugin_init_task = asyncio.create_task(
             _do_plugin_init(),
             name="terminal-plugin-init",
@@ -1803,11 +1805,15 @@ class TerminalAgentTUI(
                 finally:
                     self._refresh_layers()
 
+            if profiler is not None:
+                profiler.mark("mcp.task.create")
             self._mcp_init_task = asyncio.create_task(
                 _do_init(),
                 name="terminal-mcp-init",
             )
 
+        if profiler is not None:
+            profiler.mark("ui_tick.task.create")
         self._ui_tick_task = asyncio.create_task(
             self._ui_tick(),
             name="terminal-ui-tick",
@@ -1826,11 +1832,15 @@ class TerminalAgentTUI(
                         self._refresh_layers()
                         self._invalidate()
 
+            if profiler is not None:
+                profiler.mark("status_bar.refresh.task.create")
             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:
+            if profiler is not None:
+                profiler.mark("event_pump.task.create")
             self._event_pump_task = asyncio.create_task(
                 self._consume_event_stream(),
                 name="terminal-session-event-pump",
@@ -1894,12 +1904,16 @@ class TerminalAgentTUI(
             return Path(session_cwd).expanduser().resolve()
         return Path.cwd().expanduser().resolve()
 
-    async def _init_plugins(self) -> None:
+    async def _init_plugins(self, *, profiler: Any | None = None) -> None:
         """Load and inject plugin resources at startup."""
+        if profiler is not None:
+            profiler.mark("load_thread.start")
         loaded_plugins, plugin_errors = await asyncio.to_thread(
             _load_plugins_blocking,
             self._plugin_project_path(),
         )
+        if profiler is not None:
+            profiler.mark("load_thread.done")
         if self._closing:
             logger.debug("Plugin load completed after TUI close; discarding results")
             return
@@ -1907,7 +1921,11 @@ class TerminalAgentTUI(
         self._loaded_plugins = loaded_plugins
         self._plugin_errors = plugin_errors
         self._plugin_command_names: set[str] = set()
+        if profiler is not None:
+            profiler.mark("inject.start")
         self._inject_plugin_resources(self._loaded_plugins)
+        if profiler is not None:
+            profiler.mark("inject.done")
         logger.info(
             "Loaded %d plugins (%d errors)",
             len(self._loaded_plugins),

{comate_cli-0.7.4 → comate_cli-0.7.5}/comate_cli/terminal_agent/update_check.py

@@ -70,33 +70,53 @@ async def check_update(
     package: str = PACKAGE_NAME,
     release_notes_url: str = RELEASE_NOTES_URL,
     log: logging.Logger | None = None,
+    profiler: Any | None = None,
 ) -> UpdateInfo | None:
     """异步检查 comate-cli 是否有新版本，返回结构化版本信息或 None。"""
     active_logger = log or logger
     try:
+        if profiler is not None:
+            profiler.mark("current_version.start")
         current = importlib.metadata.version(package)
     except importlib.metadata.PackageNotFoundError:
         return None
+    finally:
+        if profiler is not None:
+            profiler.mark("current_version.done")
 
+    if profiler is not None:
+        profiler.mark("locale.start")
     if _is_chinese_locale():
         url = f"https://mirrors.tuna.tsinghua.edu.cn/pypi/{package}/json"
         source_label = "tuna"
     else:
         url = f"https://pypi.org/pypi/{package}/json"
         source_label = "pypi"
+    if profiler is not None:
+        profiler.mark("locale.done")
 
     try:
+        if profiler is not None:
+            profiler.mark("httpx_import.start")
         import httpx
+        if profiler is not None:
+            profiler.mark("httpx_import.done")
 
         async with httpx.AsyncClient(timeout=3.0) as client:
+            if profiler is not None:
+                profiler.mark("http_get.start")
             resp = await client.get(url)
             resp.raise_for_status()
             latest = resp.json()["info"]["version"]
+            if profiler is not None:
+                profiler.mark("http_get.done")
     except Exception:
         active_logger.debug(f"update check failed (source={source_label})", exc_info=True)
         return None
 
     try:
+        if profiler is not None:
+            profiler.mark("version_compare.start")
         from packaging.version import Version
 
         if Version(latest) > Version(current):
@@ -113,6 +133,9 @@ async def check_update(
             latest,
             exc_info=True,
         )
+    finally:
+        if profiler is not None:
+            profiler.mark("version_compare.done")
     return None
 
 

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

@@ -4,10 +4,10 @@ build-backend = "hatchling.build"
 
 [project]
 name = "comate-cli"
-version = "0.7.4"
+version = "0.7.5"
 description = "Comate terminal CLI built on comate-agent-sdk"
 readme = "README.md"
-requires-python = ">=3.11"
+requires-python = ">=3.11,<3.14"
 authors = [
     { name = "Andy", email = "andy.dev@aliyun.com" }
 ]

{comate_cli-0.7.4 → comate_cli-0.7.5}/tests/test_app_startup_latency.py

@@ -64,7 +64,11 @@ class TestAppStartupLatency(unittest.IsolatedAsyncioTestCase):
                 "run_preflight_if_needed",
                 AsyncMock(return_value=PreflightResult(status="configured")),
             ),
-            patch.object(app_module, "_build_agent", side_effect=lambda *, project_root: order.append("build_agent") or object()),
+            patch.object(
+                app_module,
+                "_build_agent",
+                side_effect=lambda *, project_root, profiler=None: order.append("build_agent") or object(),
+            ),
             patch.object(app_module, "print_logo", side_effect=lambda *args, **kwargs: order.append("print_logo")),
             patch.object(app_module, "_check_update", AsyncMock(return_value=None)),
             patch.object(app_module, "EventRenderer", return_value=MagicMock()),
@@ -149,7 +153,8 @@ class TestAppStartupLatency(unittest.IsolatedAsyncioTestCase):
                 await asyncio.wait_for(update_started.wait(), timeout=0.1)
                 self.run_called.set()
 
-        async def _never_finishes() -> UpdateInfo | None:
+        async def _never_finishes(*, profiler=None) -> UpdateInfo | None:
+            del profiler
             update_started.set()
             try:
                 await asyncio.Event().wait()
@@ -190,7 +195,8 @@ class TestAppStartupLatency(unittest.IsolatedAsyncioTestCase):
                 super().__init__(session, status_bar, renderer)
                 created_tuis.append(self)
 
-        async def _raises() -> UpdateInfo | None:
+        async def _raises(*, profiler=None) -> UpdateInfo | None:
+            del profiler
             raise RuntimeError("network down")
 
         with (

{comate_cli-0.7.4 → comate_cli-0.7.5}/tests/test_completion_status_panel.py

@@ -34,7 +34,7 @@ class _FakeStatusBar:
         return "act"
 
     def info_status_text(self) -> str:
-        return "model | ~main / 100%  left"
+        return "model | ~main / Context 100% left"
 
     def info_status_fragments(self) -> list[tuple[str, str]]:
         return [("class:status", self.info_status_text())]

{comate_cli-0.7.4 → comate_cli-0.7.5}/tests/test_startup_profile.py

@@ -15,11 +15,23 @@ from comate_cli.terminal_agent.tui import TerminalAgentTUI
 
 
 class _RecordingProfiler:
-    def __init__(self) -> None:
-        self.phases: list[str] = []
+    def __init__(self, prefix: str = "", phases: list[str] | None = None) -> None:
+        self._prefix = prefix.strip(".")
+        self.phases = phases if phases is not None else []
 
     def mark(self, phase: str) -> None:
-        self.phases.append(phase)
+        normalized = phase.strip(".")
+        if self._prefix:
+            normalized = f"{self._prefix}.{normalized}"
+        self.phases.append(normalized)
+
+    def child(self, prefix: str) -> "_RecordingProfiler":
+        normalized = prefix.strip(".")
+        if self._prefix and normalized:
+            normalized = f"{self._prefix}.{normalized}"
+        elif self._prefix:
+            normalized = self._prefix
+        return _RecordingProfiler(prefix=normalized, phases=self.phases)
 
 
 class _FakeRenderer:
@@ -129,7 +141,7 @@ class TestStartupProfilerTUI(unittest.IsolatedAsyncioTestCase):
         tui._mcp_init_cancel_timeout_s = 0.05
         tui._mcp_init_task = None
         tui._ui_tick_task = None
-        tui._init_plugins = lambda: asyncio.sleep(0)
+        tui._init_plugins = lambda *, profiler=None: asyncio.sleep(0)
 
         async def _fake_ui_tick() -> None:
             await asyncio.Event().wait()
@@ -144,8 +156,116 @@ class TestStartupProfilerTUI(unittest.IsolatedAsyncioTestCase):
         self.assertIn("tui.run_async.enter", profiler.phases)
         self.assertIn("tui.run_async.done", profiler.phases)
 
+    async def test_tui_run_marks_background_task_creation_boundaries(self) -> None:
+        tui = TerminalAgentTUI.__new__(TerminalAgentTUI)
+        tui._app = _FakeApp()
+        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._ui_tick_task = None
+        tui._init_plugins = lambda *, profiler=None: asyncio.sleep(0)
+        tui._status_bar = SimpleNamespace(refresh=AsyncMock())
+        tui._session = object()
+        tui._consume_event_stream = lambda: asyncio.sleep(0)
+
+        async def _fake_ui_tick() -> None:
+            await asyncio.Event().wait()
+
+        async def _fake_mcp_init() -> None:
+            return None
+
+        tui._ui_tick = _fake_ui_tick
+        profiler = _RecordingProfiler()
+
+        with patch("comate_cli.terminal_agent.tui.patch_stdout", _noop_patch_stdout):
+            await tui.run(mcp_init=_fake_mcp_init, profiler=profiler)
+
+        self.assertIn("plugins.task.create", profiler.phases)
+        self.assertIn("mcp.task.create", profiler.phases)
+        self.assertIn("ui_tick.task.create", profiler.phases)
+        self.assertIn("status_bar.refresh.task.create", profiler.phases)
+        self.assertIn("event_pump.task.create", profiler.phases)
+
+    async def test_init_plugins_marks_load_and_inject_boundaries(self) -> None:
+        tui = TerminalAgentTUI.__new__(TerminalAgentTUI)
+        tui._closing = False
+        tui._loaded_plugins = []
+        tui._plugin_errors = []
+        tui._plugin_project_path = lambda: Path("/tmp/project")
+        tui._inject_plugin_resources = lambda plugins: None
+        profiler = _RecordingProfiler()
+
+        with patch(
+            "comate_cli.terminal_agent.tui._load_plugins_blocking",
+            return_value=([], []),
+        ):
+            await tui._init_plugins(profiler=profiler.child("plugins"))
+
+        self.assertIn("plugins.load_thread.start", profiler.phases)
+        self.assertIn("plugins.load_thread.done", profiler.phases)
+        self.assertIn("plugins.inject.start", profiler.phases)
+        self.assertIn("plugins.inject.done", profiler.phases)
+
 
 class TestStartupProfilerApp(unittest.IsolatedAsyncioTestCase):
+    async def test_build_agent_marks_config_and_construct_boundaries(self) -> None:
+        profiler = _RecordingProfiler()
+
+        class _FakeAgent:
+            def __init__(self, *, config) -> None:
+                self.config = config
+
+        with (
+            patch.object(app_module, "_resolve_cli_project_root", return_value=Path("/tmp/project")),
+            patch("comate_cli.terminal_agent.config.store.load") as load_config,
+            patch.object(app_module, "Agent", _FakeAgent),
+        ):
+            load_config.return_value = SimpleNamespace(
+                token_cost_enabled=False,
+                memory_background_enabled=True,
+                memory_dreaming_enabled=True,
+                compaction_threshold_ratio=0.9,
+            )
+            app_module._build_agent(project_root=Path("/tmp/project"), profiler=profiler)
+
+        self.assertIn("agent.config.load.start", profiler.phases)
+        self.assertIn("agent.config.load.done", profiler.phases)
+        self.assertIn("agent.construct.start", profiler.phases)
+        self.assertIn("agent.construct.done", profiler.phases)
+
+    async def test_background_update_check_marks_internal_boundaries(self) -> None:
+        profiler = _RecordingProfiler()
+
+        with patch.object(app_module, "check_update", AsyncMock(return_value=None)):
+            await app_module._check_update(profiler=profiler.child("update_check"))
+
+        self.assertIn("update_check.impl.start", profiler.phases)
+        self.assertIn("update_check.impl.done", profiler.phases)
+
+    async def test_mcp_preload_marks_start_task_and_await_boundaries(self) -> None:
+        preload_task = asyncio.create_task(asyncio.sleep(0))
+        manager = SimpleNamespace(failed_servers=[], tool_infos=[])
+        runtime = SimpleNamespace(
+            config=SimpleNamespace(mcp_enabled=True),
+            start_mcp_preload=MagicMock(return_value=preload_task),
+            _mcp_manager=manager,
+        )
+        session = SimpleNamespace(runtime=runtime)
+        profiler = _RecordingProfiler()
+
+        await app_module._preload_mcp_in_tui(session, profiler=profiler.child("mcp"))  # type: ignore[arg-type]
+
+        self.assertIn("mcp.preload.start", profiler.phases)
+        self.assertIn("mcp.start_preload.start", profiler.phases)
+        self.assertIn("mcp.start_preload.done", profiler.phases)
+        self.assertIn("mcp.await_preload.start", profiler.phases)
+        self.assertIn("mcp.await_preload.done", profiler.phases)
+        self.assertIn("mcp.inspect_manager.start", profiler.phases)
+        self.assertIn("mcp.inspect_manager.done", profiler.phases)
+
     async def test_app_run_emits_startup_phase_logs_when_enabled(self) -> None:
         fake_session = MagicMock()
         fake_session.session_id = "session-1"