symphony-code 0.0.1__py3-none-any.whl

coding_agent/tui/screens/resume.py

@@ -0,0 +1,163 @@
+"""Pre-launch selector for a persisted conversation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any
+
+from rich.cells import cell_len
+from rich.console import Group
+from rich.text import Text
+from textual import events
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Container
+from textual.widgets import OptionList, Static
+from textual.widgets.option_list import Option
+
+from coding_agent.addons.persistence.active import active_session_ids
+from coding_agent.tui.theme import RESUME_CSS, SYMPHONY_RICH_THEME
+from core_ai.content import text_from_content
+from core_harness.context import COMPACTED_CONTEXT_MARK
+
+
+@dataclass(frozen=True)
+class SessionOption:
+    session_id: str
+    updated_at: str
+    first_message: str
+    message_count: int
+
+
+def _relative_time(value: str) -> str:
+    try:
+        updated = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError:
+        return value
+    seconds = max(0, int((datetime.now(timezone.utc) - updated).total_seconds()))
+    if seconds < 60:
+        return "just now"
+    if seconds < 3_600:
+        return f"{seconds // 60}m ago"
+    if seconds < 86_400:
+        return f"{seconds // 3_600}h ago"
+    return f"{seconds // 86_400}d ago"
+
+
+async def load_session_options(
+    persistence: Any,
+    *,
+    closed_only: bool = True,
+) -> list[SessionOption]:
+    """Build display rows through the existing persistence interface.
+
+    Active sessions are owned by a live Symphony process and listed under
+    ``~/.symphony/active``. The resume picker hides them so a conversation is
+    not opened twice. Pass ``closed_only=False`` to include them.
+    """
+    open_ids = active_session_ids() if closed_only else set()
+    options: list[SessionOption] = []
+    for session in await persistence.list_sessions():
+        if session.session_id in open_ids:
+            continue
+        # JsonlPersistence computes these cheap row fields while scanning each
+        # file. Avoid reparsing every transcript when opening the picker.
+        if getattr(session, "message_count", 0) or getattr(session, "first_message", ""):
+            first_message = getattr(session, "first_message", "") or "Untitled conversation"
+            message_count = getattr(session, "message_count", 0)
+        else:
+            loader = getattr(persistence, "load_transcript", persistence.load_conversation)
+            messages = await loader(session_id=session.session_id)
+            first_message = next(
+                (
+                    text_from_content(message.content).strip()
+                    for message in messages
+                    if message.role == "user"
+                    and message.content
+                    and not text_from_content(message.content).startswith(COMPACTED_CONTEXT_MARK)
+                ),
+                "Untitled conversation",
+            )
+            message_count = len(messages)
+        options.append(
+            SessionOption(session.session_id, session.updated_at, first_message, message_count)
+        )
+    return options
+
+
+def _fit(text: str, width: int) -> str:
+    """Clip by terminal cells, reserving one cell for an ellipsis."""
+    if width <= 0:
+        return ""
+    if cell_len(text) <= width:
+        return text
+    if width == 1:
+        return "…"
+    kept = text
+    while kept and cell_len(kept) > width - 1:
+        kept = kept[:-1]
+    return f"{kept}…"
+
+
+def _row(session: SessionOption, width: int) -> Option:
+    """Title on line one and aligned metadata on line two.
+
+    Both lines are pre-clipped. Textual otherwise wraps long titles while
+    measuring every session, which makes a long resume list slow to open.
+    """
+    title_width = max(1, width - 3)
+    meta_width = max(1, width - 3)
+    title = _fit(session.first_message.replace("\n", " "), title_width)
+    meta = _fit(
+        f"{_relative_time(session.updated_at):<8}  {session.message_count:>6}  {session.session_id}",
+        meta_width,
+    )
+    heading = Text(f"›  {title}", no_wrap=True, overflow="ellipsis")
+    heading.highlight_words(["›"], style="bold #e1c16e")
+    details = Text(f"   {meta}", no_wrap=True, overflow="ellipsis", style="#737373")
+    return Option(Group(heading, details), id=session.session_id)
+
+
+class ResumeApp(App[str | None]):
+    """Choose a session before the conversation UI is created."""
+
+    CSS = RESUME_CSS
+    BINDINGS = [
+        Binding("escape", "cancel", "quit"),
+        Binding("ctrl+c", "cancel", "quit", show=False),
+    ]
+
+    def __init__(self, sessions: list[SessionOption]) -> None:
+        super().__init__()
+        self.sessions = sessions
+        self._row_width = 0
+
+    def compose(self) -> ComposeResult:
+        with Container(id="resume-page"):
+            yield Static("Resume a previous session", id="resume-title")
+            yield Static("Select a conversation to continue", id="resume-subtitle")
+            yield OptionList(id="resume-list")
+            yield Static("↑↓ select   Enter resume   Esc quit", id="resume-hint")
+
+    def on_resize(self, event: events.Resize) -> None:
+        # Page padding is 2, row padding is 4, and the scrollbar takes 1.
+        width = max(1, event.size.width - 7)
+        if width == self._row_width:
+            return
+        self._row_width = width
+        options = self.query_one("#resume-list", OptionList)
+        highlighted = options.highlighted
+        options.set_options(_row(session, width) for session in self.sessions)
+        if self.sessions:
+            options.highlighted = min(highlighted or 0, len(self.sessions) - 1)
+
+    def on_mount(self) -> None:
+        self.console.push_theme(SYMPHONY_RICH_THEME, inherit=True)
+        self.query_one("#resume-list", OptionList).focus()
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        self.exit(event.option_id)
+
+    def action_cancel(self) -> None:
+        self.exit(None)

coding_agent/tui/theme/__init__.py

@@ -0,0 +1,49 @@
+"""Color tokens and Textual CSS for the coding-agent TUI."""
+
+from __future__ import annotations
+
+from coding_agent.tui.theme.load import (
+    APP_CSS,
+    CHROME_CSS,
+    COMPOSER_CSS,
+    CONTENT_MODAL_CSS,
+    CONTEXT_MODAL_CSS,
+    DIFF_MODAL_CSS,
+    EXTENSIONS_MODAL_CSS,
+    IMAGE_MODAL_CSS,
+    LEARNING_MODAL_CSS,
+    MODAL_BASE_CSS,
+    ONBOARD_CSS,
+    PROVIDER_MODAL_CSS,
+    RESUME_CSS,
+    SYMPHONY_COLORS,
+    TOOLS_CSS,
+)
+from coding_agent.tui.theme.style import (
+    SYMPHONY_CODE_THEME,
+    SYMPHONY_RICH_THEME,
+    SymphonyCodeStyle,
+    themed_markdown,
+)
+
+__all__ = [
+    "APP_CSS",
+    "CHROME_CSS",
+    "COMPOSER_CSS",
+    "CONTENT_MODAL_CSS",
+    "CONTEXT_MODAL_CSS",
+    "DIFF_MODAL_CSS",
+    "EXTENSIONS_MODAL_CSS",
+    "IMAGE_MODAL_CSS",
+    "LEARNING_MODAL_CSS",
+    "MODAL_BASE_CSS",
+    "ONBOARD_CSS",
+    "PROVIDER_MODAL_CSS",
+    "RESUME_CSS",
+    "SYMPHONY_CODE_THEME",
+    "SYMPHONY_COLORS",
+    "SYMPHONY_RICH_THEME",
+    "SymphonyCodeStyle",
+    "TOOLS_CSS",
+    "themed_markdown",
+]

coding_agent/tui/theme/load.py

@@ -0,0 +1,325 @@
+"""Load the Symphony TUI theme from ~/.symphony/theme.toml."""
+
+from __future__ import annotations
+
+import hashlib
+import tomllib
+from dataclasses import dataclass
+from importlib.resources import files
+from pathlib import Path
+from typing import Any, Mapping
+
+THEME_FILE = "theme.toml"
+PACKAGE_NAME = "coding_agent.tui.theme"
+
+SYMPHONY_COLOR_KEYS = (
+    "background",
+    "foreground",
+    "accent",
+    "muted",
+    "muted_dim",
+    "edge",
+    "comment",
+    "keyword",
+    "type_keywords",
+    "string",
+    "function",
+    "variable",
+    "number",
+    "operator",
+    "punctuation",
+    "type",
+    "tag",
+    "attribute",
+    "constant",
+    "surface",
+    "overlay",
+    "subtext",
+)
+
+SPACING_PREFIX = "space-"
+
+CSS_SECTIONS = ("chrome", "tools", "composer", "resume", "onboard")
+MODAL_SECTIONS = (
+    "base",
+    "content",
+    "image",
+    "diff",
+    "extensions",
+    "learning",
+    "context",
+    "provider",
+)
+
+
+class ThemeConfigError(ValueError):
+    """theme.toml is missing a required table, key, or color token."""
+
+
+@dataclass(frozen=True)
+class ThemeDocument:
+    """Parsed theme.toml plus the assembled CSS strings the TUI imports."""
+
+    source: str
+    colors: dict[str, str]
+    spacing: dict[str, int]
+    chrome_css: str
+    tools_css: str
+    composer_css: str
+    resume_css: str
+    onboard_css: str
+    modal_base_css: str
+    content_modal_css: str
+    image_modal_css: str
+    diff_modal_css: str
+    extensions_modal_css: str
+    learning_modal_css: str
+    context_modal_css: str
+    provider_modal_css: str
+
+    @property
+    def app_css(self) -> str:
+        return glue_css(glue_css(self.chrome_css, self.tools_css), self.composer_css)
+
+
+def user_theme_path() -> Path:
+    """Runtime theme file: ~/.symphony/theme.toml."""
+    return Path.home() / ".symphony" / THEME_FILE
+
+
+def packaged_theme_path() -> Path:
+    """Filesystem path of the theme.toml shipped next to this package."""
+    return Path(__file__).with_name(THEME_FILE)
+
+
+def resolve_theme_path(path: Path | None = None) -> Path:
+    """Prefer an explicit path, then ~/.symphony/theme.toml, then the package copy."""
+    if path is not None:
+        resolved = Path(path)
+        if not resolved.is_file():
+            raise ThemeConfigError(f"theme file not found: {resolved}")
+        return resolved
+    user = user_theme_path()
+    if user.is_file():
+        return user
+    packaged = packaged_theme_path()
+    if packaged.is_file():
+        return packaged
+    raise ThemeConfigError(
+        "theme.toml not found (no packaged copy and no ~/.symphony/theme.toml)"
+    )
+
+
+def load_theme(path: Path | None = None) -> ThemeDocument:
+    """Parse theme.toml and assemble the public color/CSS surface."""
+    source, raw = _read_theme(path)
+    document = _parse_toml(source, raw)
+    colors = color_tokens(document)
+    css = _table(document, "css", source=source)
+    variables = _string_table(_table(css, "variables", source=source, label="css.variables"))
+    spacing = spacing_tokens(css)
+    sections = {name: _css_string(css, name, source=source) for name in CSS_SECTIONS}
+    modal = _table(css, "modal", source=source, label="css.modal")
+    modal_css = {name: _css_string(modal, name, source=source, label=f"css.modal.{name}") for name in MODAL_SECTIONS}
+    chrome = textual_variable_block(colors, variables) + spacing_variable_block(spacing) + sections["chrome"]
+    base = modal_css["base"]
+    return ThemeDocument(
+        source=source,
+        colors={key: colors[key] for key in SYMPHONY_COLOR_KEYS},
+        spacing=spacing,
+        chrome_css=chrome,
+        tools_css=sections["tools"],
+        composer_css=sections["composer"],
+        resume_css=sections["resume"],
+        onboard_css=glue_css(sections["resume"], sections["onboard"]),
+        modal_base_css=base,
+        content_modal_css=glue_css(base, modal_css["content"]),
+        image_modal_css=glue_css(base, modal_css["image"]),
+        diff_modal_css=glue_css(base, modal_css["diff"]),
+        extensions_modal_css=glue_css(base, modal_css["extensions"]),
+        learning_modal_css=glue_css(base, modal_css["learning"]),
+        context_modal_css=glue_css(base, modal_css["context"]),
+        provider_modal_css=glue_css(base, modal_css["provider"]),
+    )
+
+
+def glue_css(prefix: str, extra: str) -> str:
+    """Join two CSS fragments with a blank line, matching the old Python constants."""
+    if extra.startswith("\n"):
+        return prefix + extra
+    if prefix.endswith("\n\n"):
+        return prefix + extra
+    if prefix.endswith("\n"):
+        return prefix + "\n" + extra
+    return prefix + "\n\n" + extra
+
+
+def color_tokens(document: Mapping[str, Any]) -> dict[str, str]:
+    """Return every [colors] entry; required Symphony tokens must be present."""
+    colors = _string_table(_table(document, "colors"))
+    missing = [key for key in SYMPHONY_COLOR_KEYS if key not in colors]
+    if missing:
+        raise ThemeConfigError("theme.toml [colors] missing: " + ", ".join(missing))
+    return colors
+
+
+def textual_variable_block(colors: Mapping[str, str], variables: Mapping[str, str]) -> str:
+    """Render Textual `$name: value;` declarations from [css.variables]."""
+    if not variables:
+        raise ThemeConfigError("theme.toml [css.variables] is empty")
+    lines = ["/* Symphony dark theme. Palette tokens live in theme.toml. */"]
+    for name, token in variables.items():
+        if token not in colors:
+            raise ThemeConfigError(f"[css.variables].{name} refers to unknown color {token!r}")
+        lines.append(f"${name}: {colors[token]};")
+    return "\n".join(lines) + "\n\n"
+
+
+def spacing_tokens(css: Mapping[str, Any]) -> dict[str, int]:
+    """Return [css.spacing] as cell counts; a theme without the table has no tokens."""
+    table = css.get("spacing")
+    if table is None:
+        return {}
+    if not isinstance(table, dict):
+        raise ThemeConfigError("theme.toml [css.spacing] must be a table")
+    tokens: dict[str, int] = {}
+    for key, cells in table.items():
+        if isinstance(cells, bool) or not isinstance(cells, int) or cells < 0:
+            raise ThemeConfigError(
+                f"theme.toml [css.spacing].{key} must be a non-negative integer"
+            )
+        tokens[str(key)] = cells
+    return tokens
+
+
+def spacing_variable_block(spacing: Mapping[str, int]) -> str:
+    """Render spacing tokens as Textual `$space-<name>: <cells>;` declarations."""
+    if not spacing:
+        return ""
+    lines = ["/* Spacing scale in terminal cells. Values live in theme.toml [css.spacing]. */"]
+    lines.extend(f"${SPACING_PREFIX}{name}: {cells};" for name, cells in spacing.items())
+    return "\n".join(lines) + "\n\n"
+
+
+def _read_theme(path: Path | None) -> tuple[str, str]:
+    if path is not None or user_theme_path().is_file() or packaged_theme_path().is_file():
+        resolved = resolve_theme_path(path)
+        return str(resolved), resolved.read_text(encoding="utf-8")
+    resource = files(PACKAGE_NAME).joinpath(THEME_FILE)
+    return f"package:{THEME_FILE}", resource.read_text(encoding="utf-8")
+
+
+def _parse_toml(source: str, raw: str) -> dict[str, Any]:
+    try:
+        document = tomllib.loads(raw)
+    except tomllib.TOMLDecodeError as exc:
+        raise ThemeConfigError(f"invalid TOML in {source}: {exc}") from exc
+    if not isinstance(document, dict):
+        raise ThemeConfigError(f"{source} must be a TOML table")
+    return document
+
+
+def _table(
+    document: Mapping[str, Any],
+    key: str,
+    *,
+    source: str = "theme.toml",
+    label: str | None = None,
+) -> dict[str, Any]:
+    name = label or key
+    value = document.get(key)
+    if not isinstance(value, dict):
+        raise ThemeConfigError(f"{source} is missing [{name}]")
+    return value
+
+
+def _string_table(table: Mapping[str, Any]) -> dict[str, str]:
+    values: dict[str, str] = {}
+    for key, value in table.items():
+        if not isinstance(value, str) or not value:
+            raise ThemeConfigError(f"theme.toml {key!r} must be a non-empty string")
+        values[str(key)] = value
+    return values
+
+
+def _css_string(
+    table: Mapping[str, Any],
+    key: str,
+    *,
+    source: str,
+    label: str | None = None,
+) -> str:
+    name = label or f"css.{key}"
+    value = table.get(key)
+    if not isinstance(value, str) or not value.strip():
+        raise ThemeConfigError(f"{source} is missing a non-empty [{name}] string")
+    return value
+
+
+_DEFAULT = load_theme()
+
+# Mutable on purpose. Chrome reads these keys while it paints, so a live
+# reload can replace the values without restarting the process. Do not
+# rebind the dict; callers hold this same object.
+SYMPHONY_COLORS = dict(_DEFAULT.colors)
+CHROME_CSS = _DEFAULT.chrome_css
+TOOLS_CSS = _DEFAULT.tools_css
+COMPOSER_CSS = _DEFAULT.composer_css
+RESUME_CSS = _DEFAULT.resume_css
+ONBOARD_CSS = _DEFAULT.onboard_css
+MODAL_BASE_CSS = _DEFAULT.modal_base_css
+CONTENT_MODAL_CSS = _DEFAULT.content_modal_css
+IMAGE_MODAL_CSS = _DEFAULT.image_modal_css
+DIFF_MODAL_CSS = _DEFAULT.diff_modal_css
+EXTENSIONS_MODAL_CSS = _DEFAULT.extensions_modal_css
+LEARNING_MODAL_CSS = _DEFAULT.learning_modal_css
+CONTEXT_MODAL_CSS = _DEFAULT.context_modal_css
+PROVIDER_MODAL_CSS = _DEFAULT.provider_modal_css
+APP_CSS = _DEFAULT.app_css
+
+
+def apply_theme(document: ThemeDocument) -> None:
+    """Publish a parsed theme into the module globals the running TUI holds.
+
+    ``SYMPHONY_COLORS`` is updated in place so widgets that imported the dict
+    see the new tokens on their next paint. CSS strings are replaced for the
+    next ``stylesheet`` read; already-mounted screens must reassign theirs.
+    """
+    SYMPHONY_COLORS.clear()
+    SYMPHONY_COLORS.update(document.colors)
+    global CHROME_CSS, TOOLS_CSS, COMPOSER_CSS, RESUME_CSS, ONBOARD_CSS
+    global MODAL_BASE_CSS, CONTENT_MODAL_CSS, IMAGE_MODAL_CSS, DIFF_MODAL_CSS
+    global EXTENSIONS_MODAL_CSS, LEARNING_MODAL_CSS
+    global CONTEXT_MODAL_CSS, PROVIDER_MODAL_CSS, APP_CSS
+    CHROME_CSS = document.chrome_css
+    TOOLS_CSS = document.tools_css
+    COMPOSER_CSS = document.composer_css
+    RESUME_CSS = document.resume_css
+    ONBOARD_CSS = document.onboard_css
+    MODAL_BASE_CSS = document.modal_base_css
+    CONTENT_MODAL_CSS = document.content_modal_css
+    IMAGE_MODAL_CSS = document.image_modal_css
+    DIFF_MODAL_CSS = document.diff_modal_css
+    EXTENSIONS_MODAL_CSS = document.extensions_modal_css
+    LEARNING_MODAL_CSS = document.learning_modal_css
+    CONTEXT_MODAL_CSS = document.context_modal_css
+    PROVIDER_MODAL_CSS = document.provider_modal_css
+    APP_CSS = document.app_css
+
+
+def theme_signature(path: Path | None = None) -> tuple[str, tuple[int, int, str]] | None:
+    """Identity of the theme file currently in effect, or None when unreadable.
+
+    The second item is ``(st_mtime_ns, st_size, sha256 of the bytes)``. The
+    mtime alone misses a rewrite that lands in the same filesystem timestamp
+    tick, and the size misses a same-length edit such as a changed hex color,
+    so the content digest decides those. The file is a few KB, so hashing it
+    on every poll is cheap.
+    """
+    try:
+        resolved = resolve_theme_path(path)
+        stat = resolved.stat()
+        digest = hashlib.sha256(resolved.read_bytes()).hexdigest()
+    except (OSError, ThemeConfigError):
+        return None
+    return (str(resolved), (stat.st_mtime_ns, stat.st_size, digest))

coding_agent/tui/theme/style.py

@@ -0,0 +1,95 @@
+"""Rich and Pygments glue for tokens loaded from theme.toml."""
+
+from __future__ import annotations
+
+from pygments.style import Style
+from pygments.token import (
+    Comment,
+    Error,
+    Generic,
+    Keyword,
+    Name,
+    Number,
+    Operator,
+    Punctuation,
+    String,
+    Text,
+)
+from rich.markdown import Markdown
+from rich.syntax import PygmentsSyntaxTheme
+from rich.theme import Theme
+
+from coding_agent.tui.theme.load import SYMPHONY_COLORS
+
+
+class SymphonyCodeStyle(Style):
+    """Syntax palette for the active Symphony dark theme."""
+
+    background_color = SYMPHONY_COLORS["background"]
+    highlight_color = SYMPHONY_COLORS["overlay"]
+    line_number_color = SYMPHONY_COLORS["comment"]
+    line_number_background_color = SYMPHONY_COLORS["background"]
+    line_number_special_color = SYMPHONY_COLORS["foreground"]
+    line_number_special_background_color = SYMPHONY_COLORS["overlay"]
+
+    styles = {
+        Text: SYMPHONY_COLORS["foreground"],
+        Text.Whitespace: SYMPHONY_COLORS["punctuation"],
+        Comment: "italic " + SYMPHONY_COLORS["comment"],
+        Comment.Preproc: SYMPHONY_COLORS["comment"],
+        Keyword: SYMPHONY_COLORS["keyword"],
+        Keyword.Type: SYMPHONY_COLORS["type_keywords"],
+        Operator: SYMPHONY_COLORS["operator"],
+        Punctuation: SYMPHONY_COLORS["punctuation"],
+        Name: SYMPHONY_COLORS["variable"],
+        Name.Builtin: SYMPHONY_COLORS["constant"],
+        Name.Class: "bold " + SYMPHONY_COLORS["type"],
+        Name.Decorator: SYMPHONY_COLORS["attribute"],
+        Name.Exception: SYMPHONY_COLORS["keyword"],
+        Name.Function: SYMPHONY_COLORS["function"],
+        Name.Namespace: SYMPHONY_COLORS["type"],
+        Name.Tag: SYMPHONY_COLORS["tag"],
+        Name.Variable: SYMPHONY_COLORS["variable"],
+        String: SYMPHONY_COLORS["string"],
+        String.Doc: "italic " + SYMPHONY_COLORS["comment"],
+        Number: SYMPHONY_COLORS["number"],
+        Generic.Deleted: SYMPHONY_COLORS["keyword"] + " bg:" + SYMPHONY_COLORS["overlay"],
+        Generic.Inserted: SYMPHONY_COLORS["string"] + " bg:" + SYMPHONY_COLORS["surface"],
+        Generic.Heading: "bold " + SYMPHONY_COLORS["foreground"],
+        Generic.Subheading: SYMPHONY_COLORS["subtext"],
+        Error: SYMPHONY_COLORS["keyword"] + " bg:" + SYMPHONY_COLORS["overlay"],
+    }
+
+
+SYMPHONY_CODE_THEME = PygmentsSyntaxTheme(SymphonyCodeStyle)
+
+SYMPHONY_RICH_THEME = Theme(
+    {
+        "markdown.paragraph": SYMPHONY_COLORS["foreground"],
+        "markdown.text": SYMPHONY_COLORS["foreground"],
+        "markdown.h1": "bold " + SYMPHONY_COLORS["foreground"],
+        "markdown.h2": "bold " + SYMPHONY_COLORS["attribute"],
+        "markdown.h3": "bold " + SYMPHONY_COLORS["tag"],
+        "markdown.h4": "italic " + SYMPHONY_COLORS["subtext"],
+        "markdown.h5": "italic " + SYMPHONY_COLORS["comment"],
+        "markdown.h6": "dim " + SYMPHONY_COLORS["comment"],
+        "markdown.block_quote": SYMPHONY_COLORS["string"],
+        "markdown.list": SYMPHONY_COLORS["foreground"],
+        "markdown.item.bullet": "bold " + SYMPHONY_COLORS["function"],
+        "markdown.item.number": SYMPHONY_COLORS["function"],
+        "markdown.code": "bold " + SYMPHONY_COLORS["tag"],
+        "markdown.link": SYMPHONY_COLORS["function"],
+        "markdown.link_url": "underline " + SYMPHONY_COLORS["attribute"],
+        "markdown.table.border": SYMPHONY_COLORS["punctuation"],
+        "markdown.table.header": "bold " + SYMPHONY_COLORS["attribute"],
+        "markdown.kbd": "bold " + SYMPHONY_COLORS["type"],
+    },
+    inherit=True,
+)
+
+
+def themed_markdown(markup: str, **kwargs: object) -> Markdown:
+    """Build Rich Markdown using Symphony's syntax theme (not Rich's monokai default)."""
+    kwargs.setdefault("code_theme", SYMPHONY_CODE_THEME)
+    kwargs.setdefault("inline_code_theme", SYMPHONY_CODE_THEME)
+    return Markdown(markup, **kwargs)  # type: ignore[arg-type]