iCode-TUI 0.29.1__py3-none-any.whl

chrys/app/tui/widgets/sidebar/context.py

@@ -0,0 +1,482 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""ContextPanel — token usage visualization and compressed block list."""
+
+from __future__ import annotations
+
+import contextlib
+from collections import deque
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from rich.cells import cell_len
+from rich.text import Text
+from textual.events import Resize
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import RichLog, Sparkline, Static
+
+from chrys.app.tui.i18n import render_str
+from chrys.app.tui.util.formatting import format_token_count
+from chrys.foundation.i18n import MessageRef, msg
+from chrys.foundation.i18n.formatting import format_message
+from chrys.service.profiles.models.schema import DEFAULT_MAX_CONTEXT_TOKENS
+
+_CONTEXT_USAGE = msg("tui.sidebar.context.usage", fallback="Context Usage")
+_CONTEXT_TOKEN_USAGE = msg("tui.sidebar.context.token_usage", fallback="Token Usage")
+_CONTEXT_COMPRESSED_MESSAGES = msg("tui.sidebar.context.compressed_messages", fallback="Compressed Messages")
+_CONTEXT_CACHED = msg("tui.sidebar.context.cached", fallback="Cached")
+_CONTEXT_INPUT = msg("tui.sidebar.context.input", fallback="Input")
+_CONTEXT_OUTPUT = msg("tui.sidebar.context.output", fallback="Output")
+_CONTEXT_TOTAL = msg("tui.sidebar.context.total", fallback="Total")
+CONTEXT_TURN_SINGLE = msg("tui.sidebar.context.turn_single", fallback="Turn {turn}")
+CONTEXT_TURN_RANGE = msg("tui.sidebar.context.turn_range", fallback="Turn {first}-{last}")
+CONTEXT_BLOCK_MESSAGES = msg(
+    "tui.sidebar.context.block_messages",
+    fallback="{formatted} message",
+    plural_fallback="{formatted} messages",
+)
+_CONTEXT_ROW_MESSAGES = (_CONTEXT_CACHED, _CONTEXT_INPUT, _CONTEXT_OUTPUT, _CONTEXT_TOTAL)
+_LEGACY_CONTEXT_LABEL_WIDTH = cell_len(_CONTEXT_CACHED.fallback) + 1
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from textual.app import ComposeResult
+
+    from chrys.app.tui.i18n import LocaleController
+
+
+def _format_breakdown(value: int, total: int) -> str:
+    # Em-dash signals "provider didn't report this split" — distinguishes it
+    # from the genuine pre-first-call zero state (where total is also 0).
+    if value == 0 and total > 0:
+        return "\u2014"
+    return format_token_count(value)
+
+
+def _format_optional(value: int | None) -> str:
+    """Render an optional token count: ``-`` when the provider didn't report."""
+    if value is None:
+        return "-"
+    return format_token_count(value)
+
+
+@dataclass(frozen=True, slots=True)
+class _CompressedBlock:
+    """Semantic state of one compressed context block, rendered per locale."""
+
+    context_id: str
+    summary: str
+    freed_messages: int
+    turn_range: tuple[int, int]
+
+
+class _CompressedBlocksLog(RichLog):
+    """Retain blocks so hidden-tab writes and width changes can be reflowed."""
+
+    _MAX_RENDERED_LINES = 200
+    _MAX_RETAINED_BLOCKS = 200
+
+    def __init__(self, renderer: Callable[[_CompressedBlock], Text]) -> None:
+        super().__init__(id="ctx-snapshots", max_lines=self._MAX_RENDERED_LINES, min_width=1, wrap=True)
+        self._render_block = renderer
+        self._blocks: deque[_CompressedBlock] = deque(maxlen=self._MAX_RETAINED_BLOCKS)
+        self._last_render_width = 0
+        self._needs_reflow = False
+        self._reflow_scheduled = False
+
+    def write_block(self, block: _CompressedBlock) -> None:
+        """Retain and render one block when a usable content width exists."""
+        self._blocks.append(block)
+        width = self.scrollable_content_region.width
+        if width <= 0 or not self._size_known:
+            self._needs_reflow = True
+            return
+        if self._needs_reflow or width != self._last_render_width:
+            self._schedule_reflow()
+            return
+        super().write(self._render_block(block), width=width)
+
+    def relocalize(self) -> None:
+        """Re-render retained blocks so their prose follows the active locale."""
+        if self._blocks:
+            self._schedule_reflow()
+
+    def clear(self) -> _CompressedBlocksLog:
+        """Clear rendered lines and their retained reflow sources."""
+        self._blocks.clear()
+        self._last_render_width = 0
+        self._needs_reflow = False
+        super().clear()
+        return self
+
+    def on_resize(self, event: Resize) -> None:
+        """Rebuild retained blocks when the log becomes visible or changes width."""
+        super().on_resize(event)
+        width = self.scrollable_content_region.width
+        if width > 0 and (self._needs_reflow or width != self._last_render_width):
+            self._schedule_reflow()
+
+    def _schedule_reflow(self) -> None:
+        self._needs_reflow = True
+        if not self._reflow_scheduled:
+            self._reflow_scheduled = self.call_after_refresh(self._flush_reflow)
+
+    def _flush_reflow(self) -> None:
+        self._reflow_scheduled = False
+        width = self.scrollable_content_region.width
+        if width <= 0:
+            self._needs_reflow = True
+            return
+        if self._needs_reflow or width != self._last_render_width:
+            self._reflow(width)
+
+    def _reflow(self, width: int) -> None:
+        super().clear()
+        self._last_render_width = width
+        self._needs_reflow = False
+        for block in self._blocks:
+            super().write(self._render_block(block), width=width)
+
+
+@dataclass(frozen=True, slots=True)
+class ContextUsageState:
+    """View state for the Context panel's usage and session-total display."""
+
+    used_tokens: int = 0
+    max_context_tokens: int = DEFAULT_MAX_CONTEXT_TOKENS
+    total_session_tokens: int = 0
+    total_session_input_tokens: int = 0
+    total_session_output_tokens: int = 0
+    total_session_cache_hit_tokens: int | None = None
+    update_window: bool = True
+
+    @classmethod
+    def with_window(
+        cls,
+        *,
+        used_tokens: int,
+        max_context_tokens: int,
+        total_session_tokens: int = 0,
+        total_session_input_tokens: int = 0,
+        total_session_output_tokens: int = 0,
+        total_session_cache_hit_tokens: int | None = None,
+    ) -> ContextUsageState:
+        """Update the main-session used/max gauge and the session totals."""
+        return cls(
+            used_tokens=used_tokens,
+            max_context_tokens=max_context_tokens,
+            total_session_tokens=total_session_tokens,
+            total_session_input_tokens=total_session_input_tokens,
+            total_session_output_tokens=total_session_output_tokens,
+            total_session_cache_hit_tokens=total_session_cache_hit_tokens,
+            update_window=True,
+        )
+
+    @classmethod
+    def session_totals_only(
+        cls,
+        previous: ContextUsageState | None,
+        *,
+        fallback_used_tokens: int,
+        total_session_tokens: int = 0,
+        total_session_input_tokens: int = 0,
+        total_session_output_tokens: int = 0,
+        total_session_cache_hit_tokens: int | None = None,
+    ) -> ContextUsageState:
+        """Advance totals without changing the main-session used/max gauge."""
+        used_tokens = previous.used_tokens if previous else fallback_used_tokens
+        max_context_tokens = previous.max_context_tokens if previous else cls().max_context_tokens
+        return cls(
+            used_tokens=used_tokens,
+            max_context_tokens=max_context_tokens,
+            total_session_tokens=total_session_tokens,
+            total_session_input_tokens=total_session_input_tokens,
+            total_session_output_tokens=total_session_output_tokens,
+            total_session_cache_hit_tokens=total_session_cache_hit_tokens,
+            update_window=False,
+        )
+
+
+class ContextPanel(Widget, can_focus=False):
+    """Displays token usage trend (sparkline) and list of compressed blocks."""
+
+    usage_state: reactive[ContextUsageState | None] = reactive(None, always_update=True)
+
+    DEFAULT_CSS = """
+    ContextPanel {
+        height: 100%;
+        width: 100%;
+        padding: 0 1;
+    }
+    ContextPanel > Static {
+        height: auto;
+    }
+    ContextPanel > .ctx-label {
+        text-style: bold;
+        color: $text-muted;
+    }
+    ContextPanel > Sparkline {
+        height: 1;
+        margin: 0 0 1 0;
+    }
+    ContextPanel > #ctx-session-total {
+        margin: 0 0 1 0;
+    }
+    ContextPanel > RichLog {
+        height: 1fr;
+        border: round $tui-border-primary-darken-3 $border-opacity;
+        scrollbar-size: 1 1;
+        overflow-x: hidden;
+    }
+    SidebarPanel.-shell-active ContextPanel > RichLog {
+        border: round $tui-border-warning-darken-1 $border-opacity;
+    }
+    """
+
+    def __init__(self, *, locale_controller: LocaleController | None = None) -> None:
+        super().__init__()
+        self._locale_controller = locale_controller
+        self._usage_history: list[float] = [0.0]
+        self._current_used = 0
+        self._current_max = DEFAULT_MAX_CONTEXT_TOKENS
+        self._total_session_tokens = 0
+        self._total_session_input_tokens = 0
+        self._total_session_output_tokens = 0
+        self._total_session_cache_hit_tokens: int | None = None
+
+    def watch_usage_state(self, state: ContextUsageState | None) -> None:
+        """Apply routed usage state from the screen."""
+        if state is None:
+            return
+        if state.update_window:
+            self.update_usage(
+                state.used_tokens,
+                state.max_context_tokens,
+                state.total_session_tokens,
+                state.total_session_input_tokens,
+                state.total_session_output_tokens,
+                state.total_session_cache_hit_tokens,
+            )
+            return
+        self._current_used = state.used_tokens
+        self._current_max = state.max_context_tokens
+        with contextlib.suppress(Exception):
+            self._update_usage_text()
+        self.update_session_totals(
+            total_session_tokens=state.total_session_tokens,
+            total_session_input_tokens=state.total_session_input_tokens,
+            total_session_output_tokens=state.total_session_output_tokens,
+            total_session_cache_hit_tokens=state.total_session_cache_hit_tokens,
+        )
+
+    def compose(self) -> ComposeResult:
+        yield Static(Text(self._render_message(_CONTEXT_USAGE.bind())), classes="ctx-label", id="ctx-usage-label")
+        yield Static(
+            Text(f"{self._current_used:,} / {self._current_max:,} (0.0%)"),
+            id="ctx-usage-text",
+        )
+        yield Sparkline(self._usage_history, id="ctx-sparkline")
+        yield Static(
+            Text(self._render_message(_CONTEXT_TOKEN_USAGE.bind())),
+            classes="ctx-label",
+            id="ctx-token-usage-label",
+        )
+        yield Static(Text(self._format_session_row("\u2713", _CONTEXT_CACHED.bind(), "-")), id="ctx-session-cache-hit")
+        yield Static(Text(self._format_session_row("\u2191", _CONTEXT_INPUT.bind(), "0")), id="ctx-session-input")
+        yield Static(Text(self._format_session_row("\u2193", _CONTEXT_OUTPUT.bind(), "0")), id="ctx-session-output")
+        yield Static(Text(self._format_session_row("\u03a3", _CONTEXT_TOTAL.bind(), "0")), id="ctx-session-total")
+        yield Static(
+            Text(self._render_message(_CONTEXT_COMPRESSED_MESSAGES.bind())),
+            classes="ctx-label",
+            id="ctx-compressed-label",
+        )
+        yield _CompressedBlocksLog(self._render_compressed_block)
+
+    def refresh_localization(self) -> None:
+        """Retranslate headings and rebuild current usage rows in place."""
+        if not self.is_mounted:
+            return
+        self.query_one("#ctx-usage-label", Static).update(Text(self._render_message(_CONTEXT_USAGE.bind())))
+        self.query_one("#ctx-token-usage-label", Static).update(Text(self._render_message(_CONTEXT_TOKEN_USAGE.bind())))
+        self.query_one("#ctx-compressed-label", Static).update(
+            Text(self._render_message(_CONTEXT_COMPRESSED_MESSAGES.bind()))
+        )
+        self._refresh_session_total_rows()
+        self.query_one("#ctx-snapshots", _CompressedBlocksLog).relocalize()
+
+    def _render_message(self, reference: MessageRef) -> str:
+        controller = self._locale_controller
+        if controller is None:
+            return format_message(reference)
+        return render_str(controller.localizer, reference)
+
+    def _session_label_width(self) -> int:
+        return max(
+            _LEGACY_CONTEXT_LABEL_WIDTH,
+            *(cell_len(self._render_message(definition.bind())) for definition in _CONTEXT_ROW_MESSAGES),
+        )
+
+    def _format_session_row(self, glyph: str, label_ref: MessageRef, value: str) -> str:
+        label = self._render_message(label_ref)
+        padding = " " * (self._session_label_width() - cell_len(label))
+        return f"{glyph} {label}{padding}{value:>8}"
+
+    def _refresh_session_total_rows(self) -> None:
+        self.query_one("#ctx-session-input", Static).update(
+            Text(
+                self._format_session_row(
+                    "\u2191",
+                    _CONTEXT_INPUT.bind(),
+                    _format_breakdown(self._total_session_input_tokens, self._total_session_tokens),
+                )
+            )
+        )
+        self.query_one("#ctx-session-output", Static).update(
+            Text(
+                self._format_session_row(
+                    "\u2193",
+                    _CONTEXT_OUTPUT.bind(),
+                    _format_breakdown(self._total_session_output_tokens, self._total_session_tokens),
+                )
+            )
+        )
+        self.query_one("#ctx-session-total", Static).update(
+            Text(
+                self._format_session_row(
+                    "\u03a3", _CONTEXT_TOTAL.bind(), format_token_count(self._total_session_tokens)
+                )
+            )
+        )
+        self.query_one("#ctx-session-cache-hit", Static).update(
+            Text(
+                self._format_session_row(
+                    "\u2713",
+                    _CONTEXT_CACHED.bind(),
+                    _format_optional(self._total_session_cache_hit_tokens),
+                )
+            )
+        )
+
+    def reset(self, max_context_tokens: int = 0) -> None:
+        """Reset usage state for a new session."""
+        self._usage_history = [0.0]
+        self._current_used = 0
+        self._total_session_tokens = 0
+        self._total_session_input_tokens = 0
+        self._total_session_output_tokens = 0
+        self._total_session_cache_hit_tokens = None
+        if max_context_tokens > 0:
+            self._current_max = max_context_tokens
+        try:
+            self.query_one("#ctx-usage-text", Static).update(f"0 / {self._current_max:,} (0.0%)")
+            self.query_one("#ctx-sparkline", Sparkline).data = list(self._usage_history)
+            self._refresh_session_total_rows()
+            self.query_one("#ctx-snapshots", _CompressedBlocksLog).clear()
+        except Exception:
+            pass
+
+    def update_usage(
+        self,
+        used: int,
+        max_tokens: int,
+        total_session_tokens: int = 0,
+        total_session_input_tokens: int = 0,
+        total_session_output_tokens: int = 0,
+        total_session_cache_hit_tokens: int | None = None,
+    ) -> None:
+        """Record a new usage data point."""
+        self._current_used = used
+        self._current_max = max_tokens
+        pct = used / max_tokens * 100 if max_tokens > 0 else 0.0
+        self._usage_history.append(pct)
+        # Keep last 60 data points
+        if len(self._usage_history) > 60:
+            self._usage_history = self._usage_history[-60:]
+        self.update_session_totals(
+            total_session_tokens=total_session_tokens,
+            total_session_input_tokens=total_session_input_tokens,
+            total_session_output_tokens=total_session_output_tokens,
+            total_session_cache_hit_tokens=total_session_cache_hit_tokens,
+        )
+        try:
+            self._update_usage_text()
+            self.query_one("#ctx-sparkline", Sparkline).data = list(self._usage_history)
+        except Exception:
+            pass
+
+    def _update_usage_text(self) -> None:
+        pct = self._current_used / self._current_max * 100 if self._current_max > 0 else 0.0
+        self.query_one("#ctx-usage-text", Static).update(f"{self._current_used:,} / {self._current_max:,} ({pct:.1f}%)")
+
+    def update_session_totals(
+        self,
+        *,
+        total_session_tokens: int = 0,
+        total_session_input_tokens: int = 0,
+        total_session_output_tokens: int = 0,
+        total_session_cache_hit_tokens: int | None = None,
+    ) -> None:
+        """Update only the cross-source session totals row.
+
+        Use this for sub-agent UsageUpdates \u2014 their used/max belong to the
+        sub-agent's window and must not overwrite the main session's gauge,
+        but their token costs still accumulate into the session totals shown
+        below the gauge.
+        """
+        self._total_session_tokens = total_session_tokens
+        self._total_session_input_tokens = total_session_input_tokens
+        self._total_session_output_tokens = total_session_output_tokens
+        self._total_session_cache_hit_tokens = total_session_cache_hit_tokens
+        with contextlib.suppress(Exception):
+            self._refresh_session_total_rows()
+
+    def clear_blocks(self) -> None:
+        """Clear the compressed blocks log."""
+        self.query_one("#ctx-snapshots", _CompressedBlocksLog).clear()
+
+    def add_compressed_block(
+        self,
+        compressed_context_id: str,
+        summary: str,
+        freed_messages: int = 0,
+        turn_range: tuple[int, int] = (0, 0),
+    ) -> None:
+        """Record a compressed context block."""
+        log = self.query_one("#ctx-snapshots", _CompressedBlocksLog)
+        log.write_block(
+            _CompressedBlock(
+                context_id=compressed_context_id,
+                summary=summary,
+                freed_messages=freed_messages,
+                turn_range=turn_range,
+            )
+        )
+
+    def _render_compressed_block(self, block: _CompressedBlock) -> Text:
+        """Render one retained block's prose in the active locale."""
+        t = Text()
+        t.append(f"\u2022 {self._compressed_block_title(block)}", style="magenta")
+        if block.freed_messages:
+            freed = self._render_message(
+                CONTEXT_BLOCK_MESSAGES.bind(count=block.freed_messages, formatted=f"{block.freed_messages:,}")
+            )
+            t.append(f"  {freed}", style="dim")
+        t.append(f"\n{block.summary}", style="dim italic")
+        return t
+
+    def _compressed_block_title(self, block: _CompressedBlock) -> str:
+        """Render a compressed block's turn span, retaining its recall id."""
+        turn_label = self._render_turn_range(block.turn_range)
+        if turn_label:
+            return f"{turn_label} ({block.context_id})"
+        return block.context_id
+
+    def _render_turn_range(self, turn_range: tuple[int, int]) -> str:
+        first_turn, last_turn = turn_range
+        if first_turn <= 0 or last_turn < first_turn:
+            return ""
+        if first_turn == last_turn:
+            return self._render_message(CONTEXT_TURN_SINGLE.bind(turn=first_turn))
+        return self._render_message(CONTEXT_TURN_RANGE.bind(first=first_turn, last=last_turn))

chrys/app/tui/widgets/sidebar/debug.py

@@ -0,0 +1,195 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""DebugPanel — real-time event stream viewer for debugging.
+
+Color-coded by event category:
+  cyan    — user events (UserMessage, UserInterrupt, ...)
+  green   — agent events (AgentThinking, InvocationMessage)
+  yellow  — tool events (InvocationToolCallStart, InvocationToolCallResult)
+  magenta — context events (ContextCompressed, UsageUpdate)
+  red     — errors
+  dim     — system events (SessionReady, StateChanged)
+"""
+
+from __future__ import annotations
+
+from collections import deque
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING, Any, Self
+
+from rich.text import Text
+from textual.widget import Widget
+from textual.widgets import RichLog, Static
+
+from chrys.app.tui.clipboard import copy_text_to_clipboards
+from chrys.app.tui.copy_messages import COPIED_TITLE
+from chrys.app.tui.i18n import render_str, widget_localizer
+from chrys.foundation.i18n import msg
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+    from textual.events import Click
+
+    from chrys.app.tui.i18n import LocaleController
+    from chrys.foundation.i18n import MessageRef
+
+
+_MAX_LOG_LINES = 1000
+"""Maximum lines retained in the debug event log."""
+
+_EVENT_LABEL_MAX = 15
+"""Max width for event type labels in the log."""
+
+_EVENT_STREAM_COPIED = msg("tui.debug.copy.event_stream", fallback="Event stream copied")
+_EVENT_STREAM_TITLE = msg("tui.sidebar.debug.event_stream", fallback="Event Stream")
+
+# Event type → (short label, color)
+_EVENT_STYLES: dict[str, tuple[str, str]] = {
+    "UserMessage": ("UserMsg", "cyan"),
+    "UserInterrupt": ("Interrupt", "cyan bold"),
+    "UserInject": ("Inject", "cyan"),
+    "UserInjectCancel": ("InjectCancel", "cyan"),
+    "ApprovalResponse": ("Approval", "cyan"),
+    "AgentProfileSwitch": ("Profile", "cyan"),
+    "SessionReady": ("SessionReady", "dim"),
+    "AgentThinking": ("Thinking", "green"),
+    "InvocationMessage": ("AgentMsg", "green"),
+    "InvocationToolCallStart": ("ToolStart", "yellow"),
+    "InvocationToolCallArgsUpdated": ("ToolArgsUpdated", "yellow"),
+    "InvocationToolCallResult": ("ToolResult", "yellow"),
+    "ApprovalRequest": ("NeedApproval", "yellow bold"),
+    "ToolCompacted:phase1": ("Compact:Phase1", "deep_pink4"),
+    "ToolCompacted:phase2": ("Compact:Phase2", "deep_pink4"),
+    "ToolCompacted:phase4": ("Compact:Phase4", "deep_pink4"),
+    "ToolCompacted": ("Compacted", "magenta"),
+    "ContextCompressed:auto": ("AutoCompress", "magenta bold"),
+    "ContextCompressed": ("Compress", "magenta"),
+    "UsageUpdate": ("Usage", "magenta"),
+    "TodoListUpdated": ("Todos", "blue"),
+    "StateChanged": ("State", "dim"),
+    "Error": ("ERROR", "red bold"),
+    "ShellCommand": ("Shell", "yellow bold"),
+    "RollbackResult": ("Rollback", "cyan bold"),
+}
+
+
+class _ClickableLog(RichLog, can_focus=False):
+    """RichLog that copies all entries to clipboard on click."""
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self._plain_lines: deque[str] = deque(maxlen=self.max_lines)
+
+    def write_with_text(self, renderable: Text, plain: str) -> None:
+        """Write a Rich Text and track its plain-text representation."""
+        self._plain_lines.append(plain)
+        self.write(renderable)
+
+    def on_click(self, event: Click) -> None:
+        if self._plain_lines:
+            payload = "\n".join(self._plain_lines)
+            copy_text_to_clipboards(self.app, payload)
+            localizer = widget_localizer(self)
+            self.notify(
+                render_str(localizer, _EVENT_STREAM_COPIED.bind()),
+                title=render_str(localizer, COPIED_TITLE.bind()),
+                timeout=1,
+                markup=False,
+            )
+
+    def clear(self) -> Self:
+        self._plain_lines.clear()
+        return super().clear()
+
+
+class DebugPanel(Widget, can_focus=False):
+    """Scrollable event log for real-time debugging.
+
+    Call ``log_event()`` to append a color-coded entry.
+    """
+
+    DEFAULT_CSS = """
+    DebugPanel {
+        height: 100%;
+        width: 100%;
+    }
+    DebugPanel > Static {
+        height: 1;
+        color: $text-muted;
+        text-style: bold;
+        padding: 0 1;
+    }
+    DebugPanel > _ClickableLog {
+        height: 1fr;
+        border: round $tui-border-primary-darken-3 $border-opacity;
+        scrollbar-size: 1 1;
+        overflow-x: auto;
+        scrollbar-size-horizontal: 0;
+    }
+    SidebarPanel.-shell-active DebugPanel > _ClickableLog {
+        border: round $tui-border-warning-darken-1 $border-opacity;
+    }
+    """
+
+    def __init__(self, *, locale_controller: LocaleController | None = None, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self._locale_controller = locale_controller
+
+    def _render_message(self, reference: MessageRef) -> str:
+        controller = self._locale_controller
+        if controller is None:
+            return render_str(widget_localizer(self), reference)
+        return render_str(controller.localizer, reference)
+
+    def compose(self) -> ComposeResult:
+        yield Static(Text(self._render_message(_EVENT_STREAM_TITLE.bind())), classes="debug-title")
+        yield _ClickableLog(id="debug-log", max_lines=_MAX_LOG_LINES, markup=True, wrap=False)
+
+    def refresh_localization(self) -> None:
+        """Re-render the localized title after a locale switch."""
+        if not self.is_mounted:
+            return
+        title = self.query_one(".debug-title", Static)
+        title.update(Text(self._render_message(_EVENT_STREAM_TITLE.bind())))
+
+    def log_event(self, event_type: str, detail: str = "", ts: datetime | None = None) -> None:
+        """Append a color-coded event entry."""
+        log = self.query_one("#debug-log", _ClickableLog)
+        timestamp = (ts or datetime.now(tz=UTC).astimezone()).strftime("%H:%M:%S")
+        if event_type.startswith("Usage["):
+            label, color = (_short_event_label(event_type), "magenta")
+        else:
+            label, color = _EVENT_STYLES.get(event_type, (_short_event_label(event_type), "dim"))
+
+        t = Text()
+        t.append(f"{timestamp} ", style="dim")
+        t.append(f"{label:<{_EVENT_LABEL_MAX}}", style=color)
+        if detail:
+            t.append(f" {detail}", style="dim")
+
+        plain = f"{timestamp} {label:<{_EVENT_LABEL_MAX}}"
+        if detail:
+            plain += f" {detail}"
+        log.write_with_text(t, plain)
+
+    def log_raw(self, text: str) -> None:
+        """Append raw text (for conversation logs, etc.)."""
+        log = self.query_one("#debug-log", _ClickableLog)
+        log.write_with_text(Text(text, style="dim"), text)
+
+
+def _short_event_label(event_type: str) -> str:
+    """Return an event label sized for the debug stream column."""
+    if len(event_type) <= _EVENT_LABEL_MAX:
+        return event_type
+    # ``Usage[<profile>]`` labels lose disambiguating value when the closing
+    # bracket gets truncated.  Shrink the profile name inside the brackets
+    # instead so the suffix stays attached.
+    if event_type.startswith("Usage[") and event_type.endswith("]"):
+        prefix = "Usage["
+        suffix = "]"
+        inner = event_type[len(prefix) : -len(suffix)]
+        max_inner = _EVENT_LABEL_MAX - len(prefix) - len(suffix) - 1
+        if max_inner > 0:
+            return f"{prefix}{inner[:max_inner]}…{suffix}"
+    return event_type[: _EVENT_LABEL_MAX - 1] + "…"

chrys/app/tui/widgets/sidebar/empty_state.py

@@ -0,0 +1,11 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Shared non-selectable sidebar empty-state label."""
+
+from __future__ import annotations
+
+from chrys.app.tui.widgets.selection import NonSelectableStatic
+
+
+class SidebarEmptyStateLabel(NonSelectableStatic):
+    """Centered sidebar placeholder excluded from drag selection and copy."""