shrinkray 26.1.1.0__tar.gz → 26.2.4.1__tar.gz

{shrinkray-26.1.1.0/src/shrinkray.egg-info → shrinkray-26.2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shrinkray
-Version: 26.1.1.0
+Version: 26.2.4.1
 Summary: Shrink Ray
 Author-email: "David R. MacIver" <david@drmaciver.com>
 License: MIT

{shrinkray-26.1.1.0 → shrinkray-26.2.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shrinkray"
-version = "26.1.1.0"
+version = "26.2.4.1"
 description = "Shrink Ray"
 authors = [
     {name = "David R. MacIver", email = "david@drmaciver.com"}

{shrinkray-26.1.1.0 → shrinkray-26.2.4.1}/src/shrinkray/subprocess/client.py

@@ -27,6 +27,7 @@ class SubprocessClient:
         self._progress_queue: asyncio.Queue[ProgressUpdate] = asyncio.Queue()
         self._reader_task: asyncio.Task | None = None
         self._completed = False
+        self._closed = False
         self._error_message: str | None = None
         self._debug_mode = debug_mode
         self._stderr_log_file: IO[str] | None = None
@@ -261,6 +262,17 @@ class SubprocessClient:
 
     async def close(self) -> None:
         """Close the subprocess."""
+        if self._closed:
+            return
+        self._closed = True
+
+        # Cancel all pending futures first so any code awaiting send_command
+        # responses (e.g. cancel() in action_quit) is unblocked immediately.
+        for future in self._pending_responses.values():
+            if not future.done():
+                future.cancel()
+        self._pending_responses.clear()
+
         if self._reader_task is not None:
             self._reader_task.cancel()
             try:
@@ -278,13 +290,21 @@ class SubprocessClient:
             if self._process.returncode is None:
                 try:
                     self._process.terminate()
-                    await asyncio.wait_for(self._process.wait(), timeout=5.0)
+                    await asyncio.wait_for(self._process.wait(), timeout=2.0)
                 except TimeoutError:
                     self._process.kill()
                     await self._process.wait()
                 except ProcessLookupError:
                     pass  # Process already exited
 
+            # Always await wait() to ensure the asyncio transport is fully
+            # finalized before the event loop closes. This prevents the
+            # "Event loop is closed" RuntimeError from BaseSubprocessTransport.__del__.
+            if self._process.returncode is not None:
+                await self._process.wait()
+                # Flush pending event loop callbacks (transport cleanup)
+                await asyncio.sleep(0)
+
         # Close and remove the stderr log file
         if self._stderr_log_file is not None:
             try:

{shrinkray-26.1.1.0 → shrinkray-26.2.4.1}/src/shrinkray/tui.py

@@ -13,7 +13,6 @@ from difflib import unified_diff
 from typing import Literal, Protocol, cast
 
 import humanize
-from rich.markup import escape as escape_markup
 from rich.text import Text
 from textual import work
 from textual.app import App, ComposeResult
@@ -46,6 +45,7 @@ from shrinkray.subprocess.protocol import (
 
 ThemeMode = Literal["auto", "dark", "light"]
 
+
 # Custom themes with true white/black backgrounds
 SHRINKRAY_LIGHT_THEME = Theme(
     name="shrinkray-light",
@@ -505,20 +505,20 @@ class ContentPreview(Static):
         # Fallback based on common terminal height
         return 30
 
-    def render(self) -> str:
+    def render(self) -> Text:
         if not self.preview_content:
-            return "Loading..."
+            return Text("Loading...")
 
         available_lines = self._get_available_lines()
 
         if self.hex_mode:
-            return f"[Hex mode]\n{self.preview_content}"
+            return Text(f"[Hex mode]\n{self.preview_content}")
 
         lines = self.preview_content.split("\n")
 
         # For small files that fit, show full content
         if len(lines) <= available_lines:
-            return self.preview_content
+            return Text(self.preview_content)
 
         # For larger files, show diff if we have previous displayed content
         if (
@@ -530,10 +530,10 @@ class ContentPreview(Static):
             diff = list(unified_diff(prev_lines, curr_lines, lineterm=""))
             if diff:
                 # Show as much diff as fits
-                return "\n".join(diff[:available_lines])
+                return Text("\n".join(diff[:available_lines]))
 
         # No diff available, show truncated content
-        return (
+        return Text(
             "\n".join(lines[:available_lines])
             + f"\n\n... ({len(lines) - available_lines} more lines)"
         )
@@ -591,39 +591,46 @@ class OutputPreview(Static):
             pass
         return 30
 
-    def render(self) -> str:
+    def render(self) -> Text:
         # Header line - use return_code to determine if test is running
         # (return_code is None means still running, has value means completed)
         if self.active_test_id is not None and self.last_return_code is None:
-            header = f"[green]Test #{self.active_test_id} running...[/green]"
+            header_text = f"Test #{self.active_test_id} running..."
+            header_style = "green"
         elif self.active_test_id is not None:
-            header = f"[dim]Test #{self.active_test_id} exited with code {self.last_return_code}[/dim]"
+            header_text = (
+                f"Test #{self.active_test_id} exited with code {self.last_return_code}"
+            )
+            header_style = "dim"
         elif self._has_seen_output or self.output_content:
             # Have seen output before - show without header
-            header = ""
+            header_text = ""
+            header_style = ""
         else:
-            header = "[dim]No test output yet...[/dim]"
+            header_text = "No test output yet..."
+            header_style = "dim"
 
         if not self.output_content:
-            return header
+            return Text(header_text, style=header_style)
 
         available_lines = self._get_available_lines()
-        # Escape the output content to prevent Rich markup interpretation
-        # (test output may contain characters like ^ that have special meaning)
-        escaped_content = escape_markup(self.output_content)
-        lines = escaped_content.split("\n")
-
-        # Build prefix (header + newline, or empty if no header)
-        prefix = f"{header}\n" if header else ""
+        lines = self.output_content.split("\n")
 
         # Show tail of output (most recent lines)
-        if len(lines) <= available_lines:
-            return f"{prefix}{escaped_content}"
+        if len(lines) > available_lines:
+            truncated_lines = lines[-(available_lines):]
+            skipped = len(lines) - available_lines
+            content = f"... ({skipped} earlier lines)\n" + "\n".join(truncated_lines)
+        else:
+            content = self.output_content
 
-        # Truncate from the beginning
-        truncated_lines = lines[-(available_lines):]
-        skipped = len(lines) - available_lines
-        return f"{prefix}... ({skipped} earlier lines)\n" + "\n".join(truncated_lines)
+        # Build result with styled header and unstyled content
+        result = Text()
+        if header_text:
+            result.append(header_text, style=header_style)
+            result.append("\n")
+        result.append(content)
+        return result
 
 
 class HelpScreen(ModalScreen[None]):
@@ -734,21 +741,20 @@ class ExpandedBoxModal(ModalScreen[None]):
         self._content_widget_id = content_widget_id
         self._file_path = file_path
 
-    def _read_file(self, file_path: str) -> str:
+    def _read_file(self, file_path: str) -> Text:
         """Read file content, decoding as text if possible."""
         if not os.path.isfile(file_path):
-            return "[dim]File not found[/dim]"
+            return Text("File not found", style="dim")
         try:
             with open(file_path, "rb") as f:
                 raw_content = f.read()
             # Try to decode as text, fall back to hex display if binary
             encoding, text = try_decode(raw_content)
             if encoding is not None:
-                # Escape Rich markup to prevent interpretation of [ ] etc
-                return escape_markup(text)
-            return "[Binary content - hex display]\n\n" + raw_content.hex()
+                return Text(text)
+            return Text("Binary content - hex display\n\n" + raw_content.hex())
         except OSError:
-            return "[red]Error reading file[/red]"
+            return Text("Error reading file", style="red")
 
     def compose(self) -> ComposeResult:
         with Vertical():
@@ -781,16 +787,16 @@ class ExpandedBoxModal(ModalScreen[None]):
             return "Statistics not available"
         return stats_displays[0].render()
 
-    def _get_file_content(self, app: "ShrinkRayApp") -> str:
+    def _get_file_content(self, app: "ShrinkRayApp") -> str | Text:
         """Get content from file or preview widget."""
         if self._file_path:
             return self._read_file(self._file_path)
         content_previews = list(app.query("#content-preview").results(ContentPreview))
         if not content_previews:
             return "Content preview not available"
-        return content_previews[0].preview_content
+        return Text(content_previews[0].preview_content)
 
-    def _get_output_content(self, app: "ShrinkRayApp") -> str:
+    def _get_output_content(self, app: "ShrinkRayApp") -> str | Text:
         """Get output content from the output preview widget."""
         output_previews = list(app.query("#output-preview").results(OutputPreview))
         if not output_previews:
@@ -811,21 +817,29 @@ class ExpandedBoxModal(ModalScreen[None]):
         )
         has_seen_output = output_preview._has_seen_output
 
-        # Build header - return_code is None means test is still running
+        # Build header with styling
         if test_id is not None and return_code is None:
-            header = f"[green]Test #{test_id} running...[/green]\n\n"
+            header_text = f"Test #{test_id} running..."
+            header_style = "green"
         elif test_id is not None:
-            header = f"[dim]Test #{test_id} exited with code {return_code}[/dim]\n\n"
+            header_text = f"Test #{test_id} exited with code {return_code}"
+            header_style = "dim"
         else:
-            header = ""
+            header_text = ""
+            header_style = ""
 
         if raw_content:
-            return header + raw_content
+            result = Text()
+            if header_text:
+                result.append(header_text, style=header_style)
+                result.append("\n\n")
+            result.append(raw_content)
+            return result
         elif has_seen_output or test_id is not None:
             # We've seen output before - show header only (no "No test output" message)
-            return header.rstrip("\n") if header else ""
+            return Text(header_text, style=header_style)
         else:
-            return "[dim]No test output yet...[/dim]"
+            return Text("No test output yet...", style="dim")
 
     def on_mount(self) -> None:
         """Populate content from the source widget."""
@@ -1447,13 +1461,13 @@ class HistoryExplorerModal(ModalScreen[None]):
         if os.path.isfile(output_path):
             output_content = self._read_file(output_path)
         else:
-            output_content = "[dim]No output captured[/dim]"
+            output_content = Text("No output captured", style="dim")
         self.query_one(f"#{output_preview_id}", Static).update(output_content)
 
-    def _read_file(self, file_path: str) -> str:
+    def _read_file(self, file_path: str) -> Text:
         """Read file content, decoding as text if possible."""
         if not os.path.isfile(file_path):
-            return "[dim]File not found[/dim]"
+            return Text("File not found", style="dim")
         try:
             with open(file_path, "rb") as f:
                 raw_content = f.read()
@@ -1465,18 +1479,17 @@ class HistoryExplorerModal(ModalScreen[None]):
             # Try to decode as text
             encoding, text = try_decode(raw_content)
             if encoding is not None:
-                # Escape Rich markup to prevent interpretation of [ ] etc
-                text = escape_markup(text)
+                result = Text(text)
                 if truncated:
-                    text += "\n\n[dim]... (truncated)[/dim]"
-                return text
+                    result.append("\n\n... (truncated)", style="dim")
+                return result
             # Binary content - hex display
-            hex_display = "[Binary content - hex display]\n\n" + raw_content.hex()
+            result = Text("Binary content - hex display\n\n" + raw_content.hex())
             if truncated:
-                hex_display += "\n\n[dim]... (truncated)[/dim]"
-            return hex_display
+                result.append("\n\n... (truncated)", style="dim")
+            return result
         except OSError:
-            return "[red]Error reading file[/red]"
+            return Text("Error reading file", style="red")
 
     def action_restart_from_here(self) -> None:
         """Restart reduction from the currently selected history point."""
@@ -1925,11 +1938,14 @@ class ShrinkRayApp(App[None]):
 
     async def action_quit(self) -> None:
         """Quit the application with graceful cancellation."""
+        self.update_status("Shutting down...")
         if self._client and not self._completed:
             try:
-                await self._client.cancel()
+                await self._client.close()
             except Exception:
                 pass  # Process may have already exited
+            # Prevent double-close in run_reduction's finally block
+            self._client = None
         self.exit()
 
     def action_show_pass_stats(self) -> None:

{shrinkray-26.1.1.0 → shrinkray-26.2.4.1/src/shrinkray.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shrinkray
-Version: 26.1.1.0
+Version: 26.2.4.1
 Summary: Shrink Ray
 Author-email: "David R. MacIver" <david@drmaciver.com>
 License: MIT

{shrinkray-26.1.1.0 → shrinkray-26.2.4.1}/tests/test_subprocess_client.py

@@ -1120,3 +1120,123 @@ def test_subprocess_client_close_handles_stderr_log_file_exception():
         mock_file.close.assert_called_once()
 
     asyncio.run(run())
+
+
+def test_subprocess_client_close_cancels_pending_futures():
+    """Test close() cancels all pending futures so awaiting code is unblocked."""
+
+    async def run():
+        client = SubprocessClient()
+
+        # Create pending futures
+        loop = asyncio.get_event_loop()
+        future1: asyncio.Future[Response] = loop.create_future()
+        future2: asyncio.Future[Response] = loop.create_future()
+        client._pending_responses["req-1"] = future1
+        client._pending_responses["req-2"] = future2
+
+        await client.close()
+
+        # Both futures should be cancelled
+        assert future1.cancelled()
+        assert future2.cancelled()
+        # Pending responses should be cleared
+        assert len(client._pending_responses) == 0
+
+    asyncio.run(run())
+
+
+def test_subprocess_client_close_is_idempotent():
+    """Test close() is a no-op on second call due to _closed flag."""
+
+    async def run():
+        client = SubprocessClient()
+
+        # Create a pending future
+        loop = asyncio.get_event_loop()
+        future: asyncio.Future[Response] = loop.create_future()
+        client._pending_responses["req-1"] = future
+
+        await client.close()
+        assert future.cancelled()
+        assert client._closed
+
+        # Add another future after close (simulating a race)
+        future2: asyncio.Future[Response] = loop.create_future()
+        client._pending_responses["req-2"] = future2
+
+        # Second close should be a no-op
+        await client.close()
+
+        # The second future should NOT be cancelled (close was a no-op)
+        assert not future2.cancelled()
+
+    asyncio.run(run())
+
+
+def test_subprocess_client_close_awaits_wait_after_process_exit():
+    """Test close() always awaits process.wait() after process exits."""
+
+    async def run():
+        client = SubprocessClient()
+
+        # Create a mock process that has already exited
+        mock_process = MagicMock()
+        mock_process.returncode = 0  # Already exited
+        mock_process.stdin = MagicMock()
+        mock_process.stdin.close = MagicMock()
+
+        wait_called = [False]
+
+        async def mock_wait():
+            wait_called[0] = True
+
+        mock_process.wait = mock_wait
+        client._process = mock_process
+        client._reader_task = None
+
+        await client.close()
+
+        # wait() should have been called even though process already exited
+        assert wait_called[0]
+
+    asyncio.run(run())
+
+
+def test_subprocess_client_close_skips_done_futures():
+    """Test close() skips already-done futures when cancelling."""
+
+    async def run():
+        client = SubprocessClient()
+
+        # Create one done and one pending future
+        loop = asyncio.get_event_loop()
+        done_future: asyncio.Future[Response] = loop.create_future()
+        done_future.set_result(Response(id="done", result={"status": "ok"}))
+        pending_future: asyncio.Future[Response] = loop.create_future()
+
+        client._pending_responses["done"] = done_future
+        client._pending_responses["pending"] = pending_future
+
+        await client.close()
+
+        # Done future should still have its result (not cancelled)
+        assert not done_future.cancelled()
+        assert done_future.result().result == {"status": "ok"}
+        # Pending future should be cancelled
+        assert pending_future.cancelled()
+
+    asyncio.run(run())
+
+
+def test_subprocess_client_close_handles_stderr_log_unlink_exception():
+    """Test close() handles exception when unlinking stderr log file."""
+
+    async def run():
+        client = SubprocessClient()
+        client._stderr_log_path = "/nonexistent/path/that/will/fail"
+
+        # Should not raise even if unlink fails
+        await client.close()
+
+    asyncio.run(run())

{shrinkray-26.1.1.0 → shrinkray-26.2.4.1}/tests/test_tui.py

@@ -9,6 +9,7 @@ from collections.abc import AsyncGenerator
 from unittest.mock import AsyncMock, MagicMock, Mock, PropertyMock, patch
 
 import pytest
+from rich.text import Text
 from textual.app import App
 from textual.widgets import DataTable, Label, ListView, Static, TabbedContent
 
@@ -112,6 +113,7 @@ class FakeReductionClient:
 
     async def close(self) -> None:
         self._closed = True
+        self._cancelled = True
 
     async def get_progress_updates(self) -> AsyncGenerator[ProgressUpdate, None]:
         for update in self._updates:
@@ -715,6 +717,40 @@ def test_output_preview_get_available_lines_app_zero_height():
         assert lines == 30
 
 
+def test_output_preview_render_returns_text():
+    """Test that OutputPreview.render() returns a Text object, not a markup string.
+
+    Returning a Text object ensures Textual never parses user content as markup.
+    Previously, render() returned a markup string and used Rich's escape() which
+    failed on patterns like [key=; causing MarkupError.
+
+    This fixes the crash from: shrinkray --parallelism 60 interest2.sh bf_simple_yk.c
+    """
+    widget = OutputPreview()
+    # Content that would crash if parsed as markup
+    widget.output_content = "some output\n[key=;value"
+    widget.active_test_id = 1
+
+    rendered = widget.render()
+    assert isinstance(rendered, Text)
+    assert "[key=;value" in rendered
+
+
+def test_content_preview_render_returns_text():
+    """Test that ContentPreview.render() returns a Text object, not a markup string.
+
+    Returning a Text object ensures Textual never parses user content as markup.
+    Previously, render() returned raw strings that would crash on patterns like
+    [Key=; when Textual parsed them as markup.
+    """
+    widget = ContentPreview()
+    widget.update_content("[Key=;value", False)
+
+    rendered = widget.render()
+    assert isinstance(rendered, Text)
+    assert "[Key=;value" in rendered
+
+
 # === ShrinkRayApp with fake client tests ===
 
 
@@ -1303,21 +1339,22 @@ def test_expanded_modal_read_file_success(tmp_path):
 
     modal = ExpandedBoxModal("Test", "content-container")
     content = modal._read_file(str(test_file))
-    assert content == "Hello World"
+    assert isinstance(content, Text)
+    assert content.plain == "Hello World"
 
 
-def test_expanded_modal_read_file_escapes_markup(tmp_path):
-    """Test _read_file escapes Rich markup characters like [."""
+def test_expanded_modal_read_file_preserves_brackets(tmp_path):
+    """Test _read_file preserves bracket characters in file content."""
     test_file = tmp_path / "test.txt"
     # Content with brackets that could be interpreted as Rich markup
     test_file.write_text("expected [bold] and [red]text[/red]")
 
     modal = ExpandedBoxModal("Test", "content-container")
     content = modal._read_file(str(test_file))
-    # Opening brackets should be escaped to prevent Rich interpretation
-    # Rich's escape() converts [ to \[ when followed by tag-like content
-    assert "[bold]" not in content or "\\[bold]" in content
-    assert "[red]" not in content or "\\[red]" in content
+    # Returns a Text object so brackets are preserved literally
+    assert isinstance(content, Text)
+    assert "[bold]" in content.plain
+    assert "[red]text[/red]" in content.plain
 
 
 def test_expanded_modal_read_file_binary(tmp_path):
@@ -1328,26 +1365,29 @@ def test_expanded_modal_read_file_binary(tmp_path):
 
     modal = ExpandedBoxModal("Test", "content-container")
     content = modal._read_file(str(test_file))
+    assert isinstance(content, Text)
     assert "Binary content" in content
     assert "80818283" in content
 
 
 def test_expanded_modal_read_file_missing(tmp_path):
-    """Test _read_file returns error message for missing file."""
+    """Test _read_file returns styled message for missing file."""
     modal = ExpandedBoxModal("Test", "content-container")
     result = modal._read_file(str(tmp_path / "nonexistent.txt"))
-    assert "[dim]File not found[/dim]" in result
+    assert isinstance(result, Text)
+    assert "File not found" in result
 
 
 def test_expanded_modal_read_file_oserror(tmp_path):
-    """Test _read_file returns error message on OSError."""
+    """Test _read_file returns styled message on OSError."""
     modal = ExpandedBoxModal("Test", "content-container")
     # Create a file that exists but can't be read
     test_file = tmp_path / "unreadable.txt"
     test_file.write_text("content")
     with patch("builtins.open", side_effect=OSError("Permission denied")):
         result = modal._read_file(str(test_file))
-    assert "[red]Error reading file[/red]" in result
+    assert isinstance(result, Text)
+    assert "Error reading file" in result
 
 
 # === ExpandedBoxModal integration tests ===
@@ -5367,11 +5407,60 @@ def test_expanded_modal_output_with_empty_content_and_header():
     asyncio.run(run())
 
 
+def test_expanded_modal_output_content_without_test_id():
+    """Test output modal with content but no test ID (no header)."""
+
+    async def run():
+        fake_client = FakeReductionClient(updates=[], wait_indefinitely=True)
+
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=False) as f:
+            f.write("test")
+            temp_file = f.name
+
+        try:
+            app = ShrinkRayApp(
+                file_path=temp_file,
+                test=["true"],
+                exit_on_completion=False,
+                client=fake_client,
+            )
+
+            async with app.run_test() as pilot:
+                await pilot.pause()
+
+                # Set output preview with content but no test ID
+                output_preview = app.query_one("#output-preview", OutputPreview)
+                output_preview.active_test_id = None
+                output_preview._has_seen_output = True
+                output_preview.output_content = "some raw output"
+                output_preview._pending_content = "some raw output"
+                output_preview._pending_test_id = None
+
+                # Create modal for output-container
+                modal = ExpandedBoxModal("Output", "output-container", None)
+                await app.push_screen(modal)
+                await pilot.pause()
+
+                # Should show content without header
+                content = modal.query_one("#expanded-content", Static)
+                content_str = get_static_content(content)
+                assert "some raw output" in content_str
+                assert "Test #" not in content_str
+
+                await pilot.press("escape")
+                await pilot.press("q")
+        finally:
+            if os.path.exists(temp_file):
+                os.unlink(temp_file)
+
+    asyncio.run(run())
+
+
 # === Action method tests ===
 
 
 def test_action_quit_with_client():
-    """Test action_quit cancels client before exiting."""
+    """Test action_quit closes client directly before exiting."""
 
     async def run():
         fake_client = FakeReductionClient(updates=[], wait_indefinitely=True)
@@ -5395,8 +5484,10 @@ def test_action_quit_with_client():
                 await pilot.press("q")
                 await pilot.pause()
 
-                # Client should have been cancelled
-                assert fake_client._cancelled
+                # Client should have been closed directly (not just cancelled)
+                assert fake_client._closed
+                # Client reference should be cleared to prevent double-close
+                assert app._client is None
         finally:
             if os.path.exists(temp_file):
                 os.unlink(temp_file)
@@ -5405,16 +5496,16 @@ def test_action_quit_with_client():
 
 
 def test_action_quit_handles_exception():
-    """Test action_quit handles exception from cancel gracefully."""
+    """Test action_quit handles exception from close gracefully."""
 
     async def run():
         fake_client = FakeReductionClient(updates=[], wait_indefinitely=True)
 
-        # Make cancel raise an exception
+        # Make close raise an exception
         async def raise_exception():
             raise RuntimeError("Process already exited")
 
-        fake_client.cancel = raise_exception
+        fake_client.close = raise_exception
 
         with tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=False) as f:
             f.write("test")
@@ -6125,11 +6216,12 @@ def test_history_modal_read_file_success(tmp_path):
     modal = HistoryExplorerModal(str(tmp_path), "test.txt")
     content = modal._read_file(str(test_file))
 
-    assert content == "Hello World\nLine 2"
+    assert isinstance(content, Text)
+    assert content.plain == "Hello World\nLine 2"
 
 
-def test_history_modal_read_file_escapes_markup(tmp_path):
-    """Test _read_file escapes Rich markup characters like [."""
+def test_history_modal_read_file_preserves_brackets(tmp_path):
+    """Test _read_file preserves bracket characters in file content."""
     test_file = tmp_path / "test.txt"
     # Content with brackets that look like Rich markup tags
     test_file.write_text("error: [bold]text[/bold] failed")
@@ -6137,9 +6229,9 @@ def test_history_modal_read_file_escapes_markup(tmp_path):
     modal = HistoryExplorerModal(str(tmp_path), "test.txt")
     content = modal._read_file(str(test_file))
 
-    # Opening brackets should be escaped to prevent Rich interpretation
-    assert "[bold]" not in content or "\\[bold]" in content
-    # The original text should not be corrupted
+    # Returns a Text object so brackets are preserved literally
+    assert isinstance(content, Text)
+    assert "[bold]" in content.plain
     assert "error:" in content
     assert "failed" in content
 
@@ -6153,15 +6245,17 @@ def test_history_modal_read_file_binary(tmp_path):
     content = modal._read_file(str(test_file))
 
     # Should fall back to hex display
+    assert isinstance(content, Text)
     assert "Binary content" in content
 
 
 def test_history_modal_read_file_missing(tmp_path):
-    """Test _read_file returns error message for missing file."""
+    """Test _read_file returns styled message for missing file."""
     modal = HistoryExplorerModal(str(tmp_path), "test.txt")
     content = modal._read_file(str(tmp_path / "nonexistent.txt"))
 
-    assert "[dim]File not found[/dim]" in content
+    assert isinstance(content, Text)
+    assert "File not found" in content
 
 
 def test_history_modal_read_file_truncated_text(tmp_path):
@@ -6174,9 +6268,10 @@ def test_history_modal_read_file_truncated_text(tmp_path):
     content = modal._read_file(str(test_file))
 
     # Should be truncated
-    assert "[dim]... (truncated)[/dim]" in content
-    # Content should be limited
-    assert len(content) < 60000
+    assert isinstance(content, Text)
+    assert "truncated" in content
+    # Content should be limited (50000 chars + truncation message)
+    assert len(content.plain) < 60000
 
 
 def test_history_modal_read_file_truncated_binary(tmp_path):
@@ -6189,8 +6284,9 @@ def test_history_modal_read_file_truncated_binary(tmp_path):
     content = modal._read_file(str(test_file))
 
     # Should be truncated and shown as binary
-    assert "[Binary content" in content
-    assert "[dim]... (truncated)[/dim]" in content
+    assert isinstance(content, Text)
+    assert "Binary content" in content
+    assert "truncated" in content
 
 
 def test_history_modal_read_file_oserror(tmp_path):
@@ -6204,7 +6300,8 @@ def test_history_modal_read_file_oserror(tmp_path):
     with patch("builtins.open", side_effect=OSError("Permission denied")):
         content = modal._read_file(str(test_file))
 
-    assert "[red]Error reading file[/red]" in content
+    assert isinstance(content, Text)
+    assert "Error reading file" in content
 
 
 def test_history_modal_on_list_view_highlighted_no_entries(tmp_path):