comate-cli 0.5.4__tar.gz → 0.5.6__tar.gz

{comate_cli-0.5.4 → comate_cli-0.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.5.4
+Version: 0.5.6
 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.5.4 → comate_cli-0.5.6}/comate_cli/terminal_agent/event_renderer.py

@@ -279,12 +279,13 @@ class EventRenderer:
         self._show_thinking_cb: Callable[[], bool] = lambda: True
         self._turn_received_text_delta: bool = False
         self._turn_received_thinking_delta: bool = False
+        self._text_delta_started: bool = False
         # ━━━━━ spec §4.1 新管道状态字段（Phase 1.2 引入，Phase 4-6 接入） ━━━━━
         # Pipeline A: text line-commit
         self._text_pending: str = ""
         self._held_pipe_line: str | None = None
         self._container: ContainerState | None = None
-        # Pipeline B: thinking batch
+        # Pipeline B: thinking line-commit + tail
         self._thinking_batch: str = ""
         # Pipeline C: loading 行 aux
         self._loading_aux_text: str = ""
@@ -367,7 +368,7 @@ class EventRenderer:
         self._loading_aux_text = ""
 
     def _flush_thinking_batch(self) -> None:
-        """spec §6.5：thinking batch 整段 → HistoryEntry（受 _show_thinking_cb 过滤）。
+        """spec §6.5：thinking 残段 → HistoryEntry（受 _show_thinking_cb 过滤）。
         即使 hidden 也清空 batch 避免持续累积。"""
         text = self._thinking_batch
         self._thinking_batch = ""
@@ -379,6 +380,22 @@ class EventRenderer:
             HistoryEntry(entry_type="thinking", text=text)
         )
 
+    def _consume_thinking_delta(self, delta: str) -> None:
+        """spec §6.1：thinking delta 主入口。
+
+        与 text delta 对称：按完整行即时 commit 到 scrollback，未换行尾巴留在
+        _thinking_batch，等待 text/tool/turn 边界通过 _flush_thinking_batch 落盘。
+        """
+        if not delta:
+            return
+        self._thinking_batch += delta
+        while "\n" in self._thinking_batch:
+            line, self._thinking_batch = self._thinking_batch.split("\n", 1)
+            if self._show_thinking_cb():
+                self._append_history_entry(
+                    HistoryEntry(entry_type="thinking", text=line + "\n")
+                )
+
     # ── 行级路由（spec §6.2，Task 4.1-4.4 渐进扩展）──
 
     def _handle_complete_line(self, line: str) -> None:
@@ -457,7 +474,7 @@ class EventRenderer:
 
         把 delta 累到 _text_pending，按 \\n 切完整行送 _handle_complete_line。
 
-        关键顺序保证：text 进入前先 flush 待 thinking batch —— 保证
+        关键顺序保证：text 进入前先 flush 待 thinking 残段 —— 保证
         scrollback 看到 "thinking → text" 而非 "text → thinking" 错序。
         """
         if not delta:
@@ -467,6 +484,9 @@ class EventRenderer:
         self._text_pending += delta
         while "\n" in self._text_pending:
             line, self._text_pending = self._text_pending.split("\n", 1)
+            if line == "" and not self._text_delta_started:
+                continue
+            self._text_delta_started = True
             self._handle_complete_line(line)
 
     # ── turn 边界（spec §6.4）──
@@ -509,6 +529,7 @@ class EventRenderer:
         self._container = None
         self._thinking_batch = ""
         self._loading_aux_text = ""
+        self._text_delta_started = False
 
     def _should_drop_duplicate_system_message(
         self,
@@ -541,6 +562,7 @@ class EventRenderer:
         self._pending_tool_starts.clear()
         self._turn_received_text_delta = False
         self._turn_received_thinking_delta = False
+        self._text_delta_started = False
         # spec §6.4：清空新 5 字段（每 turn 起点保证状态干净）
         self._text_pending = ""
         self._held_pipe_line = None
@@ -630,6 +652,7 @@ class EventRenderer:
         self._pending_tool_starts.clear()
         self._turn_received_text_delta = False
         self._turn_received_thinking_delta = False
+        self._text_delta_started = False
         # spec §6.4：清空 5 个新字段（与 start_turn 同语义）
         self._text_pending = ""
         self._held_pipe_line = None
@@ -1444,10 +1467,9 @@ class EventRenderer:
                     self._turn_received_text_delta = True
             case ThinkingDeltaEvent(delta=delta, message_id=_):
                 if delta:
-                    # spec §6.1：thinking delta → batch 累加，段结束（StopEvent /
-                    # text delta 来时）才一次性 commit
-                    self._thinking_batch += delta
+                    # spec §6.1：thinking delta → 按 \n 切完整行入队，残段留 batch
                     self._turn_received_thinking_delta = True
+                    self._consume_thinking_delta(delta)
             case ToolCallStartEvent(tool_call_id=tool_call_id, tool=tool_name):
                 # tool 调用前先把 _text_pending / _thinking_batch 落到 scrollback，
                 # 保证说明文字出现在 tool UI 之前（无 \n 结尾的模型也适用）。
@@ -1625,7 +1647,7 @@ class EventRenderer:
                     return (True, None)
                 if reason == "waiting_for_plan_approval":
                     return (False, None)
-                if reason == "interrupted":
+                if reason == "interrupted" and "error" not in event.metadata:
                     self._append_history_entry(
                         HistoryEntry(entry_type="system", text="Current task interrupted.", severity="warning")
                     )

{comate_cli-0.5.4 → comate_cli-0.5.6}/comate_cli/terminal_agent/history_printer.py

@@ -103,6 +103,7 @@ def render_history_group(
         in_run_continuation = is_assistant and prev_was_assistant
         next_entry = entries[idx + 1] if idx + 1 < len(entries) else None
         next_is_assistant = next_entry is not None and next_entry.entry_type == "assistant"
+        next_is_thinking = next_entry is not None and next_entry.entry_type == "thinking"
 
         # 跳过位于两个块标记 entry 之间的空 assistant entry（loose list 视觉对齐）
         if is_assistant and _is_blank_assistant(entry):
@@ -127,7 +128,13 @@ def render_history_group(
                 line_text.append("  ", style="dim")
                 line_text.append(line, style="dim")
             renderables.append(line_text)
-            renderables.append(Text(""))
+            is_batch_tail = next_entry is None
+            suppress_trailing_gap = (
+                is_batch_tail
+                and assume_run_continues_at_tail
+            )
+            if not next_is_thinking and not suppress_trailing_gap:
+                renderables.append(Text(""))
             prev_was_assistant = False
             continue
 

{comate_cli-0.5.4 → comate_cli-0.5.6}/comate_cli/terminal_agent/rpc_stdio.py

@@ -228,7 +228,7 @@ class StdioRPCBridge:
         self._active_prompt_result = result_future
 
         try:
-            await self._session.send(user_input)
+            _ = await self._session.send(user_input)
         except Exception as exc:
             self._clear_active_prompt(result_future)
             await self._send(

{comate_cli-0.5.4 → comate_cli-0.5.6}/comate_cli/terminal_agent/selection_menu.py

@@ -288,14 +288,13 @@ class SelectionMenuUI:
             desc_style = "class:selection.description.selected" if is_selected else "class:selection.description"
 
             if self._state.layout_mode == "inline":
-                fragments.append(
-                    (
-                        line_style,
-                        self._inline_option_line(
-                            option=option,
-                            cursor=cursor,
-                            marker=marker,
-                        ),
+                fragments.extend(
+                    self._inline_option_fragments(
+                        option=option,
+                        cursor=cursor,
+                        marker=marker,
+                        line_style=line_style,
+                        desc_style=desc_style,
                     )
                 )
                 fragments.append(("", "\n"))
@@ -331,13 +330,15 @@ class SelectionMenuUI:
         )
         return fragments
 
-    def _inline_option_line(
+    def _inline_option_fragments(
         self,
         *,
         option: SelectionOption,
         cursor: str,
         marker: str,
-    ) -> str:
+        line_style: str,
+        desc_style: str,
+    ) -> list[tuple[str, str]]:
         total_width = max(20, int(self._state.inline_total_width or 100))
         prefix = f"  {cursor} {marker} "
         prefix_width = get_cwidth(prefix)
@@ -357,13 +358,16 @@ class SelectionMenuUI:
         name_padding = " " * max(0, name_width - get_cwidth(name_text))
 
         if desc_width <= 0:
-            return fit_single_line(f"{prefix}{name_text}", total_width)
+            return [(line_style, fit_single_line(f"{prefix}{name_text}", total_width))]
 
         description = option.description.strip()
         desc_text = fit_single_line(description, desc_width) if description else ""
         if desc_text:
-            return f"{prefix}{name_text}{name_padding}{' ' * gap_width}{desc_text}"
-        return f"{prefix}{name_text}{name_padding}"
+            return [
+                (line_style, f"{prefix}{name_text}{name_padding}"),
+                (desc_style, f"{' ' * gap_width}{desc_text}"),
+            ]
+        return [(line_style, f"{prefix}{name_text}{name_padding}")]
 
     def _normalized_page_size(self) -> int:
         options_count = len(self._state.options)

{comate_cli-0.5.4 → comate_cli-0.5.6}/comate_cli/terminal_agent/tool_view.py

@@ -93,11 +93,10 @@ def should_show_tool_in_scrollback(
         return is_result and is_error
 
     if lowered == "taskcreate":
-        return is_result
+        return is_result and is_error
 
     if lowered == "taskupdate":
-        status = str(args.get("status", "")).strip().lower()
-        return is_result and (is_error or status == "completed")
+        return is_result and is_error
 
     # Read-only task tools: only show errors.
     if lowered in _SILENT_TASK_TOOLS:

{comate_cli-0.5.4 → comate_cli-0.5.6}/comate_cli/terminal_agent/tui.py

@@ -9,7 +9,6 @@ import asyncio
 import logging
 import random
 import time
-from collections import deque
 from collections.abc import Callable
 from contextlib import suppress
 from pathlib import Path
@@ -34,10 +33,14 @@ from comate_agent_sdk.agent import ChatSession
 from comate_agent_sdk.agent.events import (
     ExternalTurnScheduledEvent,
     PlanApprovalRequiredEvent,
+    QueueDirtyEvent,
+    QueueDirtyReason,
+    QueuedMessageInjectedEvent,
     SessionInitEvent,
     StopEvent,
     TeamMessageEvent,
 )
+from comate_agent_sdk.agent.queue_types import MessageOrigin
 
 from comate_cli.terminal_agent.animations import (
     DEFAULT_STATUS_PHRASES,
@@ -196,22 +199,21 @@ class TerminalAgentTUI(
             "AGENT_SDK_TUI_TODO_PANEL_EXPANDED_MAX_LINES",
             12,
         )
-        self._message_queue_max_size = read_env_int(
-            "AGENT_SDK_TUI_MESSAGE_QUEUE_MAX_SIZE",
-            3,
-        )
         self._queued_preview_max_chars = read_env_int(
             "AGENT_SDK_TUI_QUEUED_PREVIEW_MAX_CHARS",
             24,
         )
+        self._queued_preview_max_rows = read_env_int(
+            "AGENT_SDK_TUI_QUEUED_PREVIEW_MAX_ROWS",
+            3,
+        )
 
         self._busy = False
-        self._initializing = False  # MCP 加载中
         self._is_compacting = False
         self._compact_task: asyncio.Task[Any] | None = None
         self._compact_cancel_requested = False
         self._pending_exit_after_compact_cancel = False
-        self._queued_messages: deque[str] = deque()  # busy 时入队的消息（FIFO）
+        self._queued_display_by_message_id: dict[str, str] = {}
         self._waiting_for_input = False
         self._pending_questions: list[dict[str, Any]] | None = None
         self._pending_plan_approval: dict[str, str] | None = None
@@ -220,6 +222,7 @@ class TerminalAgentTUI(
         self._renderer._show_thinking_cb = lambda: self._show_thinking
 
         self._custom_slash_commands: dict[str, CustomSlashCommand] = {}
+        self._skill_slash_command_names: set[str] = set()
         self._slash_registry = SlashCommandRegistry()
         self._build_slash_registry()
         self._slash_completer = SlashCommandCompleter(
@@ -235,6 +238,7 @@ class TerminalAgentTUI(
                 deduplicate=True,
             )
         )
+        self._sync_skill_slash_commands()
         self._loading_frame = 0
         self._fallback_loading_phrase = (
             random.choice(DEFAULT_STATUS_PHRASES)
@@ -288,10 +292,6 @@ class TerminalAgentTUI(
         self._ctrl_c_press_count: int = 0
         ctrl_c_window_ms = read_env_int("AGENT_SDK_TUI_CTRL_C_EXIT_WINDOW_MS", 700)
         self._ctrl_c_exit_window_seconds = ctrl_c_window_ms / 1000.0
-        self._mcp_init_gate_timeout_s = read_env_float(
-            "AGENT_SDK_TUI_MCP_INIT_GATE_TIMEOUT_S",
-            8.0,
-        )
         self._mcp_init_cancel_timeout_s = read_env_float(
             "AGENT_SDK_TUI_MCP_INIT_CANCEL_TIMEOUT_S",
             1.0,
@@ -559,8 +559,8 @@ class TerminalAgentTUI(
                 "status.transient.warning": "bg:default italic fg:ansiyellow",
                 "input.placeholder": "bg:default #9CA3AF",
                 "auto-suggestion": "bg:default #94a3b8",
-                "queue": "bg:#1d222a #d8dee9",
-                "queue.item": "bg:#1d222a #cbd5e1",
+                "queue": "bg:default #d8dee9",
+                "queue.item": "bg:default #cbd5e1",
                 "git-diff.added": "#4ade80",
                 "git-diff.removed": "#f87171",
                 "question.tabs": "bg:default #c7d2fe",
@@ -638,9 +638,7 @@ class TerminalAgentTUI(
         )
 
     def _should_show_queue_panel(self) -> bool:
-        return self._ui_mode == UIMode.NORMAL and len(self._queued_messages) >= 1
-
-    _QUEUED_SLASH_PREFIX = "__COMATE_QUEUED_SLASH__::"
+        return self._ui_mode == UIMode.NORMAL and bool(self._queued_human_messages())
 
     def _build_slash_registry(self) -> None:
         handlers: dict[str, Callable[[str], Any]] = {
@@ -723,31 +721,61 @@ class TerminalAgentTUI(
                 argument_hint=command.argument_hint,
             )
 
-    def _resolve_slash_spec(self, name: str) -> SlashCommandSpec | None:
-        entry = self._slash_registry.resolve(name)
-        if entry is None:
-            return None
-        return entry.spec
+    def _sync_skill_slash_commands(self) -> None:
+        """同步当前 runtime skills 到 slash command registry。"""
+        for name in list(getattr(self, "_skill_slash_command_names", set())):
+            self._slash_registry.unregister(name)
+        self._skill_slash_command_names = set()
 
-    def _encode_queued_slash(self, raw_command: str) -> str:
-        return f"{self._QUEUED_SLASH_PREFIX}{raw_command}"
+        agent = getattr(self._session, "_agent", None)
+        runtime_state = getattr(agent, "_runtime_state", None)
+        skills = list(getattr(runtime_state, "skills", []) or [])
+        seen_names: set[str] = set()
 
-    def _is_encoded_queued_slash(self, value: str) -> bool:
-        return value.startswith(self._QUEUED_SLASH_PREFIX)
+        for skill in skills:
+            if not bool(getattr(skill, "user_invocable", True)):
+                continue
 
-    def _decode_queued_slash(self, value: str) -> str:
-        if not self._is_encoded_queued_slash(value):
-            return value
-        return value[len(self._QUEUED_SLASH_PREFIX) :]
+            name = str(getattr(skill, "name", "")).strip()
+            if not name or name in seen_names:
+                continue
+            seen_names.add(name)
 
-    def _queued_preview_text(self, value: str) -> str:
-        return self._decode_queued_slash(value)
+            if self._slash_registry.resolve(name) is not None:
+                logger.warning(
+                    "Skill '%s' conflicts with an existing slash command, skipping",
+                    name,
+                )
+                continue
 
-    def _dispatch_queued_item(self, queued: str) -> None:
-        if self._is_encoded_queued_slash(queued):
-            self._schedule_background(self._execute_command(self._decode_queued_slash(queued)))
-            return
-        self._schedule_background(self._submit_user_message(queued))
+            spec = SlashCommandSpec(
+                name=name,
+                description=str(getattr(skill, "description", "") or "").strip(),
+                execution_kind="hybrid",
+                argument_hint=getattr(skill, "argument_hint", None),
+            )
+
+            async def _handler(args: str, *, skill_name: str = name) -> None:
+                await self._slash_skill(skill_name=skill_name, args=args)
+
+            self._slash_registry.register(
+                spec=spec,
+                handler=_handler,
+                allow_when_busy=False,
+                source="skill",
+                argument_hint=spec.argument_hint,
+            )
+            self._skill_slash_command_names.add(name)
+
+        slash_completer = getattr(self, "_slash_completer", None)
+        if slash_completer is not None:
+            slash_completer.update_commands(self._slash_registry.command_specs())
+
+    def _resolve_slash_spec(self, name: str) -> SlashCommandSpec | None:
+        entry = self._slash_registry.resolve(name)
+        if entry is None:
+            return None
+        return entry.spec
 
     def _create_input_history(self) -> FileHistory | InMemoryHistory:
         """Create persistent FileHistory based on cwd, with fallback to InMemoryHistory."""
@@ -771,15 +799,16 @@ class TerminalAgentTUI(
     def _input_placeholder_hint(self) -> str | None:
         if self._ui_mode != UIMode.NORMAL:
             return None
-        if not self._queued_messages:
+        queued_messages = self._queued_human_messages()
+        if not queued_messages:
             return None
         input_text = str(getattr(getattr(self, "_input_area", None), "text", ""))
         if input_text.strip():
             return None
-        if len(self._queued_messages) >= 2:
+        if len(queued_messages) >= 2:
             return self._queued_input_hint
 
-        preview = " ".join(self._queued_preview_text(self._queued_messages[0]).split())
+        preview = self._queued_message_preview(queued_messages[0])
         max_chars = max(8, int(self._queued_preview_max_chars))
         if len(preview) > max_chars:
             preview = f"{preview[: max_chars - 3]}..."
@@ -927,10 +956,63 @@ class TerminalAgentTUI(
             async for event in self._session.events():
                 if self._closing:
                     break
+                stop_error: Exception | None = None
                 self._maybe_cancel_tool_result_flash(event)
                 await self._animation_controller.on_event(event)
                 if isinstance(event, SessionInitEvent):
                     self._initialized_session_id = str(event.session_id)
+                if isinstance(event, QueueDirtyEvent):
+                    if event.reason in {
+                        QueueDirtyReason.CANCELLED,
+                        QueueDirtyReason.CLEARED,
+                    }:
+                        for message_id in event.message_ids:
+                            self._queued_display_by_message_id.pop(
+                                str(message_id),
+                                None,
+                            )
+                    if event.reason is QueueDirtyReason.CONSUMED:
+                        consumed_human_displays: list[str] = []
+                        for message_id, origin in zip(event.message_ids, event.origins):
+                            if origin is not MessageOrigin.HUMAN:
+                                continue
+                            display_text = self._queued_display_by_message_id.pop(
+                                str(message_id),
+                                None,
+                            )
+                            if display_text:
+                                consumed_human_displays.append(display_text)
+                        if consumed_human_displays and not self._busy:
+                            self._session.run_controller.clear()
+                            self._interrupt_requested_at = None
+                            self._waiting_for_input = False
+                            self._pending_questions = None
+                            self._pending_plan_approval = None
+                            self._set_busy(True)
+                            self._run_start_time = time.monotonic()
+                            self._fallback_loading_phrase = (
+                                random.choice(DEFAULT_STATUS_PHRASES)
+                                if DEFAULT_STATUS_PHRASES
+                                else f"Thinking{ELLIPSIS}"
+                            )
+                            self._fallback_phrase_refresh_at = time.monotonic() + 3.0
+                            self._renderer.start_turn()
+                            await self._animation_controller.start()
+                            self._last_turn_user_preview = consumed_human_displays[-1]
+                        for display_text in consumed_human_displays:
+                            self._renderer.seed_user_message(display_text)
+                    self._refresh_layers()
+                    self._invalidate()
+                if isinstance(event, QueuedMessageInjectedEvent):
+                    for message_id, origin in zip(event.message_ids, event.origins):
+                        if origin is not MessageOrigin.HUMAN:
+                            continue
+                        display_text = self._queued_display_by_message_id.pop(
+                            str(message_id),
+                            None,
+                        )
+                        if display_text:
+                            self._renderer.seed_user_message(display_text)
                 if isinstance(event, ExternalTurnScheduledEvent) and not self._busy:
                     self._session.run_controller.clear()
                     self._interrupt_requested_at = None
@@ -954,6 +1036,14 @@ class TerminalAgentTUI(
                     }
                 if isinstance(event, StopEvent):
                     stop_reason = str(event.reason or "")
+                    raw_stop_error = event.metadata.get("error")
+                    if raw_stop_error is not None:
+                        stop_error = (
+                            raw_stop_error
+                            if isinstance(raw_stop_error, Exception)
+                            else Exception(str(raw_stop_error))
+                        )
+                        stop_reason = "error"
                     if event.reason == "shutdown_request":
                         shutdown_recipients = event.metadata.get("shutdown_recipients", [])
                         if shutdown_recipients:
@@ -969,6 +1059,15 @@ class TerminalAgentTUI(
                     waiting_for_input = True
                     if new_questions is not None:
                         questions = new_questions
+                if stop_error is not None:
+                    from comate_cli.terminal_agent.error_display import format_error
+
+                    message, transient_summary, severity = format_error(stop_error)
+                    self._renderer.append_system_message(message, severity=severity)
+                    self._status_bar.show_transient(
+                        transient_summary,
+                        severity=severity,
+                    )
                 self._refresh_layers()
                 if isinstance(event, StopEvent):
                     background_turn = self._background_turn_source is not None
@@ -1013,14 +1112,6 @@ class TerminalAgentTUI(
 
                     self._refresh_layers()
 
-                    if (
-                        self._queued_messages
-                        and not waiting_for_input
-                        and plan_approval is None
-                    ):
-                        queued = self._queued_messages.popleft()
-                        self._dispatch_queued_item(queued)
-
                     waiting_for_input = False
                     questions = None
                     plan_approval = None
@@ -1285,17 +1376,16 @@ class TerminalAgentTUI(
                 if self._renderer.has_running_tools():
                     # Keep repainting for breathing animation.
                     self._render_dirty = True
-                elif self._busy or self._initializing:
+                elif self._busy:
                     self._render_dirty = True
 
                 if self._render_dirty:
                     self._invalidate()
                     self._render_dirty = False
 
-                # 动态帧率：busy/动画/initializing 时降为 6fps（缓解 scrollback 污染），idle 时 4fps
+                # 动态帧率：busy/动画时降为 6fps（缓解 scrollback 污染），idle 时 4fps
                 fast = (
                     self._busy
-                    or self._initializing
                     or self._animator.is_active
                     or self._renderer.has_running_tools()
                 )
@@ -1408,45 +1498,23 @@ class TerminalAgentTUI(
             logger.exception("Plugin init failed at startup; continuing without plugins")
 
         if mcp_init is not None:
-            self._initializing = True
-
             async def _do_init() -> None:
-                init_task = asyncio.create_task(mcp_init(), name="terminal-mcp-init-worker")
                 try:
-                    await asyncio.wait_for(
-                        asyncio.shield(init_task),
-                        timeout=self._mcp_init_gate_timeout_s,
-                    )
-                except asyncio.TimeoutError:
-                    logger.debug(
-                        "MCP init timed out after "
-                        f"{self._mcp_init_gate_timeout_s:.1f}s; continuing in background",
-                    )
-                    self._status_bar.show_transient(
-                        f"MCP: init timed out, continuing in background{ELLIPSIS}",
-                        duration_s=5.0,
-                    )
-                    # Don't cancel init_task — let it complete in background.
-                    # asyncio.shield above already protects it from wait_for's
-                    # auto-cancellation. When it finishes, runtime._mcp_manager
-                    # will be set and tools become available for the next turn.
+                    await mcp_init()
                 except asyncio.CancelledError:
-                    await self._cancel_task_with_timeout(
-                        init_task,
-                        timeout_s=self._mcp_init_cancel_timeout_s,
-                        task_name="terminal-mcp-init-worker",
-                    )
-                    return
+                    raise
                 except Exception as exc:
-                    logger.debug(f"MCP init failed in TUI bootstrap: {exc}", exc_info=True)
+                    logger.debug(
+                        f"MCP init failed in TUI bootstrap: {exc}",
+                        exc_info=True,
+                    )
                 finally:
-                    self._initializing = False
-                    if self._queued_messages and not self._busy:
-                        queued = self._queued_messages.popleft()
-                        self._dispatch_queued_item(queued)
                     self._refresh_layers()
 
-            self._mcp_init_task = asyncio.create_task(_do_init(), name="terminal-mcp-init")
+            self._mcp_init_task = asyncio.create_task(
+                _do_init(),
+                name="terminal-mcp-init",
+            )
 
         self._ui_tick_task = asyncio.create_task(
             self._ui_tick(),
@@ -1519,6 +1587,9 @@ class TerminalAgentTUI(
 
             # Commands → SlashCommandRegistry with namespace prefix
             for cmd in plugin.commands:
+                if cmd.name in getattr(self, "_skill_slash_command_names", set()):
+                    self._slash_registry.unregister(cmd.name)
+                    self._skill_slash_command_names.discard(cmd.name)
                 spec = SlashCommandSpec(
                     name=cmd.name,  # already namespaced: "plugin-name:cmd-name"
                     description=cmd.description,
@@ -1576,8 +1647,10 @@ class TerminalAgentTUI(
         if any(p.agents for p in plugins):
             rebuild_agent_tool(agent)
 
+        if any(p.skills for p in plugins):
+            self._sync_skill_slash_commands()
         # Refresh tab-completion so new plugin commands appear
-        if any(p.commands for p in plugins):
+        elif any(p.commands for p in plugins):
             self._slash_completer.update_commands(self._slash_registry.command_specs())
 
     def _clear_plugin_resources(self) -> None:
@@ -1615,10 +1688,6 @@ class TerminalAgentTUI(
             self._custom_slash_commands.pop(cmd_name, None)
         self._plugin_command_names = set()
 
-        # Refresh tab-completion so removed commands disappear
-        if had_commands:
-            self._slash_completer.update_commands(self._slash_registry.command_specs())
-
         # Remove plugin MCP servers from frozen config
         has_mcp = any(p.mcp_servers for p in loaded)
         if has_mcp and agent.config.mcp_servers:
@@ -1642,3 +1711,5 @@ class TerminalAgentTUI(
             rebuild_skill_tool(agent)
         if had_agents:
             rebuild_agent_tool(agent)
+        if had_skills or had_commands:
+            self._sync_skill_slash_commands()