comate-cli 0.5.0__tar.gz → 0.5.1__tar.gz

{comate_cli-0.5.0 → comate_cli-0.5.1}/PKG-INFO

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

@@ -43,6 +43,7 @@ _DEFAULT_TOOL_PANEL_MAX_LINES = 4
 _DEFAULT_TASK_PANEL_MAX_LINES = 6
 _RECENT_TEAM_EVENT_CACHE_SIZE = 128
 _FILE_REF_MAX_COUNT_BYTES = 10 * 1024 * 1024  # 10 MB
+_SYSTEM_MESSAGE_DEDUPE_WINDOW_SECONDS = 0.5
 
 
 def _truncate(content: str, max_len: int = 120) -> str:
@@ -207,6 +208,37 @@ class EventRenderer:
         self._recent_team_event_keys: deque[tuple[str, str, str, str, str, str]] = deque(
             maxlen=_RECENT_TEAM_EVENT_CACHE_SIZE
         )
+        self._last_history_append_at: float = 0.0
+
+    def _append_history_entry(self, entry: HistoryEntry) -> None:
+        self._history.append(entry)
+        self._last_history_append_at = time.monotonic()
+
+    def _should_drop_duplicate_system_message(
+        self,
+        *,
+        content: str,
+        severity: Literal["info", "warning", "error"],
+    ) -> bool:
+        if severity not in {"warning", "error"}:
+            return False
+        if not self._history:
+            return False
+        last_entry = self._history[-1]
+        if last_entry.entry_type != "system":
+            return False
+        if last_entry.severity != severity:
+            return False
+        if str(last_entry.text).strip() != content:
+            return False
+        if time.monotonic() - self._last_history_append_at > _SYSTEM_MESSAGE_DEDUPE_WINDOW_SECONDS:
+            return False
+        logger.debug(
+            "Skip duplicate system message in scrollback: severity=%s content=%r",
+            severity,
+            content,
+        )
+        return True
 
     def start_turn(self) -> None:
         self._flush_assistant_segment()
@@ -218,7 +250,7 @@ class EventRenderer:
         if not normalized:
             return
         self._flush_assistant_segment()
-        self._history.append(HistoryEntry(entry_type="user", text=normalized))
+        self._append_history_entry(HistoryEntry(entry_type="user", text=normalized))
         self._maybe_append_file_ref_hint(normalized)
 
     def _maybe_append_file_ref_hint(self, text: str) -> None:
@@ -230,7 +262,9 @@ class EventRenderer:
             candidate = self._project_root / raw_path
             try:
                 if candidate.is_dir():
-                    self._history.append(HistoryEntry(entry_type="file_ref", text=f"Listed directory {raw_path}"))
+                    self._append_history_entry(
+                        HistoryEntry(entry_type="file_ref", text=f"Listed directory {raw_path}")
+                    )
                     return
                 if candidate.is_file():
                     hint = f"Read {raw_path}"
@@ -241,7 +275,7 @@ class EventRenderer:
                             hint += f"  ({line_count} lines)"
                         except OSError:
                             pass
-                    self._history.append(HistoryEntry(entry_type="file_ref", text=hint))
+                    self._append_history_entry(HistoryEntry(entry_type="file_ref", text=hint))
                     return
             except OSError:
                 continue
@@ -261,7 +295,7 @@ class EventRenderer:
 
     def interrupt_turn(self) -> None:
         if self._running_tools:
-            self._history.append(
+            self._append_history_entry(
                 HistoryEntry(
                     entry_type="system",
                     text=f"Current task interrupted ({len(self._running_tools)} running tools)",
@@ -343,7 +377,7 @@ class EventRenderer:
         normalized = text.strip()
         if not normalized:
             return
-        self._history.append(HistoryEntry(entry_type="file_ref", text=normalized))
+        self._append_history_entry(HistoryEntry(entry_type="file_ref", text=normalized))
 
     def append_system_message(
         self,
@@ -354,8 +388,13 @@ class EventRenderer:
         normalized = content.strip()
         if not normalized:
             return
+        if self._should_drop_duplicate_system_message(
+            content=normalized,
+            severity=severity,
+        ):
+            return
         self._flush_assistant_segment()
-        self._history.append(
+        self._append_history_entry(
             HistoryEntry(entry_type="system", text=normalized, severity=severity)
         )
 
@@ -433,14 +472,14 @@ class EventRenderer:
         if not normalized:
             return
         self._flush_assistant_segment()
-        self._history.append(HistoryEntry(entry_type="elapsed", text=normalized))
+        self._append_history_entry(HistoryEntry(entry_type="elapsed", text=normalized))
 
     def append_assistant_message(self, content: str) -> None:
         normalized = content.strip()
         if not normalized:
             return
         self._flush_assistant_segment()
-        self._history.append(HistoryEntry(entry_type="assistant", text=normalized))
+        self._append_history_entry(HistoryEntry(entry_type="assistant", text=normalized))
 
     def tool_panel_entries(
         self, *, max_lines: int | None = None
@@ -554,7 +593,9 @@ class EventRenderer:
     def _flush_assistant_segment(self) -> None:
         if not self._assistant_buffer:
             return
-        self._history.append(HistoryEntry(entry_type="assistant", text=self._assistant_buffer))
+        self._append_history_entry(
+            HistoryEntry(entry_type="assistant", text=self._assistant_buffer)
+        )
         self._assistant_buffer = ""
 
     def _append_assistant_text(self, text: str) -> None:
@@ -700,18 +741,18 @@ class EventRenderer:
                 text_obj.append(f" · {model_name}", style="dim")
             text_obj.append("\n")
             text_obj.append(self._render_diff_text(diff_lines, max_lines=self._diff_max_lines))
-            self._history.append(
+            self._append_history_entry(
                 HistoryEntry(entry_type="tool_result", text=text_obj, severity="info", subtitle=subtitle)
             )
             return
         if model_name:
             text_obj = Text(signature)
             text_obj.append(f" · {model_name}", style="dim")
-            self._history.append(
+            self._append_history_entry(
                 HistoryEntry(entry_type="tool_result", text=text_obj, severity=sev, subtitle=subtitle)
             )
             return
-        self._history.append(
+        self._append_history_entry(
             HistoryEntry(
                 entry_type="tool_result",
                 text=signature,
@@ -764,7 +805,9 @@ class EventRenderer:
         if state is None:
             display_name = resolve_display_tool_name(tool_name, {})
             signature = _tool_signature(display_name, "")
-            self._history.append(HistoryEntry(entry_type="tool_result", text=signature, severity=sev, subtitle=subtitle))
+            self._append_history_entry(
+                HistoryEntry(entry_type="tool_result", text=signature, severity=sev, subtitle=subtitle)
+            )
             return
 
         if state.is_task:
@@ -811,15 +854,19 @@ class EventRenderer:
                     text_obj = Text(base)
                 text_obj.append("\n")
                 text_obj.append(self._render_diff_text(diff_lines, max_lines=self._diff_max_lines))
-                self._history.append(
+                self._append_history_entry(
                     HistoryEntry(entry_type="tool_result", text=text_obj, severity="info", subtitle=subtitle)
                 )
                 return
 
         if isinstance(base, Text):
-            self._history.append(HistoryEntry(entry_type="tool_result", text=base, severity=sev, subtitle=subtitle))
+            self._append_history_entry(
+                HistoryEntry(entry_type="tool_result", text=base, severity=sev, subtitle=subtitle)
+            )
         else:
-            self._history.append(HistoryEntry(entry_type="tool_result", text=base, severity=sev, subtitle=subtitle))
+            self._append_history_entry(
+                HistoryEntry(entry_type="tool_result", text=base, severity=sev, subtitle=subtitle)
+            )
 
     @staticmethod
     def _render_diff_text(diff_lines: list[str], max_lines: int = 50) -> Text:
@@ -900,7 +947,7 @@ class EventRenderer:
     def _append_questions(self, questions: list[dict[str, Any]]) -> None:
         if not questions:
             return
-        self._history.append(
+        self._append_history_entry(
             HistoryEntry(
                 entry_type="tool_result",
                 text=f"Input required: {len(questions)} question(s) pending.",
@@ -919,7 +966,7 @@ class EventRenderer:
                     if label:
                         labels.append(label)
             choice_preview = f" (Options: {' / '.join(labels)})" if labels else ""
-            self._history.append(
+            self._append_history_entry(
                 HistoryEntry(
                     entry_type="tool_result",
                     text=f"  {idx}. {header}: {question_text} {choice_preview}".strip(),
@@ -962,7 +1009,7 @@ class EventRenderer:
         if started is not None:
             elapsed_suffix = f" · {_format_duration(time.monotonic() - started)}"
         total = len(normalized)
-        self._history.append(
+        self._append_history_entry(
             HistoryEntry(
                 entry_type="tool_result",
                 text=f"tasks {total}/{total} completed{elapsed_suffix}",
@@ -1042,7 +1089,7 @@ class EventRenderer:
                 pass
             case ThinkingEvent(content=thinking):
                 self._thinking_content = thinking
-                self._history.append(HistoryEntry(entry_type="thinking", text=thinking))
+                self._append_history_entry(HistoryEntry(entry_type="thinking", text=thinking))
             case CompactionResultEvent(
                 current_tokens=tokens,
                 threshold=threshold,
@@ -1207,7 +1254,7 @@ class EventRenderer:
                 if reason == "waiting_for_plan_approval":
                     return (False, None)
                 if reason == "interrupted":
-                    self._history.append(
+                    self._append_history_entry(
                         HistoryEntry(entry_type="system", text="Current task interrupted.", severity="warning")
                     )
             case PlanApprovalRequiredEvent(
@@ -1225,18 +1272,18 @@ class EventRenderer:
                     except Exception:
                         logger.warning("ExitPlanMode: Failed to read plan file %s", plan_path)
                 if plan_content:
-                    self._history.append(
+                    self._append_history_entry(
                         HistoryEntry(
                             entry_type="system",
                             text="─── Here is the plan, please review and approve or reject ───",
                         )
                     )
-                    self._history.append(HistoryEntry(entry_type="assistant", text=plan_content))
+                    self._append_history_entry(HistoryEntry(entry_type="assistant", text=plan_content))
 
                 text = f"Plan ready for review: {plan_path}"
                 if summary:
                     text = f"{text} | {summary}"
-                self._history.append(
+                self._append_history_entry(
                     HistoryEntry(entry_type="system", text=text)
                 )
             case TeamMessageEvent(

{comate_cli-0.5.0 → comate_cli-0.5.1}/comate_cli/terminal_agent/logging_adapter.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 import logging
 import os
 import sys
+import threading
+import time
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.application import run_in_terminal
@@ -12,6 +14,30 @@ if TYPE_CHECKING:
     from comate_cli.terminal_agent.event_renderer import EventRenderer
 
 
+_COMATE_LOGGING_SESSION_MARKER = "_comate_tui_logging_session"
+_RECENT_DUPLICATE_LOG_WINDOW_SECONDS = 0.5
+_recent_log_message_times: dict[str, float] = {}
+_recent_log_message_lock = threading.Lock()
+_active_tui_logging_session: "TUILoggingSession | None" = None
+_active_tui_logging_session_lock = threading.Lock()
+
+
+def _should_drop_recent_duplicate_log(msg_key: str) -> bool:
+    now = time.monotonic()
+    with _recent_log_message_lock:
+        expired_keys = [
+            key
+            for key, ts in _recent_log_message_times.items()
+            if now - ts > _RECENT_DUPLICATE_LOG_WINDOW_SECONDS
+        ]
+        for key in expired_keys:
+            _recent_log_message_times.pop(key, None)
+
+        previous = _recent_log_message_times.get(msg_key)
+        _recent_log_message_times[msg_key] = now
+        return previous is not None
+
+
 class TUILoggingHandler(logging.Handler):
     """自定义 logging handler，将日志友好地显示在 TUI 中
 
@@ -40,6 +66,8 @@ class TUILoggingHandler(logging.Handler):
 
             # 首次显示检查
             msg_key = self._get_message_key(record)
+            if _should_drop_recent_duplicate_log(msg_key):
+                return
             if msg_key in self._shown_messages:
                 return
             self._shown_messages.add(msg_key)
@@ -108,9 +136,9 @@ class TUILoggingHandler(logging.Handler):
                 # DummyApplication，直接调用
                 _append()
             else:
-                app.create_background_task(
-                    run_in_terminal(_append, in_executor=False)
-                )
+                # run_in_terminal() 自身已经会调度 Future；这里不能再交给
+                # create_background_task() 二次包装，否则会触发重复执行竞态。
+                run_in_terminal(_append, in_executor=False)
         except Exception:
             # 没有 app 或导入失败，直接调用
             _append()
@@ -159,6 +187,10 @@ class TUILoggingSession:
                 continue
 
         self._root_logger.setLevel(self._previous_level)
+        with _active_tui_logging_session_lock:
+            global _active_tui_logging_session
+            if _active_tui_logging_session is self:
+                _active_tui_logging_session = None
 
 
 def _build_file_handler() -> logging.Handler:
@@ -197,14 +229,40 @@ def setup_tui_logging(renderer: EventRenderer) -> TUILoggingSession:
     root = logging.getLogger()
     previous_level = root.level
 
+    with _active_tui_logging_session_lock:
+        global _active_tui_logging_session
+        active_session = _active_tui_logging_session
+    if active_session is not None:
+        active_session.close()
+    with _recent_log_message_lock:
+        _recent_log_message_times.clear()
+
+    stale_handlers: list[logging.Handler] = []
+    for handler in list(root.handlers):
+        if not getattr(handler, _COMATE_LOGGING_SESSION_MARKER, False):
+            continue
+        try:
+            root.removeHandler(handler)
+        except Exception:
+            pass
+        stale_handlers.append(handler)
+
+    for handler in stale_handlers:
+        try:
+            handler.close()
+        except Exception:
+            continue
+
     # 1. 日志文件 handler（完整调试信息，含 traceback）
     file_handler = _build_file_handler()
+    setattr(file_handler, _COMATE_LOGGING_SESSION_MARKER, True)
     root.addHandler(file_handler)
     root.setLevel(logging.DEBUG)
 
     # 2. TUI handler 挂到 root（覆盖所有命名空间的 WARNING/ERROR）
     tui_handler = TUILoggingHandler(renderer)
     tui_handler.setLevel(logging.WARNING)
+    setattr(tui_handler, _COMATE_LOGGING_SESSION_MARKER, True)
     root.addHandler(tui_handler)
 
     # 3. 临时静默直写终端的 handler，避免污染 prompt_toolkit UI
@@ -218,9 +276,12 @@ def setup_tui_logging(renderer: EventRenderer) -> TUILoggingSession:
         handler.addFilter(log_filter)
         muted_handlers.append((handler, log_filter))
 
-    return TUILoggingSession(
+    session = TUILoggingSession(
         root_logger=root,
         added_handlers=[file_handler, tui_handler],
         muted_handlers=muted_handlers,
         previous_level=previous_level,
     )
+    with _active_tui_logging_session_lock:
+        _active_tui_logging_session = session
+    return session

{comate_cli-0.5.0 → comate_cli-0.5.1}/pyproject.toml

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

{comate_cli-0.5.0 → comate_cli-0.5.1}/tests/test_event_renderer.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import tempfile
 import unittest
 from pathlib import Path
+from unittest.mock import patch
 
 from comate_agent_sdk.agent.events import (
     CompactionResultEvent,
@@ -36,6 +37,41 @@ def _task_payload(size: int) -> list[dict[str, str]]:
 
 
 class TestEventRenderer(unittest.TestCase):
+    def test_append_system_message_deduplicates_adjacent_warning_within_window(self) -> None:
+        renderer = EventRenderer()
+
+        with patch(
+            "comate_cli.terminal_agent.event_renderer.time.monotonic",
+            side_effect=[100.0, 100.2, 100.2],
+        ):
+            renderer.append_system_message("boom", severity="warning")
+            renderer.append_system_message("boom", severity="warning")
+
+        system_entries = [e for e in renderer.history_entries() if e.entry_type == "system"]
+        self.assertEqual(len(system_entries), 1)
+        self.assertEqual(system_entries[0].text, "boom")
+
+    def test_append_system_message_keeps_same_warning_after_window(self) -> None:
+        renderer = EventRenderer()
+
+        with patch(
+            "comate_cli.terminal_agent.event_renderer.time.monotonic",
+            side_effect=[100.0, 100.7, 100.7],
+        ):
+            renderer.append_system_message("boom", severity="warning")
+            renderer.append_system_message("boom", severity="warning")
+
+        system_entries = [e for e in renderer.history_entries() if e.entry_type == "system"]
+        self.assertEqual(len(system_entries), 2)
+
+    def test_append_system_message_does_not_deduplicate_info(self) -> None:
+        renderer = EventRenderer()
+        renderer.append_system_message("same-info", severity="info")
+        renderer.append_system_message("same-info", severity="info")
+
+        system_entries = [e for e in renderer.history_entries() if e.entry_type == "system"]
+        self.assertEqual(len(system_entries), 2)
+
     def test_team_message_event_deduplicates_identical_event(self) -> None:
         renderer = EventRenderer()
         event = TeamMessageEvent(

comate_cli-0.5.1/tests/test_logging_adapter.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+import io
+import logging
+import sys
+from unittest.mock import patch
+
+from comate_cli.terminal_agent.logging_adapter import (
+    TUILoggingHandler,
+    TUILoggingSession,
+    setup_tui_logging,
+)
+
+
+class _FakeRenderer:
+    def __init__(self) -> None:
+        self.messages: list[tuple[str, str]] = []
+
+    def append_system_message(self, message: str, *, severity: str) -> None:
+        self.messages.append((message, severity))
+
+
+def test_setup_tui_logging_preserves_existing_root_handlers_and_restores_them() -> None:
+    root = logging.getLogger()
+    original_handlers = list(root.handlers)
+    original_level = root.level
+    stderr_handler = logging.StreamHandler(sys.stderr)
+    root.addHandler(stderr_handler)
+
+    session: TUILoggingSession | None = None
+    try:
+        session = setup_tui_logging(_FakeRenderer())
+
+        assert stderr_handler in root.handlers
+        assert any(isinstance(handler, TUILoggingHandler) for handler in root.handlers)
+        assert root.level == logging.DEBUG
+        assert len(stderr_handler.filters) == 1
+    finally:
+        if session is not None:
+            session.close()
+        if stderr_handler in root.handlers:
+            root.removeHandler(stderr_handler)
+        root.handlers[:] = original_handlers
+        root.setLevel(original_level)
+
+    assert stderr_handler.filters == []
+    assert root.handlers == original_handlers
+    assert root.level == original_level
+
+
+def test_setup_tui_logging_does_not_mute_non_terminal_stream_handlers() -> None:
+    root = logging.getLogger()
+    original_handlers = list(root.handlers)
+    original_level = root.level
+    buffer_handler = logging.StreamHandler(io.StringIO())
+    root.addHandler(buffer_handler)
+
+    session: TUILoggingSession | None = None
+    try:
+        session = setup_tui_logging(_FakeRenderer())
+        assert buffer_handler in root.handlers
+        assert buffer_handler.filters == []
+    finally:
+        if session is not None:
+            session.close()
+        if buffer_handler in root.handlers:
+            root.removeHandler(buffer_handler)
+        root.handlers[:] = original_handlers
+        root.setLevel(original_level)
+
+
+def test_setup_tui_logging_replaces_stale_managed_handlers_before_installing_new_ones() -> None:
+    root = logging.getLogger()
+    original_handlers = list(root.handlers)
+    original_level = root.level
+    renderer1 = _FakeRenderer()
+    renderer2 = _FakeRenderer()
+
+    session1: TUILoggingSession | None = None
+    session2: TUILoggingSession | None = None
+    try:
+        session1 = setup_tui_logging(renderer1)
+        session2 = setup_tui_logging(renderer2)
+
+        tui_handlers = [h for h in root.handlers if isinstance(h, TUILoggingHandler)]
+        managed_handlers = [
+            h for h in root.handlers if getattr(h, "_comate_tui_logging_session", False)
+        ]
+
+        assert len(tui_handlers) == 1
+        assert len(managed_handlers) == 2
+
+        logging.getLogger("test.logging").warning("duplicate-warning-check")
+
+        assert renderer1.messages == []
+        assert renderer2.messages == [("duplicate-warning-check", "warning")]
+    finally:
+        if session2 is not None:
+            session2.close()
+        if session1 is not None:
+            session1.close()
+        root.handlers[:] = original_handlers
+        root.setLevel(original_level)
+
+
+def test_tui_logging_handler_deduplicates_recent_duplicate_across_handlers() -> None:
+    renderer = _FakeRenderer()
+    handler1 = TUILoggingHandler(renderer)
+    handler2 = TUILoggingHandler(renderer)
+    record = logging.LogRecord(
+        name="test.logging",
+        level=logging.WARNING,
+        pathname=__file__,
+        lineno=1,
+        msg="duplicate-warning-check",
+        args=(),
+        exc_info=None,
+    )
+
+    with patch(
+        "comate_cli.terminal_agent.logging_adapter._recent_log_message_times",
+        {},
+    ):
+        handler1.emit(record)
+        handler2.emit(record)
+
+    assert renderer.messages == [("duplicate-warning-check", "warning")]
+
+
+def test_tui_logging_handler_does_not_wrap_run_in_terminal_with_background_task() -> None:
+    renderer = _FakeRenderer()
+    handler = TUILoggingHandler(renderer)
+    record = logging.LogRecord(
+        name="test.logging",
+        level=logging.WARNING,
+        pathname=__file__,
+        lineno=1,
+        msg="background-task-race-check",
+        args=(),
+        exc_info=None,
+    )
+
+    class _FakeApp:
+        def create_background_task(self, _coroutine) -> None:
+            raise AssertionError("create_background_task should not be called")
+
+    def _run_in_terminal_now(func, render_cli_done=False, in_executor=False):  # type: ignore[no-untyped-def]
+        assert render_cli_done is False
+        assert in_executor is False
+        func()
+        return object()
+
+    with (
+        patch("prompt_toolkit.application.get_app", return_value=_FakeApp()),
+        patch(
+            "comate_cli.terminal_agent.logging_adapter.run_in_terminal",
+            side_effect=_run_in_terminal_now,
+        ),
+        patch(
+            "comate_cli.terminal_agent.logging_adapter._recent_log_message_times",
+            {},
+        ),
+    ):
+        handler.emit(record)
+
+    assert renderer.messages == [("background-task-race-check", "warning")]

comate_cli-0.5.0/tests/test_logging_adapter.py

@@ -1,68 +0,0 @@
-from __future__ import annotations
-
-import io
-import logging
-import sys
-
-from comate_cli.terminal_agent.logging_adapter import (
-    TUILoggingHandler,
-    TUILoggingSession,
-    setup_tui_logging,
-)
-
-
-class _FakeRenderer:
-    def __init__(self) -> None:
-        self.messages: list[tuple[str, str]] = []
-
-    def append_system_message(self, message: str, *, severity: str) -> None:
-        self.messages.append((message, severity))
-
-
-def test_setup_tui_logging_preserves_existing_root_handlers_and_restores_them() -> None:
-    root = logging.getLogger()
-    original_handlers = list(root.handlers)
-    original_level = root.level
-    stderr_handler = logging.StreamHandler(sys.stderr)
-    root.addHandler(stderr_handler)
-
-    session: TUILoggingSession | None = None
-    try:
-        session = setup_tui_logging(_FakeRenderer())
-
-        assert stderr_handler in root.handlers
-        assert any(isinstance(handler, TUILoggingHandler) for handler in root.handlers)
-        assert root.level == logging.DEBUG
-        assert len(stderr_handler.filters) == 1
-    finally:
-        if session is not None:
-            session.close()
-        if stderr_handler in root.handlers:
-            root.removeHandler(stderr_handler)
-        root.handlers[:] = original_handlers
-        root.setLevel(original_level)
-
-    assert stderr_handler.filters == []
-    assert root.handlers == original_handlers
-    assert root.level == original_level
-
-
-def test_setup_tui_logging_does_not_mute_non_terminal_stream_handlers() -> None:
-    root = logging.getLogger()
-    original_handlers = list(root.handlers)
-    original_level = root.level
-    buffer_handler = logging.StreamHandler(io.StringIO())
-    root.addHandler(buffer_handler)
-
-    session: TUILoggingSession | None = None
-    try:
-        session = setup_tui_logging(_FakeRenderer())
-        assert buffer_handler in root.handlers
-        assert buffer_handler.filters == []
-    finally:
-        if session is not None:
-            session.close()
-        if buffer_handler in root.handlers:
-            root.removeHandler(buffer_handler)
-        root.handlers[:] = original_handlers
-        root.setLevel(original_level)