diff --git a/clients/terminal/tui/renderers/__init__.py b/clients/terminal/tui/renderers/__init__.py
index f0acc07..cf33a5d 100644
--- a/clients/terminal/tui/renderers/__init__.py
+++ b/clients/terminal/tui/renderers/__init__.py
@@ -4,7 +4,7 @@
 
 from .base import ContentRenderer
 from .registry import RendererRegistry
-from . import message, tool, thinking, error, markdown_content, plain, diff, artifact, status, planning, subagent, todo, turn_meta, summary
+from . import message, tool, thinking, error, markdown_content, plain, diff, artifact, status, planning, subagent, todo, turn_meta, summary, filesystem
 
 
 def default_registry() -> RendererRegistry:
@@ -19,6 +19,9 @@
     reg.register(todo.TodoStartedRenderer())
     reg.register(todo.TodoResultRenderer())
     reg.register(tool.ToolStartedRenderer())
+    # filesystem-specific result renderer must be checked before the generic
+    # ToolResultRenderer (first accepting renderer wins).
+    reg.register(filesystem.FilesystemToolResultRenderer())
     reg.register(tool.ToolResultRenderer())
     reg.register(error.ErrorRenderer())
     reg.register(status.StatusRenderer())
diff --git a/clients/terminal/tui/renderers/diff.py b/clients/terminal/tui/renderers/diff.py
index 7f99592..1935c67 100644
--- a/clients/terminal/tui/renderers/diff.py
+++ b/clients/terminal/tui/renderers/diff.py
@@ -6,11 +6,33 @@
 from rich.panel import Panel
 from rich.text import Text
 
-from clients.terminal.tui.themes import get_active_theme
+from clients.terminal.tui.themes import Theme, get_active_theme
 
 from .base import ContentRenderer
 
 
+def highlight_unified_diff(text: str, theme: Theme) -> Text:
+    """Color a unified-diff string: ``+`` green, ``-`` red, ``@@`` dim, rest text.
+
+    Shared by the standalone ``diff`` event renderer and the ``filesystem``
+    tool-call renderer (``edit_lines`` / ``smart_edit`` / ``diff`` actions embed
+    a unified diff as plain text in ``ToolResult.output``).
+    """
+    out = Text()
+    for idx, line in enumerate(text.splitlines()):
+        if idx:
+            out.append("\n")
+        if line.startswith("+") and not line.startswith("+++"):
+            out.append(line, style=theme.success.hex)
+        elif line.startswith("-") and not line.startswith("---"):
+            out.append(line, style=theme.error.hex)
+        elif line.startswith("@@"):
+            out.append(line, style=theme.text_dim.hex)
+        else:
+            out.append(line, style=theme.text.hex)
+    return out
+
+
 class DiffRenderer(ContentRenderer):
     """Render a unified diff with added/removed line highlighting."""
 
@@ -23,23 +45,11 @@
         old_label = msg.get("old_label", "---")
         new_label = msg.get("new_label", "+++")
 
-        lines = content.splitlines()
-        highlighted = Text()
-        for idx, line in enumerate(lines):
-            if idx:
-                highlighted.append("\n")
-            if line.startswith("+") and not line.startswith("+++"):
-                highlighted.append(line, style=theme.success.hex)
-            elif line.startswith("-") and not line.startswith("---"):
-                highlighted.append(line, style=theme.error.hex)
-            elif line.startswith("@@"):
-                highlighted.append(line, style=theme.text_dim.hex)
-            else:
-                highlighted.append(line, style=theme.text.hex)
+        highlighted = highlight_unified_diff(content, theme)
 
         return Panel(
             highlighted,
             title=f"diff: {old_label} → {new_label}",
             title_align="left",
             border_style=theme.border.hex,
-        )
+        )
\ No newline at end of file
diff --git a/clients/terminal/tui/renderers/filesystem.py b/clients/terminal/tui/renderers/filesystem.py
new file mode 100644
index 0000000..9b92031
--- /dev/null
+++ b/clients/terminal/tui/renderers/filesystem.py
@@ -0,0 +1,208 @@
+"""Styled renderer for ``filesystem`` tool-call results.
+
+The filesystem tool embeds structured output (unified diffs, directory listings,
+grep matches) as plain text in ``ToolResult.output``. This renderer detects the
+action via ``args.action`` and restyles the output — diff highlighting, listing
+layout, grep match highlighting — without touching the tool or the WebSocket
+protocol. Unknown / not-yet-styled actions fall back to the generic plain
+rendering used by :class:`ToolResultRenderer`.
+"""
+
+from __future__ import annotations
+
+import re
+
+from rich.box import ROUNDED
+from rich.console import RenderableType, Group
+from rich.padding import Padding
+from rich.panel import Panel
+from rich.text import Text
+
+from clients.terminal.tui.themes import Theme, get_active_theme
+
+from .base import ContentRenderer
+from .diff import highlight_unified_diff
+
+# Actions whose output embeds a unified diff (edit_lines / smart_edit prepend an
+# "Applied …" summary line; diff is the raw unified diff).
+_DIFF_ACTIONS = {"diff", "edit_lines", "smart_edit"}
+
+# List entry prefixes emitted by filesystem._list.
+_LIST_DIR_RE = re.compile(r"^d\s+(?P<name>.+?)/\s*(?:\((?P<n>\d+) items\))?\s*$")
+_LIST_FILE_RE = re.compile(r"^\s{3}(?P<name>.+?)\s{2,}(?P<size>\S+)\s{2,}(?P<time>.+)$")
+_LIST_UNKNOWN_RE = re.compile(r"^\?\s+(?P<name>.+)$")
+_TRUNCATED_MARKER = "⚠"
+
+# Grep match line: ``rel:line: text``.
+_GREP_MATCH_RE = re.compile(r"^(?P<loc>.+?:\d+): (?P<text>.*)$")
+
+
+class FilesystemToolResultRenderer(ContentRenderer):
+    """Styled output for ``filesystem`` tool-call results (diff / list / grep).
+
+    Sub-agent results are indented to read as nested inside the parent
+    ``spawn_agent`` card, matching :class:`ToolResultRenderer`.
+    """
+
+    def accepts(self, msg: dict) -> bool:
+        return msg.get("type") == "tool_call" and msg.get("tool") == "filesystem"
+
+    def render(self, msg: dict) -> RenderableType:
+        theme = get_active_theme()
+        success = msg.get("success", True)
+        result = msg.get("result")
+        text = str(result) if result is not None else ""
+        args = msg.get("args") or {}
+        action = args.get("action")
+
+        body = self._render_body(text, action, args, success, theme)
+        color = theme.tool_success if success else theme.tool_error
+        panel = Panel(
+            body,
+            title=f"← filesystem {'✓' if success else '✗'}",
+            title_align="left",
+            border_style=color.hex,
+            box=ROUNDED,
+        )
+        if bool(msg.get("is_subagent", False)):
+            return Padding(panel, (0, 0, 0, 2))
+        return panel
+
+    # ── dispatch ───────────────────────────────────────────────────────────
+
+    def _render_body(
+        self, text: str, action: str | None, args: dict, success: bool, theme: Theme
+    ) -> RenderableType:
+        if not success:
+            # Errors carry a human-readable message; do not attempt to parse.
+            return Text(text, style=theme.tool_error.hex)
+
+        if action in _DIFF_ACTIONS:
+            return self._render_diff(text, action, theme)
+        if action == "list":
+            return self._render_list(text, theme)
+        if action == "grep":
+            return self._render_grep(text, args, theme)
+        # read / info / write / edit / append / move / copy / delete / mkdir /
+        # exists / find / find_up / query / unknown → plain, unchanged for now.
+        return Text(text, style=theme.text_dim.hex)
+
+    # ── diff ───────────────────────────────────────────────────────────────
+
+    def _render_diff(self, text: str, action: str | None, theme: Theme) -> RenderableType:
+        if action == "diff":
+            if text == "Files are identical.":
+                return Text(text, style=theme.text_dim.hex)
+            return highlight_unified_diff(text, theme)
+
+        # edit_lines / smart_edit: "Applied …" summary, blank line, then diff.
+        summary, _, diff = text.partition("\n\n")
+        if not diff:
+            # No diff body (e.g. edit_lines with no net line change) — just summary.
+            return Text(summary, style=theme.text_dim.hex)
+        return Group(
+            Text(summary, style=theme.text_dim.hex),
+            Text(""),
+            highlight_unified_diff(diff, theme),
+        )
+
+    # ── list ───────────────────────────────────────────────────────────────
+
+    def _render_list(self, text: str, theme: Theme) -> RenderableType:
+        lines = text.splitlines()
+        if not lines:
+            return Text(text, style=theme.text_dim.hex)
+
+        header_line = lines[0]
+        rest = lines[1:]
+        out = Text()
+        # Header plaque: "[path  |  N entries  ⚠ truncated]" → dim, warning if truncated.
+        header_style = (
+            theme.warning.hex if _TRUNCATED_MARKER in header_line else theme.text_dim.hex
+        )
+        out.append(header_line, style=header_style)
+
+        for line in rest:
+            out.append("\n")
+            if line == "(empty directory)":
+                out.append(line, style=theme.text_dim.hex)
+                continue
+            m = _LIST_DIR_RE.match(line)
+            if m:
+                name = m.group("name")
+                n = m.group("n")
+                out.append("▸ ", style=theme.info.hex)
+                out.append(f"{name}/", style=theme.info.hex)
+                if n:
+                    out.append(f"  ({n} items)", style=theme.text_dim.hex)
+                continue
+            m = _LIST_FILE_RE.match(line)
+            if m:
+                out.append(m.group("name").rstrip(), style=theme.text.hex)
+                out.append("  " + m.group("size"), style=theme.accent.hex)
+                out.append("  " + m.group("time"), style=theme.text_dim.hex)
+                continue
+            m = _LIST_UNKNOWN_RE.match(line)
+            if m:
+                out.append("? " + m.group("name"), style=theme.warning.hex)
+                continue
+            # Unrecognized line — render verbatim.
+            out.append(line, style=theme.text_dim.hex)
+        return out
+
+    # ── grep ───────────────────────────────────────────────────────────────
+
+    def _render_grep(self, text: str, args: dict, theme: Theme) -> RenderableType:
+        lines = text.splitlines()
+        if not lines:
+            return Text(text, style=theme.text_dim.hex)
+
+        pattern = str(args.get("pattern", "") or "")
+        # Pre-compile a case-insensitive literal match for highlighting.
+        highlight = None
+        if pattern:
+            try:
+                highlight = re.compile(re.escape(pattern), re.IGNORECASE)
+            except re.error:
+                highlight = None
+
+        out = Text()
+        for idx, line in enumerate(lines):
+            if idx:
+                out.append("\n")
+            if idx == 0 and line.startswith("["):
+                # Header plaque "[N matches for '…' in … (M files searched) ⚠ …]".
+                style = (
+                    theme.warning.hex
+                    if _TRUNCATED_MARKER in line
+                    else theme.text_dim.hex
+                )
+                out.append(line, style=style)
+                continue
+            if line.startswith("No matches for "):
+                out.append(line, style=theme.text_dim.hex)
+                continue
+            m = _GREP_MATCH_RE.match(line)
+            if m:
+                out.append(m.group("loc") + ":", style=theme.text_dim.hex)
+                out.append(" ")
+                self._append_with_highlight(out, m.group("text"), highlight, theme)
+                continue
+            out.append(line, style=theme.text_dim.hex)
+        return out
+
+    @staticmethod
+    def _append_with_highlight(
+        out: Text, text: str, highlight: re.Pattern | None, theme: Theme
+    ) -> None:
+        if highlight is None:
+            out.append(text, style=theme.text.hex)
+            return
+        last = 0
+        for m in highlight.finditer(text):
+            if m.start() > last:
+                out.append(text[last:m.start()], style=theme.text.hex)
+            out.append(m.group(0), style=theme.accent.hex)
+            last = m.end()
+        if last < len(text):
+            out.append(text[last:], style=theme.text.hex)
\ No newline at end of file
diff --git a/tests/clients/test_filesystem_renderer.py b/tests/clients/test_filesystem_renderer.py
new file mode 100644
index 0000000..8ad67c7
--- /dev/null
+++ b/tests/clients/test_filesystem_renderer.py
@@ -0,0 +1,360 @@
+"""Tests for the filesystem tool-call result renderer (diff / list / grep)."""
+
+from __future__ import annotations
+
+from rich.console import Console
+from rich.text import Text
+
+from clients.terminal.tui.renderers.filesystem import FilesystemToolResultRenderer
+from clients.terminal.tui.themes import get_active_theme, set_active_theme
+
+
+def _render_text(renderable) -> str:
+    console = Console(record=True, width=100, force_terminal=True, color_system=None)
+    console.print(renderable)
+    return console.export_text()
+
+
+def _body(panel_or_renderable):
+    """Unwrap a Panel to its inner renderable (Text or Group)."""
+    r = panel_or_renderable
+    if hasattr(r, "renderable") and not isinstance(r, Text):
+        r = r.renderable
+    return r
+
+
+def _span_styles_at(text: Text, substring: str) -> set[str]:
+    """Return the styles that cover the first occurrence of ``substring``.
+
+    Covers both explicit ``Text.spans`` (from ``.append(…, style=)``) and the
+    ``Text.style`` default (from ``Text(str, style=…)``), which does not create
+    a span.
+    """
+    styles: set[str] = set()
+    idx = text.plain.find(substring)
+    if idx < 0:
+        return styles
+    start, end = idx, idx + len(substring)
+    covered = False
+    for span in text.spans:
+        if span.start < end and span.end > start:
+            styles.add(span.style)
+            covered = True
+    if not covered and text.style:
+        styles.add(text.style)
+    return styles
+
+
+# ── accepts ──────────────────────────────────────────────────────────────────
+
+
+def test_accepts_filesystem_tool_call() -> None:
+    set_active_theme("gnexus-dark")
+    renderer = FilesystemToolResultRenderer()
+    assert renderer.accepts({"type": "tool_call", "tool": "filesystem", "args": {}})
+
+
+def test_does_not_accept_other_tools() -> None:
+    renderer = FilesystemToolResultRenderer()
+    assert not renderer.accepts({"type": "tool_call", "tool": "code_exec", "args": {}})
+
+
+def test_does_not_accept_non_tool_call() -> None:
+    renderer = FilesystemToolResultRenderer()
+    assert not renderer.accepts({"type": "tool_started", "tool": "filesystem", "args": {}})
+    assert not renderer.accepts({"type": "diff", "content": ""})
+
+
+# ── diff ──────────────────────────────────────────────────────────────────────
+
+
+def test_diff_action_highlights_added_and_removed() -> None:
+    set_active_theme("gnexus-dark")
+    theme = get_active_theme()
+    renderer = FilesystemToolResultRenderer()
+    msg = {
+        "type": "tool_call",
+        "tool": "filesystem",
+        "args": {"action": "diff"},
+        "result": "--- a.py\n+++ b.py\n@@ -1,2 +1,2 @@\n-old\n+new\n unchanged\n",
+        "success": True,
+    }
+    body = _body(renderer.render(msg))
+    assert isinstance(body, Text)
+    assert _span_styles_at(body, "+new") == {theme.success.hex}
+    assert _span_styles_at(body, "-old") == {theme.error.hex}
+    assert theme.text_dim.hex in _span_styles_at(body, "@@ -1,2 +1,2 @@")
+
+
+def test_diff_identical_renders_plain_dim() -> None:
+    set_active_theme("gnexus-dark")
+    theme = get_active_theme()
+    renderer = FilesystemToolResultRenderer()
+    msg = {
+        "type": "tool_call",
+        "tool": "filesystem",
+        "args": {"action": "diff"},
+        "result": "Files are identical.",
+        "success": True,
+    }
+    body = _body(renderer.render(msg))
+    assert isinstance(body, Text)
+    assert body.plain == "Files are identical."
+    assert _span_styles_at(body, "Files are identical.") == {theme.text_dim.hex}
+
+
+def test_edit_lines_separates_summary_and_diff() -> None:
+    set_active_theme("gnexus-dark")
+    theme = get_active_theme()
+    renderer = FilesystemToolResultRenderer()
+    msg = {
+        "type": "tool_call",
+        "tool": "filesystem",
+        "args": {"action": "edit_lines"},
+        "result": (
+            "Applied 2 operation(s) to a.py (3 → 5 lines).\n\n"
+            "--- a.py\n+++ b.py\n@@ -1,1 +1,1 @@\n-x\n+y\n"
+        ),
+        "success": True,
+    }
+    body = _body(renderer.render(msg))
+    # Group(summary, blank, diff)
+    renderables = body.renderables
+    summary = renderables[0]
+    diff = renderables[2]
+    assert isinstance(summary, Text)
+    assert "Applied 2 operation(s) to a.py" in summary.plain
+    assert _span_styles_at(summary, "Applied 2 operation(s) to a.py") == {theme.text_dim.hex}
+    assert isinstance(diff, Text)
+    assert _span_styles_at(diff, "+y") == {theme.success.hex}
+    assert _span_styles_at(diff, "-x") == {theme.error.hex}
+
+
+def test_edit_lines_without_diff_body_shows_summary_only() -> None:
+    set_active_theme("gnexus-dark")
+    renderer = FilesystemToolResultRenderer()
+    msg = {
+        "type": "tool_call",
+        "tool": "filesystem",
+        "args": {"action": "edit_lines"},
+        "result": "Applied 1 operation(s) to a.py (3 → 3 lines).",
+        "success": True,
+    }
+    body = _body(renderer.render(msg))
+    assert isinstance(body, Text)
+    assert body.plain.startswith("Applied 1 operation(s)")
+
+
+def test_diff_error_renders_plain_error_color() -> None:
+    set_active_theme("gnexus-dark")
+    theme = get_active_theme()
+    renderer = FilesystemToolResultRenderer()
+    msg = {
+        "type": "tool_call",
+        "tool": "filesystem",
+        "args": {"action": "diff"},
+        "result": "'destination' is required for diff (path to second file)",
+        "success": False,
+    }
+    body = _body(renderer.render(msg))
+    assert isinstance(body, Text)
+    assert _span_styles_at(body, "destination") == {theme.tool_error.hex}
+
+
+# ── list ──────────────────────────────────────────────────────────────────────
+
+
+def test_list_highlights_directories_and_files() -> None:
+    set_active_theme("gnexus-dark")
+    theme = get_active_theme()
+    renderer = FilesystemToolResultRenderer()
+    msg = {
+        "type": "tool_call",
+        "tool": "filesystem",
+        "args": {"action": "list"},
+        "result": (
+            "[/proj  |  2 entries]\n"
+            "d  src/  (12 items)\n"
+            "   main.py                                       1.2K  2026-07-12 14:30\n"
+        ),
+        "success": True,
+    }
+    body = _body(renderer.render(msg))
+    assert isinstance(body, Text)
+    # Header plaque is dim.
+    assert theme.text_dim.hex in _span_styles_at(body, "/proj")
+    # Directory name in info color.
+    assert theme.info.hex in _span_styles_at(body, "src/")
+    # File name in text color, size in accent.
+    assert theme.text.hex in _span_styles_at(body, "main.py")
+    assert theme.accent.hex in _span_styles_at(body, "1.2K")
+    # Directory entry carries the ▸ icon.
+    assert "▸" in body.plain
+    assert "(12 items)" in body.plain
+
+
+def test_list_truncated_header_uses_warning_color() -> None:
+    set_active_theme("gnexus-dark")
+    theme = get_active_theme()
+    renderer = FilesystemToolResultRenderer()
+    msg = {
+        "type": "tool_call",
+        "tool": "filesystem",
+        "args": {"action": "list"},
+        "result": "[/proj  |  500 entries  ⚠ truncated]\n   a.py                                         0B  2026-07-12 00:00\n",
+        "success": True,
+    }
+    body = _body(renderer.render(msg))
+    assert isinstance(body, Text)
+    assert theme.warning.hex in _span_styles_at(body, "truncated")
+
+
+# ── grep ──────────────────────────────────────────────────────────────────────
+
+
+def test_grep_highlights_pattern_and_dims_location() -> None:
+    set_active_theme("gnexus-dark")
+    theme = get_active_theme()
+    renderer = FilesystemToolResultRenderer()
+    msg = {
+        "type": "tool_call",
+        "tool": "filesystem",
+        "args": {"action": "grep", "pattern": "foo"},
+        "result": (
+            "[3 matches for 'foo' in /proj (5 files searched)]\n"
+            "src/a.py:3: foo bar\n"
+            "src/b.py:7: foobar\n",
+        ),
+        "success": True,
+    }
+    body = _body(renderer.render(msg))
+    assert isinstance(body, Text)
+    # Header is dim.
+    assert theme.text_dim.hex in _span_styles_at(body, "3 matches")
+    # Location prefix is dim.
+    assert theme.text_dim.hex in _span_styles_at(body, "src/a.py:3:")
+    # Matched pattern occurrence on the match line is in accent. Check "foo bar"
+    # (the match line) rather than "foo" alone — "foo" first appears in the dim
+    # header plaque "[3 matches for 'foo' in …]".
+    styles_foo_bar = _span_styles_at(body, "foo bar")
+    assert theme.accent.hex in styles_foo_bar
+
+
+def test_grep_no_matches_renders_dim() -> None:
+    set_active_theme("gnexus-dark")
+    theme = get_active_theme()
+    renderer = FilesystemToolResultRenderer()
+    msg = {
+        "type": "tool_call",
+        "tool": "filesystem",
+        "args": {"action": "grep", "pattern": "foo"},
+        "result": "No matches for 'foo' in /proj",
+        "success": True,
+    }
+    body = _body(renderer.render(msg))
+    assert isinstance(body, Text)
+    assert _span_styles_at(body, "No matches") == {theme.text_dim.hex}
+
+
+def test_grep_without_pattern_arg_does_not_crash() -> None:
+    set_active_theme("gnexus-dark")
+    renderer = FilesystemToolResultRenderer()
+    msg = {
+        "type": "tool_call",
+        "tool": "filesystem",
+        "args": {"action": "grep"},
+        "result": "[1 matches for 'x' in /proj (1 files searched)]\na.py:1: x y\n",
+        "success": True,
+    }
+    body = _body(renderer.render(msg))
+    assert "a.py:1: x y" in body.plain
+
+
+# ── fallback ──────────────────────────────────────────────────────────────────
+
+
+def test_read_action_falls_back_to_plain_dim() -> None:
+    set_active_theme("gnexus-dark")
+    theme = get_active_theme()
+    renderer = FilesystemToolResultRenderer()
+    msg = {
+        "type": "tool_call",
+        "tool": "filesystem",
+        "args": {"action": "read"},
+        "result": "[main.py  |  10 lines  |  256B]\nprint('hi')\n",
+        "success": True,
+    }
+    body = _body(renderer.render(msg))
+    assert isinstance(body, Text)
+    assert "print('hi')" in body.plain
+    # Whole body is dim (no per-part highlighting for read yet).
+    assert _span_styles_at(body, "print('hi')") == {theme.text_dim.hex}
+
+
+def test_unknown_action_falls_back_to_plain() -> None:
+    set_active_theme("gnexus-dark")
+    renderer = FilesystemToolResultRenderer()
+    msg = {
+        "type": "tool_call",
+        "tool": "filesystem",
+        "args": {"action": "query"},
+        "result": "some natural-language answer",
+        "success": True,
+    }
+    body = _body(renderer.render(msg))
+    assert isinstance(body, Text)
+    assert body.plain == "some natural-language answer"
+
+
+def test_missing_args_treats_action_as_unknown() -> None:
+    set_active_theme("gnexus-dark")
+    renderer = FilesystemToolResultRenderer()
+    msg = {
+        "type": "tool_call",
+        "tool": "filesystem",
+        "result": "raw output",
+        "success": True,
+    }
+    body = _body(renderer.render(msg))
+    assert isinstance(body, Text)
+    assert body.plain == "raw output"
+
+
+# ── subagent + title ──────────────────────────────────────────────────────────
+
+
+def test_panel_title_carries_status() -> None:
+    set_active_theme("gnexus-dark")
+    renderer = FilesystemToolResultRenderer()
+    ok = renderer.render(
+        {"type": "tool_call", "tool": "filesystem", "args": {"action": "list"},
+         "result": "[/p  |  0 entries]\n(empty directory)", "success": True}
+    )
+    assert "← filesystem" in str(ok.title)
+    assert "✓" in str(ok.title)
+
+    err = renderer.render(
+        {"type": "tool_call", "tool": "filesystem", "args": {"action": "list"},
+         "result": "Path not found: /p", "success": False}
+    )
+    assert "✗" in str(err.title)
+
+
+def test_subagent_result_is_indented() -> None:
+    set_active_theme("gnexus-dark")
+    renderer = FilesystemToolResultRenderer()
+    renderable = renderer.render(
+        {"type": "tool_call", "tool": "filesystem", "args": {"action": "read"},
+         "result": "x", "success": True, "is_subagent": True}
+    )
+    assert any(line.startswith("  ") for line in _render_text(renderable).splitlines())
+
+
+def test_non_subagent_result_not_indented() -> None:
+    set_active_theme("gnexus-dark")
+    renderer = FilesystemToolResultRenderer()
+    renderable = renderer.render(
+        {"type": "tool_call", "tool": "filesystem", "args": {"action": "read"},
+         "result": "x", "success": True, "is_subagent": False}
+    )
+    assert any(line.startswith("╭") for line in _render_text(renderable).splitlines())
\ No newline at end of file