iCode-TUI 0.29.1__py3-none-any.whl

chrys/app/tui/themes/document.py

@@ -0,0 +1,120 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Theme drafts and field-scoped, one-shot edit transactions."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+from uuid import UUID, uuid4
+
+from textual.theme import Theme
+
+SURFACES = ("background", "surface", "panel", "boost")
+
+
+def copy_theme(theme: Theme, *, name: str | None = None) -> Theme:
+    """Textual Theme is mutable; its variables must never be shared with drafts."""
+    return replace(theme, name=theme.name if name is None else name, variables=dict(theme.variables))
+
+
+@dataclass(frozen=True)
+class EditToken:
+    document: UUID
+    field: str
+    transaction: UUID
+
+
+@dataclass
+class EditTransaction:
+    token: EditToken
+    candidate: Theme
+
+
+class ThemeDocument:
+    """Opening baseline, saved baseline and history are separate concepts."""
+
+    def __init__(self, theme: Theme, *, is_new: bool = False) -> None:
+        self.is_new = is_new
+        self.id = uuid4()
+        self.original = copy_theme(theme)
+        self.saved = copy_theme(theme)
+        self.draft = copy_theme(theme)
+        self.undo_stack: list[Theme] = []
+        self.redo_stack: list[Theme] = []
+        self.transaction: EditTransaction | None = None
+
+    @property
+    def changed(self) -> bool:
+        return self.draft != self.original
+
+    @property
+    def unsaved(self) -> bool:
+        return self.is_new or self.draft != self.saved
+
+    def begin(self, field: str) -> EditToken:
+        self.cancel()
+        token = EditToken(self.id, field, uuid4())
+        self.transaction = EditTransaction(token, copy_theme(self.draft))
+        return token
+
+    def owns(self, token: EditToken) -> bool:
+        return self.transaction is not None and self.transaction.token == token
+
+    def require_transaction(self) -> EditTransaction:
+        if self.transaction is None:
+            raise RuntimeError("The theme document has no active edit transaction.")
+        return self.transaction
+
+    def stage(self, token: EditToken, value: str | None) -> Theme | None:
+        if not self.owns(token):
+            return None
+        candidate = copy_theme(self.draft)
+        kind, name = token.field.split(":", 1)
+        if kind == "color":
+            setattr(candidate, name, value)
+        elif kind == "var":
+            if value is None:
+                candidate.variables.pop(name, None)
+            else:
+                candidate.variables[name] = value
+        else:
+            raise ValueError(f"Unknown theme field: {token.field}")
+        self.transaction = EditTransaction(token, candidate)
+        return candidate
+
+    def commit(self, token: EditToken) -> bool:
+        if not self.owns(token):
+            return False
+        candidate = self.require_transaction().candidate
+        self.transaction = None
+        return self.replace(candidate)
+
+    def cancel(self) -> None:
+        self.transaction = None
+
+    def replace(self, candidate: Theme) -> bool:
+        self.cancel()
+        if candidate == self.draft:
+            return False
+        self.undo_stack.append(copy_theme(self.draft))
+        del self.undo_stack[:-100]
+        self.redo_stack.clear()
+        self.draft = copy_theme(candidate)
+        return True
+
+    def undo(self) -> None:
+        self.cancel()
+        if self.undo_stack:
+            self.redo_stack.append(self.draft)
+            self.draft = self.undo_stack.pop()
+
+    def redo(self) -> None:
+        self.cancel()
+        if self.redo_stack:
+            self.undo_stack.append(self.draft)
+            self.draft = self.redo_stack.pop()
+
+    def mark_saved(self) -> None:
+        """A future writer calls this only after a successful atomic write."""
+        self.is_new = False
+        self.saved = copy_theme(self.draft)

chrys/app/tui/themes/preview.py

@@ -0,0 +1,170 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Validate candidate themes without touching the running application's styles.
+
+The adapter targets the project's pinned Textual 8.2.7. Private CSS invalidation
+and source metadata live here; widgets only submit whole Theme snapshots. The
+application suppresses preference writes while an editor preview is active.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from textual.color import Color
+from textual.css.stylesheet import Stylesheet, StylesheetError, StylesheetParseError
+from textual.css.tokenizer import TokenError
+from textual.theme import Theme
+
+from chrys.app.tui.i18n import render_str
+from chrys.app.tui.theme import with_tui_css_variables
+from chrys.foundation.i18n import Localizer, msg
+
+from .document import SURFACES, copy_theme
+
+if TYPE_CHECKING:
+    from chrys.app.tui.app import ChrysApp
+
+_INVALID_CSS = msg("tui.theme_editor.invalid_css", fallback="Invalid CSS value{field}: {value}")
+
+
+def theme_variables(theme: Theme, defaults: dict[str, str]) -> dict[str, str]:
+    variables = with_tui_css_variables(theme, {**defaults, **theme.to_color_system().generate(), **theme.variables})
+    return variables
+
+
+def css_error(error: Exception, localizer: Localizer | None = None) -> str:
+    if isinstance(error, StylesheetParseError):
+        # Textual's HelpText summaries embed Rich markup alongside raw user
+        # values. Build a plain diagnostic from tokens instead of interpreting
+        # that mixed string or exposing its formatting tags in a Label.
+        messages = []
+        localizer = localizer or Localizer("en")
+        for rule in error.errors.rules:
+            for token, _message in rule.errors:
+                reference = token.referenced_by
+                variable = f" (${reference.name})" if reference is not None else ""
+                messages.append(render_str(localizer, _INVALID_CSS.bind(field=variable, value=repr(token.value))))
+        return "; ".join(dict.fromkeys(messages))[:700]
+    return str(error)[:700] or type(error).__name__
+
+
+def validate_theme(theme: Theme, defaults: dict[str, str], live: Stylesheet) -> dict[str, str]:
+    """Check only styles already in memory, without touching the live sheet.
+
+    New screen/widget styles are checked by ThemeStylesheet when loaded; the
+    preview's recovery hook keeps the previous valid theme if they reject it.
+    Never scan or parse application/library source files to open the editor.
+    """
+    for name in SURFACES:
+        value = getattr(theme, name)
+        if value is not None and Color.parse(value).a != 1:
+            # TextArea's Rich fallback may consume Theme.surface directly,
+            # outside CSS parsing. Keep the editor's existing opaque-surface policy.
+            raise ValueError(f"{name} requires an opaque color")
+    variables = theme_variables(theme, defaults)
+    probe = Stylesheet(variables=variables)
+    probe.source.update(live.source)
+    probe.parse()
+    return variables
+
+
+class ThemePreview:
+    """Last-valid publication with bounded history for newly discovered CSS."""
+
+    def __init__(self, app: ChrysApp) -> None:
+        self.app = app
+        # Opening the editor adopts the already displayed theme. Revalidating
+        # and republishing it would parse all loaded CSS and restyle the entire
+        # transcript before the panel can paint, despite no theme change.
+        self.current: Theme | None = copy_theme(app.current_theme)
+        self.variables: dict[str, str] | None = app.get_css_variables().copy()
+        self.history: list[Theme] = []
+        self.baseline: Theme | None = copy_theme(app.current_theme)
+        self._error: Exception | None = None
+        self._error_field = ""
+        self.field = ""
+
+    @property
+    def error(self) -> str:
+        """Render retained diagnostics in the active language without revalidating."""
+        if self._error is None:
+            return ""
+        diagnostic = css_error(self._error, self.app.locale_controller.localizer)
+        return f"{self._error_field}: {diagnostic}" if self._error_field else diagnostic
+
+    def checkpoint(self) -> None:
+        """Retain the pre-gesture theme even after a long stream of drag updates."""
+        if self.current is not None:
+            self.baseline = copy_theme(self.current)
+
+    def check(self, theme: Theme, field: str = "") -> dict[str, str] | None:
+        try:
+            result = validate_theme(theme, self.app.get_theme_variable_defaults(), self.app.stylesheet)
+        except (StylesheetError, TokenError, ValueError, TypeError, AttributeError) as error:
+            self._error = error
+            self._error_field = field
+            return None
+        self._error = None
+        return result
+
+    def show(self, theme: Theme, field: str = "") -> bool:
+        if theme == self.current:
+            self._error = None
+            return True
+        variables = self.check(theme, field)
+        if variables is None:
+            return False
+        if field != self.field:
+            self.checkpoint()
+        if self.current is not None:
+            self.history.append(copy_theme(self.current))
+            del self.history[:-20]
+        self.field = field
+        self.current = copy_theme(theme)
+        self.variables = variables
+        self._refresh()
+        return True
+
+    def _refresh(self) -> None:
+        theme = self.current
+        if theme is None:
+            raise RuntimeError("Refreshing the theme preview requires a current theme.")
+        app = self.app
+        classes = {name: False for name in app.classes if name.startswith("-theme-")}
+        classes.update(
+            {
+                f"-theme-{theme.name}": True,
+                "-dark-mode": theme.dark,
+                "-light-mode": not theme.dark,
+            }
+        )
+        app.update_classes(classes, update=False)
+        app._refresh_truecolor_filter(app.ansi_theme)
+        app._invalidate_css()
+        app.refresh_css(animate=False)
+        app.theme_changed_signal.publish(theme)
+
+    def recover(self, stylesheet: Stylesheet, error: Exception) -> bool:
+        """A lazily introduced style rejects the candidate, without theme switching.
+
+        Ordinary application syntax errors still propagate: none of the previous
+        themes can make them valid. Never delegate an editing failure to Chrys's
+        production fallback-to-chrys behavior.
+        """
+        candidates = [*reversed(self.history)]
+        if self.baseline is not None:
+            candidates.append(self.baseline)
+        for previous in candidates:
+            try:
+                variables = validate_theme(previous, self.app.get_theme_variable_defaults(), stylesheet)
+            except StylesheetError, TokenError, ValueError, TypeError, AttributeError:
+                continue
+            self._error = error
+            self._error_field = self.field
+            self.current = copy_theme(previous)
+            self.variables = variables
+            stylesheet.set_variables(variables)
+            self.app.call_next(self._refresh)
+            return True
+        return False

chrys/app/tui/themes/store.py

@@ -0,0 +1,176 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Validated user-theme files with atomic writes and optimistic conflict checks."""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass, fields
+from pathlib import Path
+
+import yaml
+from textual.theme import Theme
+
+from chrys.app.tui.theme_loader import (
+    _theme_from_data,
+    default_theme_directory,
+    theme_is_read_only,
+    theme_name_is_valid,
+)
+from chrys.foundation.i18n import MessageRef, msg
+from chrys.foundation.platform.files import atomic_write_text
+from chrys.foundation.util.lock import FileLock
+
+_INVALID_NAME = msg(
+    "tui.theme_store.invalid_name", fallback="Use a short name with letters, digits, dots, dashes or underscores."
+)
+_READ_ONLY = msg("tui.theme_store.read_only", fallback="Built-in themes are read-only. Choose a new name.")
+_EXISTS = msg("tui.theme_store.exists", fallback="A theme with this name already exists. Choose another name.")
+_CONFLICT = msg(
+    "tui.theme_store.conflict", fallback="This theme changed on disk. Close the editor and reopen it before saving."
+)
+_IO_ERROR = msg("tui.theme_store.io_error", fallback="Could not save the theme: {reason}")
+_LOAD_ERROR = msg("tui.theme_store.load_error", fallback="Could not open the theme: {reason}")
+_DELETE_ERROR = msg("tui.theme_store.delete_error", fallback="Could not delete the theme: {reason}")
+_DELETE_CONFLICT = msg(
+    "tui.theme_store.delete_conflict",
+    fallback="This theme changed on disk. Close the editor and reopen it before deleting.",
+)
+
+
+class ThemeStoreError(Exception):
+    """A storage failure with a localizable display message."""
+
+    def __init__(self, display: MessageRef) -> None:
+        super().__init__(display)
+        self.display = display
+
+    @property
+    def retryable(self) -> bool:
+        """A save IO failure may be retried without changing the document."""
+        return self.display.definition == _IO_ERROR
+
+
+@dataclass(frozen=True)
+class ThemeFileRevision:
+    path: Path
+    digest: str
+
+
+def theme_data(theme: Theme) -> dict[str, object]:
+    """Persist declared values, preserving expressions and omitted color fields."""
+    return {
+        field.name: dict(theme.variables) if field.name == "variables" else getattr(theme, field.name)
+        for field in fields(Theme)
+        if field.name != "name" and getattr(theme, field.name) is not None
+    }
+
+
+class UserThemeStore:
+    def __init__(self, directory: Path | None = None) -> None:
+        self.directory = directory if directory is not None else default_theme_directory()
+
+    def _matches(self, name: str) -> list[Path]:
+        if not self.directory.is_dir():
+            return []
+        return sorted(
+            path
+            for path in self.directory.iterdir()
+            if path.suffix.lower() in {".yaml", ".yml"} and path.stem.casefold() == name.casefold()
+        )
+
+    def validate_name(self, name: str, revision: ThemeFileRevision | None = None) -> None:
+        # Names are filenames on every supported platform, including Windows.
+        device = name.split(".", 1)[0].upper()
+        if (
+            not theme_name_is_valid(name)
+            or len(name) > 100
+            or name.endswith(".")
+            or device
+            in {"CON", "PRN", "AUX", "NUL", *(f"COM{i}" for i in range(1, 10)), *(f"LPT{i}" for i in range(1, 10))}
+        ):
+            raise ThemeStoreError(_INVALID_NAME.bind())
+        if theme_is_read_only(name):
+            raise ThemeStoreError(_READ_ONLY.bind())
+        try:
+            matches = self._matches(name)
+        except OSError as error:
+            raise ThemeStoreError(_IO_ERROR.bind(reason=str(error))) from error
+        if revision is not None:
+            if name != revision.path.stem or matches != [revision.path] or revision.path.is_symlink():
+                raise ThemeStoreError(_CONFLICT.bind())
+        elif matches:
+            raise ThemeStoreError(_EXISTS.bind())
+
+    def suggest_name(self, base: str) -> str:
+        stem = base[:85].rstrip(".") or "my-theme"
+        for index in range(1, 10000):
+            name = f"{stem}-{index}"
+            try:
+                self.validate_name(name)
+            except ThemeStoreError as error:
+                if error.display.definition == _EXISTS:
+                    continue
+                raise
+            return name
+        raise ThemeStoreError(_EXISTS.bind())
+
+    def load(self, name: str) -> tuple[Theme, ThemeFileRevision]:
+        if theme_is_read_only(name):
+            raise ThemeStoreError(_READ_ONLY.bind())
+        try:
+            paths = self._matches(name)
+            if len(paths) != 1 or paths[0].is_symlink() or paths[0].stem != name:
+                raise ThemeStoreError(_CONFLICT.bind())
+            path = paths[0]
+            payload = path.read_bytes()
+            data = yaml.safe_load(payload)
+            if not isinstance(data, dict):
+                raise ValueError("Theme must contain a mapping")
+            theme = _theme_from_data(name, data, path)
+            return theme, ThemeFileRevision(path, hashlib.sha256(payload).hexdigest())
+        except ThemeStoreError:
+            raise
+        except Exception as error:
+            raise ThemeStoreError(_LOAD_ERROR.bind(reason=str(error))) from error
+
+    def save(self, theme: Theme, revision: ThemeFileRevision | None) -> ThemeFileRevision:
+        """Call off the UI thread, after complete CSS preview validation."""
+        try:
+            self.directory.mkdir(parents=True, exist_ok=True)
+            with FileLock(self.directory / ".themes.lock", timeout=3):
+                self.validate_name(theme.name, revision)
+                path = revision.path if revision is not None else self.directory / f"{theme.name}.yaml"
+                if revision is not None and hashlib.sha256(path.read_bytes()).hexdigest() != revision.digest:
+                    raise ThemeStoreError(_CONFLICT.bind())
+                data = theme_data(theme)
+                _theme_from_data(theme.name, data, path)
+                payload = yaml.safe_dump(data, sort_keys=False, allow_unicode=True)
+                written = atomic_write_text(path, payload)
+                return ThemeFileRevision(path, hashlib.sha256(written).hexdigest())
+        except ThemeStoreError:
+            raise
+        except Exception as error:
+            raise ThemeStoreError(_IO_ERROR.bind(reason=str(error))) from error
+
+    def delete(self, name: str, revision: ThemeFileRevision) -> None:
+        """Remove only the user file the editor opened, under the save lock."""
+        if theme_is_read_only(name):
+            raise ThemeStoreError(_READ_ONLY.bind())
+        try:
+            with FileLock(self.directory / ".themes.lock", timeout=3):
+                if (
+                    not theme_name_is_valid(name)
+                    or revision.path.stem != name
+                    or self._matches(name) != [revision.path]
+                    or revision.path.is_symlink()
+                    or hashlib.sha256(revision.path.read_bytes()).hexdigest() != revision.digest
+                ):
+                    raise ThemeStoreError(_DELETE_CONFLICT.bind())
+                revision.path.unlink()
+        except ThemeStoreError:
+            raise
+        except FileNotFoundError as error:
+            raise ThemeStoreError(_DELETE_CONFLICT.bind()) from error
+        except Exception as error:
+            raise ThemeStoreError(_DELETE_ERROR.bind(reason=str(error))) from error

chrys/app/tui/toasts.py

@@ -0,0 +1,69 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Toasts under the header, the newest on top.
+
+Textual appends each new toast under the older ones and scrolls its rack to
+the end, which stacks a bottom-docked rack upward from the newest toast.
+Chrys docks the rack under the header instead (``chrys.tcss``), so the stack
+grows downward: new toasts mount ahead of the older ones and the rack keeps
+its start in view.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from textual.app import ScreenStackError
+from textual.css.query import NoMatches
+from textual.widgets._toast import Toast, ToastHolder, ToastRack
+
+if TYPE_CHECKING:
+    from textual.app import App
+    from textual.notifications import Notification, Notifications
+
+TEXTUAL_TOAST_RACK_FORK_VERSION = "8.2.7"
+"""The Textual release whose private ``App._refresh_notifications`` and ``ToastRack.show`` this mirrors."""
+
+
+def refresh_newest_first(app: App[object]) -> None:
+    """``App._refresh_notifications`` showing the current screen's rack newest first."""
+    try:
+        screen = app.screen
+    except ScreenStackError:
+        return
+    try:
+        rack = screen.get_child_by_type(ToastRack)
+    except NoMatches:
+        return
+    app.call_later(show_newest_first, rack, app._notifications)
+
+
+def show_newest_first(rack: ToastRack, notifications: Notifications) -> None:
+    """``ToastRack.show`` with the newest toast on top.
+
+    The only intentional delta from Textual's version: new toasts mount ahead
+    of the toasts already racked, and the rack scrolls to its start.
+    """
+    rack.display = bool(notifications)
+    for toast in rack.query(Toast):
+        if toast._notification not in notifications:
+            toast.remove()
+
+    new_toasts: list[Notification] = []
+    for notification in notifications:
+        try:
+            rack.get_child_by_id(rack._toast_id(notification))
+        except NoMatches:
+            if not notification.has_expired:
+                new_toasts.append(notification)
+
+    if new_toasts:
+        # Notifications iterate oldest first; the newest goes in first so it lands on top.
+        rack.mount_all(
+            [
+                ToastHolder(Toast(notification), id=rack._toast_id(notification))
+                for notification in reversed(new_toasts)
+            ],
+            before=0,
+        )
+        rack.call_later(rack.scroll_home, animate=False, force=True)

chrys/app/tui/util/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Utility helpers for TUI presentation code."""

chrys/app/tui/util/context_pressure.py

@@ -0,0 +1,146 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Shared context-pressure explanations for chat and nested agent transcripts."""
+
+from __future__ import annotations
+
+from chrys.foundation.i18n import MessageDef, MessageRef, msg
+
+_CONTEXT_PRESSURE_CONVERSATION = msg(
+    "tui.context_pressure.conversation.generic",
+    fallback="Conversation context compaction stopped because {reason}. The active task may exceed its model window.",
+)
+_CONTEXT_PRESSURE_SUB_AGENT = msg(
+    "tui.context_pressure.sub_agent.generic",
+    fallback="Sub-agent context compaction stopped because {reason}. The active task may exceed its model window.",
+)
+_CONTEXT_PRESSURE_CONVERSATION_INTERNAL_LIMIT = msg(
+    "tui.context_pressure.conversation.internal_limit",
+    fallback=(
+        "Conversation context compaction stopped because an internal safety limit was reached. "
+        "The active task may exceed its model window."
+    ),
+)
+_CONTEXT_PRESSURE_SUB_AGENT_INTERNAL_LIMIT = msg(
+    "tui.context_pressure.sub_agent.internal_limit",
+    fallback=(
+        "Sub-agent context compaction stopped because an internal safety limit was reached. "
+        "The active task may exceed its model window."
+    ),
+)
+_CONTEXT_PRESSURE_CONVERSATION_DISABLED = msg(
+    "tui.context_pressure.conversation.disabled",
+    fallback=(
+        "Conversation context compaction stopped because the compaction breaker was already disabled. "
+        "The active task may exceed its model window."
+    ),
+)
+_CONTEXT_PRESSURE_SUB_AGENT_DISABLED = msg(
+    "tui.context_pressure.sub_agent.disabled",
+    fallback=(
+        "Sub-agent context compaction stopped because the compaction breaker was already disabled. "
+        "The active task may exceed its model window."
+    ),
+)
+_CONTEXT_PRESSURE_CONVERSATION_GENERATION_FAILURE = msg(
+    "tui.context_pressure.conversation.generation_failure",
+    fallback=(
+        "Conversation context compaction stopped because progress-note generation failed repeatedly. "
+        "The active task may exceed its model window."
+    ),
+)
+_CONTEXT_PRESSURE_SUB_AGENT_GENERATION_FAILURE = msg(
+    "tui.context_pressure.sub_agent.generation_failure",
+    fallback=(
+        "Sub-agent context compaction stopped because progress-note generation failed repeatedly. "
+        "The active task may exceed its model window."
+    ),
+)
+_CONTEXT_PRESSURE_CONVERSATION_NO_PROGRESS = msg(
+    "tui.context_pressure.conversation.no_progress",
+    fallback=(
+        "Conversation context compaction stopped because repeated compaction attempts made insufficient progress. "
+        "The active task may exceed its model window."
+    ),
+)
+_CONTEXT_PRESSURE_SUB_AGENT_NO_PROGRESS = msg(
+    "tui.context_pressure.sub_agent.no_progress",
+    fallback=(
+        "Sub-agent context compaction stopped because repeated compaction attempts made insufficient progress. "
+        "The active task may exceed its model window."
+    ),
+)
+_CONTEXT_PRESSURE_CONVERSATION_ROUND_LIMIT = msg(
+    "tui.context_pressure.conversation.round_limit",
+    fallback=(
+        "Conversation context compaction stopped because the compaction attempt limit was reached. "
+        "The active task may exceed its model window."
+    ),
+)
+_CONTEXT_PRESSURE_SUB_AGENT_ROUND_LIMIT = msg(
+    "tui.context_pressure.sub_agent.round_limit",
+    fallback=(
+        "Sub-agent context compaction stopped because the compaction attempt limit was reached. "
+        "The active task may exceed its model window."
+    ),
+)
+_CONTEXT_PRESSURE_CONVERSATION_SIDE_CALL_BUDGET = msg(
+    "tui.context_pressure.conversation.side_call_budget",
+    fallback=(
+        "Conversation context compaction stopped because the progress-note token budget was exhausted. "
+        "The active task may exceed its model window."
+    ),
+)
+_CONTEXT_PRESSURE_SUB_AGENT_SIDE_CALL_BUDGET = msg(
+    "tui.context_pressure.sub_agent.side_call_budget",
+    fallback=(
+        "Sub-agent context compaction stopped because the progress-note token budget was exhausted. "
+        "The active task may exceed its model window."
+    ),
+)
+_CONTEXT_PRESSURE_CONVERSATION_SPILL_ABORT = msg(
+    "tui.context_pressure.conversation.spill_abort",
+    fallback=(
+        "Conversation context compaction stopped because dropped-call storage could not be durably checkpointed. "
+        "The active task may exceed its model window."
+    ),
+)
+_CONTEXT_PRESSURE_SUB_AGENT_SPILL_ABORT = msg(
+    "tui.context_pressure.sub_agent.spill_abort",
+    fallback=(
+        "Sub-agent context compaction stopped because dropped-call storage could not be durably checkpointed. "
+        "The active task may exceed its model window."
+    ),
+)
+
+_CONTEXT_PRESSURE_MESSAGES: dict[tuple[str, str], MessageDef] = {
+    ("main", "disabled"): _CONTEXT_PRESSURE_CONVERSATION_DISABLED,
+    ("sub_agent", "disabled"): _CONTEXT_PRESSURE_SUB_AGENT_DISABLED,
+    ("main", "generation_failure"): _CONTEXT_PRESSURE_CONVERSATION_GENERATION_FAILURE,
+    ("sub_agent", "generation_failure"): _CONTEXT_PRESSURE_SUB_AGENT_GENERATION_FAILURE,
+    ("main", "no_progress"): _CONTEXT_PRESSURE_CONVERSATION_NO_PROGRESS,
+    ("sub_agent", "no_progress"): _CONTEXT_PRESSURE_SUB_AGENT_NO_PROGRESS,
+    ("main", "round_limit"): _CONTEXT_PRESSURE_CONVERSATION_ROUND_LIMIT,
+    ("sub_agent", "round_limit"): _CONTEXT_PRESSURE_SUB_AGENT_ROUND_LIMIT,
+    ("main", "side_call_budget"): _CONTEXT_PRESSURE_CONVERSATION_SIDE_CALL_BUDGET,
+    ("sub_agent", "side_call_budget"): _CONTEXT_PRESSURE_SUB_AGENT_SIDE_CALL_BUDGET,
+    ("main", "spill_abort"): _CONTEXT_PRESSURE_CONVERSATION_SPILL_ABORT,
+    ("sub_agent", "spill_abort"): _CONTEXT_PRESSURE_SUB_AGENT_SPILL_ABORT,
+}
+
+
+def context_pressure_message(reason: str, *, source: str = "main") -> MessageRef:
+    """Keep the reason-specific warning identical across transcript surfaces."""
+    source = "sub_agent" if source == "sub_agent" else "main"
+    definition = _CONTEXT_PRESSURE_MESSAGES.get((source, reason))
+    if definition is not None:
+        return definition.bind()
+    if reason:
+        definition = _CONTEXT_PRESSURE_SUB_AGENT if source == "sub_agent" else _CONTEXT_PRESSURE_CONVERSATION
+        return definition.bind(reason=reason.replace("_", " "))
+    definition = (
+        _CONTEXT_PRESSURE_SUB_AGENT_INTERNAL_LIMIT
+        if source == "sub_agent"
+        else _CONTEXT_PRESSURE_CONVERSATION_INTERNAL_LIMIT
+    )
+    return definition.bind()