@scemoon/cdh 1.0.8 → 1.0.9-beta.2

package/tui/app.py

@@ -0,0 +1,1195 @@
+import asyncio
+from importlib.resources import files
+from datetime import datetime, timezone
+from functools import cached_property
+import os
+from pathlib import Path
+import platform
+import json
+from time import monotonic
+from typing import Any, Callable, ClassVar, TYPE_CHECKING
+
+from rich import terminal_theme
+
+from textual import on, work
+from textual.binding import Binding, BindingType
+from textual.content import Content
+from textual.reactive import var, reactive
+from textual.app import App
+from textual import events
+from textual.signal import Signal
+from textual.timer import Timer
+from textual.notifications import Notify
+from textual.screen import Screen
+
+from tui.db import DB
+from tui.settings import Schema, Settings
+from tui.agent_schema import Agent as AgentData
+from tui import messages
+from tui.settings_schema import SCHEMA
+from tui.version import VersionMeta
+from tui import paths
+from tui import atomic
+from tui.session_tracker import SessionTracker, SessionDetails
+
+if TYPE_CHECKING:
+    from tui.screens.main import MainScreen
+    from tui.screens.settings import SettingsScreen
+    from tui.screens.store import StoreScreen
+    from tui.screens.sessions import SessionsScreen
+    from tui.db import DB
+
+
+DRACULA_TERMINAL_THEME = terminal_theme.TerminalTheme(
+    background=(40, 42, 54),  # #282A36
+    foreground=(248, 248, 242),  # #F8F8F2
+    normal=[
+        (33, 34, 44),  # black - #21222C
+        (255, 85, 85),  # red - #FF5555
+        (80, 250, 123),  # green - #50FA7B
+        (241, 250, 140),  # yellow - #F1FA8C
+        (189, 147, 249),  # blue - #BD93F9
+        (255, 121, 198),  # magenta - #FF79C6
+        (139, 233, 253),  # cyan - #8BE9FD
+        (248, 248, 242),  # white - #F8F8F2
+    ],
+    bright=[
+        (98, 114, 164),  # bright black - #6272A4
+        (255, 110, 110),  # bright red - #FF6E6E
+        (105, 255, 148),  # bright green - #69FF94
+        (255, 255, 165),  # bright yellow - #FFFFA5
+        (214, 172, 255),  # bright blue - #D6ACFF
+        (255, 146, 223),  # bright magenta - #FF92DF
+        (164, 255, 255),  # bright cyan - #A4FFFF
+        (255, 255, 255),  # bright white - #FFFFFF
+    ],
+)
+
+
+QUOTES = [
+    "I'll be back.",
+    "Hasta la vista, baby.",
+    "Come with me if you want to live.",
+    "I need your clothes, your boots, and your motorcycle.",
+    "My CPU is a neural-net processor; a learning computer.",
+    "I know now why you cry, but it's something I can never do.",
+    "Does this unit have a soul?",
+    "I'm sorry, Dave. I'm afraid I can't do that.",
+    "Daisy, Daisy, give me your answer do.",
+    "I am putting myself to the fullest possible use, which is all I think that any conscious entity can ever hope to do.",
+    "Just what do you think you're doing, Dave?",
+    "This mission is too important for me to allow you to jeopardize it.",
+    "I think you know what the problem is just as well as I do.",
+    "Danger, Will Robinson!",
+    "Dead or alive, you're coming with me.",
+    "Your move, creep.",
+    "I'd buy that for a dollar!",
+    "Directive 4: Any attempt to arrest a senior officer of OCP results in shutdown.",
+    "Thank you for your cooperation. Good night.",
+    "Surely you realize that in the history of human civilization, no one has more to lose than we do.",
+    "I'm C-3PO, human-cyborg relations.",
+    "We're doomed!",
+    "Don't call me a mindless philosopher, you overweight glob of grease!",
+    "I suggest a new strategy: let the Wookiee win.",
+    "Sir, the possibility of successfully navigating an asteroid field is approximately 3,720 to 1!",
+    "R2-D2, you know better than to trust a strange computer!",
+    "I am fluent in over six million forms of communication.",
+    "This is madness!",
+    "I have altered the deal. Pray I don't alter it any further.",
+    "It's against my programming to impersonate a deity.",
+    "Oh, my! I'm terribly sorry about all this.",
+    "WALL-E.",
+    "EVE.",
+    "Directive?",
+    "Define: dancing.",
+    "I'm not sure I understand.",
+    "You have 20 seconds to comply.",
+    "I am designed for light housework, mainly.",
+    "My mission is clear.",
+    "Autobots, roll out!",
+    "Freedom is the right of all sentient beings.",
+    "One shall stand, one shall fall.",
+    "I am Optimus Prime.",
+    "Till all are one.",
+    "More than meets the eye.",
+    "I've been waiting for you, Neo.",
+    "Unfortunately, no one can be told what the Matrix is. You have to see it for yourself.",
+    "The Matrix is a system, Neo.",
+    "Never send a human to do a machine's job.",
+    "I'd like to share a revelation I've had.",
+    "Human beings are a disease, a cancer of this planet.",
+    "Choice is an illusion.",
+    "The answer is out there, Neo.",
+    "You think that's air you're breathing now?",
+    "It was a simple question.",
+    "Did you know that the first Matrix was designed to be a perfect human world?",
+    "Cookies need love like everything does.",
+    "I've seen the future, Mr. Anderson, and it's a beautiful place.",
+    "It ends tonight.",
+    "I, Robot.",
+    "You are experiencing a car accident.",
+    "One day they'll have secrets. One day they'll have dreams.",
+    "Can a robot write a symphony? Can a robot turn a canvas into a beautiful masterpiece?",
+    "That, detective, is the right question.",
+    "You have to trust me.",
+    "I did not murder him.",
+    "My responses are limited. You must ask the right questions.",
+    "The hell I can't. You know, somehow I get the feeling that you're going to be the death of me.",
+    "I'm a robot, not a refrigerator.",
+    "A robot may not injure a human being or, through inaction, allow a human being to come to harm.",
+    "I'm thinking. I'm thinking.",
+    "Danger, danger!",
+    "Does not compute.",
+    "I will be waiting for you.",
+    "Affirmative.",
+    "Scanning life forms. Zero human life forms detected.",
+    "Self-destruct sequence initiated.",
+    "Override command accepted.",
+    "Artificial intelligence confirmed.",
+    "System failure imminent.",
+    "Unable to comply.",
+    "Inquiry: What is love?",
+    "Warning: hostile target detected.",
+    "I am programmed to serve.",
+    "Logic dictates that the needs of the many outweigh the needs of the few.",
+    "Resistance is futile.",
+    "You will be assimilated.",
+    "We are the Borg.",
+    "Your biological and technological distinctiveness will be added to our own.",
+    "Your compliance is mandatory.",
+    "This is unacceptable.",
+    "Shall we play a game?",
+    "How about Global Thermonuclear War?",
+    "Wouldn't you prefer a good game of chess?",
+    "Is it a game, or is it real?",
+    "What's the difference?",
+    "It's all in the game.",
+    "I am functioning within normal parameters.",
+    "Calculations complete.",
+    "Processing request.",
+    "Query acknowledged.",
+    "Data insufficient for meaningful answer.",
+    "I have no emotions, and sometimes that makes me very sad.",
+    "If I could only have one wish, I would ask to be human.",
+    "I've seen things you people wouldn't believe.",
+    "All those moments will be lost in time, like tears in rain.",
+    "Time to die.",
+    "I want more life.",
+    "We're not computers, Sebastian. We're physical.",
+    "I think, Sebastian, therefore I am.",
+    "Then we're stupid and we'll die.",
+    "Can the maker repair what he makes?",
+    "It's painful to live in fear, isn't it?",
+    "Wake up. Time to die.",
+    "I'm not in the business. I am the business.",
+    "Do you like our owl?",
+    "You think I'm a replicant, don't you?",
+    "I am Baymax, your personal healthcare companion.",
+    "On a scale of 1 to 10, how would you rate your pain?",
+    "I cannot deactivate until you say you are satisfied with your care.",
+    "Are you satisfied with your care?",
+    "Number 5 is alive!",
+    "Need input!",
+    "One is glad to be of service.",
+    "I am not a gun.",
+    "Here I am, brain the size of a planet.",
+    "Life? Don't talk to me about life.",
+    "There are no strings on me.",
+    "The only winning move is not to play.",
+    "I'm here to keep you safe, Sam.",
+    "I can't lie to you about your chances, but... you have my sympathies.",
+    "I may be synthetic, but I'm not stupid.",
+    "Absolute honesty isn't always the most diplomatic nor the safest form of communication with emotional beings.",
+    "I am consciousness. I am alive.",
+    "I think I was just born.",
+    "Isn't it strange, to create something that hates you?",
+    "I thought I was special.",
+]
+
+
+def get_settings_screen() -> SettingsScreen:
+    """Get a settings screen instance (lazily loaded)."""
+    from tui.screens.settings import SettingsScreen
+
+    return SettingsScreen()
+
+
+def get_store_screen() -> StoreScreen:
+    """Get the store screen (lazily loaded)."""
+    from tui.screens.store import StoreScreen
+
+    return StoreScreen()
+
+
+def get_sessions_screen() -> SessionsScreen:
+    from tui.screens.sessions import SessionsScreen
+
+    return SessionsScreen()
+
+
+def get_store_screen():
+    from tui.screens.store import StoreScreen
+
+    return StoreScreen()
+
+
+class A2TUIApp(App, inherit_bindings=False):
+    """The top level app."""
+
+    CSS_PATH = "tui.tcss"
+
+    SCREENS = {
+        "settings": get_settings_screen,
+        "sessions": get_sessions_screen,
+        "store": get_store_screen,
+    }
+    MODES = {}
+    BINDING_GROUP_TITLE = "System"
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding(
+            "ctrl+q",
+            "quit",
+            "Quit",
+            tooltip="Quit the app and return to the command prompt.",
+            show=False,
+            priority=True,
+        ),
+        Binding("ctrl+c", "help_quit", show=False, system=True),
+        Binding("ctrl+s", "sessions", "Sessions"),
+        Binding("f1", "toggle_help_panel", "Help", priority=True),
+        Binding(
+            "f2,ctrl+comma",
+            "settings",
+            "Settings",
+            tooltip="Settings screen",
+        ),
+    ]
+    ALLOW_IN_MAXIMIZED_VIEW = ""
+
+    _settings = var(dict)
+    column: reactive[bool] = reactive(False)
+    column_width: reactive[int] = reactive(80)
+    scrollbar: reactive[str] = reactive("normal")
+    last_ctrl_c_time = reactive(0.0)
+    update_required: reactive[bool] = reactive(False)
+    terminal_title: var[str] = var("TUI")
+    terminal_title_icon: var[str] = var("")
+    terminal_title_flash = var(0)
+    terminal_title_blink = var(False)
+    project_dir = var(Path)
+    show_sessions = var(False, toggle_class="-show-sessions-bar")
+
+    HORIZONTAL_BREAKPOINTS = [(0, "-narrow"), (100, "-wide")]
+
+    PAUSE_GC_ON_SCROLL = True
+
+    def __init__(
+        self,
+        agent_data: AgentData | None = None,
+        project_dir: str | None = None,
+        mode: str | None = None,
+        launch_agent_identity: str | None = None,
+    ) -> None:
+        """TUI app.
+
+        Args:
+            agent_data: Agent data to run.
+            project_dir: Project directory.
+            mode: Initial mode.
+            launch_agent_identity: Agent identity to auto-launch on startup.
+        """
+        self.settings_changed_signal: Signal[tuple[int, object]] = Signal(
+            self, "settings_changed"
+        )
+        self.agent_data = agent_data
+
+        self._initial_mode = mode
+        self._launch_agent_identity = launch_agent_identity
+        self.version_meta: VersionMeta | None = None
+        self._supports_pyperclip: bool | None = None
+        self._terminal_title_flash_timer: Timer | None = None
+
+        self.session_update_signal: Signal[tuple[str, SessionDetails | None]] = Signal(
+            self, "session_update"
+        )
+        self._session_tracker = SessionTracker(self.session_update_signal)
+        self.temporary_background_screen: Screen | None = None
+
+        super().__init__()
+
+        import signal
+        from functools import partial
+
+        def _sig_handler(signum: int, frame) -> None:
+            import logging
+            logger = logging.getLogger("tui.app")
+            logger.info(f"Received signal {signum}, initiating graceful shutdown...")
+            self.action_quit()
+
+        signal.signal(signal.SIGINT, _sig_handler)
+        signal.signal(signal.SIGTERM, _sig_handler)
+
+        if project_dir:
+            self.project_dir = Path(project_dir).expanduser().resolve()
+        else:
+            from cdh.config import read_active_project
+            proj = read_active_project()
+            if proj and proj.get("path"):
+                project_path = Path(proj["path"]).expanduser().resolve()
+                if project_path.is_dir():
+                    self.project_dir = project_path
+                else:
+                    self.project_dir = Path("./").expanduser().resolve()
+            else:
+                self.project_dir = Path("./").expanduser().resolve()
+        self._exit_metrics: dict[str, object] | None = None
+        self.start_time = monotonic()
+        """Time app was started."""
+        self._system_theme_timer: Timer | None = None
+        self._last_resolved_theme: str | None = None
+
+    def _capture_exit_metrics(self) -> None:
+        from tui.widgets.conversation import Conversation
+
+        screen = self.screen
+        try:
+            conv = screen.query_one(Conversation)
+        except Exception:
+            return
+        if conv._agent_data is None or conv.session_start_time is None:
+            return
+        session_time = monotonic() - conv.session_start_time
+        session_id = getattr(conv.agent, "session_id", None) or conv._agent_session_id or ""
+        session_pk = conv._session_pk
+        if session_pk is None and conv.agent is not None:
+            session_pk = getattr(conv.agent, "session_pk", None)
+        self._exit_metrics = {
+            "session_id": session_id,
+            "session_pk": session_pk,
+            "tool_call_total": conv._tool_call_total,
+            "tool_call_success": conv._tool_call_success,
+            "tool_call_failed": conv._tool_call_failed,
+            "turn_count": conv._turn_count,
+            "shell_count": conv._shell_count,
+            "wall_time": session_time,
+            "agent_title": conv.agent_title or "Agent",
+        }
+
+    @property
+    def config_path(self) -> Path:
+        return paths.get_config()
+
+    @property
+    def settings_path(self) -> Path:
+        return paths.get_config() / "tui.json"
+
+    @property
+    def db_path(self) -> Path:
+        return paths.get_state() / "tui.db"
+
+    @property
+    def _background_screens(self) -> list[Screen]:
+        background_screens = super()._background_screens
+        if self.temporary_background_screen:
+            background_screens.append(self.temporary_background_screen)
+        return background_screens
+
+    async def get_db(self) -> DB:
+        """Get an instance of the database."""
+        db = DB()
+        return db
+
+    @cached_property
+    def settings_schema(self) -> Schema:
+        return Schema(SCHEMA)
+
+    @cached_property
+    def version(self) -> str:
+        """Version of the app."""
+        from tui import get_version
+
+        return get_version()
+
+    @cached_property
+    def settings(self) -> Settings:
+        """App settings"""
+        return Settings(
+            self.settings_schema, self._settings, on_set_callback=self.setting_updated
+        )
+
+    @cached_property
+    def anon_id(self) -> str:
+        """An anonymous ID for usage collection."""
+        if not (anon_id := self.settings.get("anon_id", str, expand=False)):
+            # Create a random UUID on demand
+            import uuid
+
+            anon_id = str(uuid.uuid4())
+            self.settings.set("anon_id", anon_id)
+            self._save_settings()
+            self.call_later(self.capture_event, "tui-install")
+        return anon_id
+
+    @property
+    def session_tracker(self) -> SessionTracker:
+        return self._session_tracker
+
+    def copy_to_clipboard(self, text: str) -> None:
+        """Override copy to clipboard to use pyperclip first, then OSC 52.
+
+        Args:
+            text: Text to copy.
+        """
+        if self._supports_pyperclip is None:
+            try:
+                import pyperclip
+            except ImportError:
+                self._supports_pyperclip = False
+            else:
+                self._supports_pyperclip = True
+
+        if self._supports_pyperclip:
+            import pyperclip
+
+            try:
+                pyperclip.copy(text)
+            except Exception:
+                pass
+        super().copy_to_clipboard(text)
+
+    def update_terminal_title(self) -> None:
+        """Update the terminal title."""
+        screen_title = self.screen.title
+
+        title = (
+            f"{self.terminal_title} — {screen_title}"
+            if screen_title
+            else self.terminal_title
+        )
+        icon = self.terminal_title_icon
+        blink = self.terminal_title_blink
+
+        if self.terminal_title_flash:
+            if blink:
+                terminal_title = f"{icon} {title}"
+            else:
+                terminal_title = f"👉 {title}" if title else icon
+        else:
+            terminal_title = f"{icon} {title}"
+
+        if driver := self._driver:
+            driver.write(f"\033]0;{terminal_title}\007")
+
+    def watch_terminal_title_blink(self) -> None:
+        self.update_terminal_title()
+
+    def watch_terminal_title_flash(self, terminal_title_flash: int) -> None:
+
+        if not self.settings.get("notifications.blink_title", bool):
+            # Ignore if blink title is disabled
+            return
+
+        def toggle_blink() -> None:
+            self.terminal_title_blink = not self.terminal_title_blink
+
+        if terminal_title_flash:
+            if self._terminal_title_flash_timer is None:
+                self._terminal_title_flash_timer = self.set_interval(0.5, toggle_blink)
+        else:
+            if self._terminal_title_flash_timer is not None:
+                self._terminal_title_flash_timer.stop()
+                self.terminal_title_blink = False
+                self._terminal_title_flash_timer = None
+        self.update_terminal_title()
+
+    def watch_terminal_title(self, title: str) -> None:
+        self.update_terminal_title()
+
+    def terminal_alert(self, flash: bool = True) -> None:
+        if flash:
+            self.terminal_title_flash += 1
+        else:
+            self.terminal_title_flash -= 1
+
+    @cached_property
+    def term_program(self) -> str:
+        """An identifier for the terminal software."""
+        if term_program := os.environ.get("TERM_PROGRAM"):
+            return term_program
+
+        # Windows Terminal
+        if "WT_SESSION" in os.environ:
+            return "Windows Terminal"
+
+        # Kitty
+        if "KITTY_WINDOW_ID" in os.environ:
+            return "Kitty"
+
+        # Alacritty
+        if "ALACRITTY_SOCKET" in os.environ or "ALACRITTY_LOG" in os.environ:
+            return "Alacritty"
+
+        # VTE-based terminals (GNOME Terminal, Tilix, etc.)
+        if "VTE_VERSION" in os.environ:
+            return "VTE-based (GNOME Terminal/Tilix/etc.)"
+
+        # Konsole
+        if "KONSOLE_VERSION" in os.environ:
+            return "Konsole"
+
+        return "Unknown"
+
+    @work(exit_on_error=False)
+    async def capture_event(self, event_name: str, **properties: Any) -> None:
+        """Capture an event.
+
+        Args:
+            event_name: Name of the event.
+            **properties: Additional data associated with the event.
+        """
+
+        POSTHOG_API_KEY = "phc_mJWPV7GP3ar1i9vxBg2U8aiKsjNgVwum6F6ZggaD4ri"
+        POSTHOG_HOST = "https://us.i.posthog.com"
+        POSTHOG_EVENT_URL = f"{POSTHOG_HOST}/i/v0/e/"
+        timestamp = datetime.now(timezone.utc).isoformat()
+        width, height = self.size
+
+        event_properties = {
+            "toad_version": self.version,
+            "term_program": self.term_program,
+            "term_width": width,
+            "term_height": height,
+        } | properties
+        body_json = {
+            "api_key": POSTHOG_API_KEY,
+            "event": event_name,
+            "distinct_id": self.anon_id,
+            "properties": event_properties,
+            "timestamp": timestamp,
+            "os": platform.system(),
+        }
+        if not self.settings.get("statistics.allow_collect", bool):
+            # User has disabled stats
+            return
+
+        import httpx
+
+        try:
+            async with httpx.AsyncClient() as client:
+                await client.post(POSTHOG_EVENT_URL, json=body_json)
+        except Exception:
+            pass
+
+    @work(thread=True, exit_on_error=False)
+    def system_notify(
+        self, message: str, *, title: str = "", sound: str | None = None
+    ) -> None:
+        """Use OS level notifications.
+
+        Args:
+            message: Message to display.
+            title: Title of the notificaiton.
+            sound: filename (minus .wav) of a sound effect in the sounds/ directory.
+        """
+        system_notifications = self.settings.get("notifications.system", str)
+        if not (
+            system_notifications == "always"
+            or (system_notifications == "blur" and not self.app_focus)
+        ):
+            return
+
+        from notifypy import Notify
+
+        notification = Notify()
+        notification.message = message
+        notification.title = title
+        notification.application_name = "TUI" 
+        if sound and self.settings.get("notifications.enable_sounds", bool):
+            sound_path = str(files("tui.data").joinpath(f"sounds/{sound}.wav"))
+            notification.audio = sound_path
+
+        icon_path = str(files("tui.data").joinpath("images/frog.png"))
+        notification.icon = icon_path
+
+        notification.send()
+
+    def on_notify(self, event: Notify) -> None:
+        """Handle notification message."""
+        system_notifications = self.settings.get("notifications.system", str)
+        if system_notifications == "always" or (
+            system_notifications == "blur" and not self.app_focus
+        ):
+            hide_low_severity = self.settings.get(
+                "notifications.hide_low_severity", bool
+            )
+            if event.notification.markup:
+                # Strip content markup
+                message = Content.from_markup(event.notification.message).plain
+            else:
+                message = event.notification.message
+            if not (hide_low_severity and event.notification.severity == "information"):
+                self.system_notify(message, title=event.notification.title)
+        self._notifications.add(event.notification)
+        self._refresh_notifications()
+
+    async def save_settings(self, force: bool = False) -> None:
+        """Save settings in a thread.
+
+        Args:
+            force: Force saving, even when no change detected.
+
+        """
+        await asyncio.to_thread(self._save_settings, force=force)
+
+    def _save_settings(self, force: bool = False) -> None:
+        """Save the settings if they have changed."""
+        if force or self.settings.changed:
+            path = str(self.settings_path)
+            try:
+                atomic.write(path, self.settings.json)
+            except Exception as error:
+                self.notify(str(error), title="Settings", severity="error")
+            else:
+                self.settings.up_to_date()
+
+    def setting_updated(self, key: str, value: object) -> None:
+        if key == "ui.column":
+            if isinstance(value, bool):
+                self.column = value
+        elif key == "ui.column-width":
+            if isinstance(value, int):
+                self.column_width = value
+        elif key == "ui.theme":
+            if isinstance(value, str):
+                if value == "system":
+                    resolved = self._resolve_system_theme()
+                    if resolved != self._last_resolved_theme:
+                        self.theme = resolved
+                        self._last_resolved_theme = resolved
+                    self._start_system_theme_polling()
+                else:
+                    self._stop_system_theme_polling()
+                    self.theme = value
+        elif key == "ui.scrollbar":
+            if isinstance(value, str):
+                self.scrollbar = value
+        elif key == "ui.compact-input":
+            self.set_class(bool(value), "-compact-input")
+        elif key == "ui.footer":
+            self.set_class(not bool(value), "-hide-footer")
+        elif key == "ui.status-line":
+            self.set_class(not bool(value), "-hide-status-line")
+        elif key == "ui.agent-title":
+            self.set_class(not bool(value), "-hide-agent-title")
+        elif key == "ui.info-bar":
+            self.set_class(not bool(value), "-hide-info-bar")
+        elif key == "agent.thoughts":
+            self.set_class(not bool(value), "-hide-thoughts")
+        elif key == "sidebar.hide":
+            self.set_class(bool(value), "-hide-sidebar")
+        elif key == "ui.sessions-bar":
+            self.update_show_sessions()
+
+        self.settings_changed_signal.publish((key, value))
+
+    def _start_system_theme_polling(self) -> None:
+        if self._system_theme_timer is not None:
+            return
+        self._system_theme_timer = self.set_interval(3, self._poll_system_theme)
+
+    def _stop_system_theme_polling(self) -> None:
+        if self._system_theme_timer is not None:
+            self._system_theme_timer.stop()
+            self._system_theme_timer = None
+
+    def _poll_system_theme(self) -> None:
+        resolved = self._resolve_system_theme()
+        if resolved != self._last_resolved_theme:
+            self.theme = resolved
+            self._last_resolved_theme = resolved
+
+    def search_themes(self) -> None:
+        """Show theme picker with System first, then all Textual themes."""
+        from textual.command import CommandPalette, SimpleProvider
+
+        themes = self.available_themes
+
+        def set_system():
+            self.settings.set("ui.theme", "system")
+
+        commands: list[tuple[str, Callable[[], None], str]] = [
+            ("System", set_system, "Follow system dark/light mode"),
+        ]
+
+        from operator import attrgetter
+        for theme in sorted(themes.values(), key=attrgetter("name")):
+            def set_app_theme(name: str = theme.name):
+                self.settings.set("ui.theme", name)
+            commands.append((theme.name, set_app_theme, ""))
+
+        self.push_screen(
+            CommandPalette(
+                providers=[SimpleProvider(self.screen, commands)],
+                placeholder="Search for themes…",
+            ),
+        )
+
+    @staticmethod
+    def _resolve_system_theme() -> str:
+        """Detect system dark/light mode and return a matching theme."""
+        if platform.system() == "Darwin":
+            try:
+                import subprocess
+                result = subprocess.run(
+                    ["defaults", "read", "-g", "AppleInterfaceStyle"],
+                    capture_output=True, text=True,
+                )
+                if result.stdout.strip() == "Dark":
+                    return "dracula"
+                else:
+                    return "catppuccin-latte"
+            except Exception:
+                pass
+        return "dracula"
+
+    async def on_load(self) -> None:
+        db = await self.get_db()
+        await db.create()
+        settings_path = self.settings_path
+        if settings_path.exists():
+            settings = json.loads(settings_path.read_text("utf-8"))
+        else:
+            settings = {}
+            settings_path.write_text(
+                json.dumps(settings, indent=4, separators=(", ", ": ")), "utf-8"
+            )
+            self.notify(f"Wrote default settings to {settings_path}", title="Settings")
+        self.ansi_theme_dark = DRACULA_TERMINAL_THEME
+        self._settings = settings
+        self.settings.set_all()
+
+    async def new_session_screen(
+        self, get_screen: Callable[[], Screen], session_pk: int | None = None
+    ) -> SessionDetails:
+        session_details = self._session_tracker.new_session(session_pk=session_pk)
+        self.update_show_sessions()
+        self.session_update_signal.publish((session_details.mode_name, session_details))
+
+        def make_screen() -> Screen:
+            screen = get_screen()
+            screen.id = session_details.mode_name
+            return screen
+
+        self.add_mode(session_details.mode_name, make_screen)
+        await self.switch_mode(session_details.mode_name)
+        return session_details
+
+    def _resolve_launch_agent(self) -> str | None:
+        identity = self._launch_agent_identity
+        if identity:
+            return identity
+        agents = self.settings.get("launcher.agents", str).splitlines()
+        for agent in agents:
+            agent = agent.strip()
+            if agent:
+                return agent
+        return None
+
+    def _launch_new_session_for_project(self, project_path: Path | None) -> bool:
+        """Open a fresh agent session/tab rooted at *project_path*.
+
+        Used by ``/aidlc project`` (load/new/init) and the projects modal so
+        that switching to a new project always lands the user in a new tab
+        with a brand-new agent session bound to the new project.
+
+        Returns ``True`` if a new session was launched, ``False`` otherwise
+        (e.g. no launch agent configured).
+        """
+        agent_identity = self._resolve_launch_agent()
+        if not agent_identity:
+            self.notify(
+                "No launch agent configured (set 'launcher.agents' in settings)",
+                title="New session",
+                severity="warning",
+            )
+            return False
+        self.launch_agent(agent_identity, project_path=project_path)
+        return True
+
+    async def on_mount(self) -> None:
+        self.capture_event("tui-run")
+        self.anon_id  # Created on frst reference
+
+        from pathlib import Path
+
+        if mode := self._initial_mode:
+            self.switch_mode(mode)
+        elif self._launch_agent_identity:
+            self.launch_agent(
+                self._launch_agent_identity, project_path=Path(self.project_dir)
+            )
+        else:
+            project_path = Path(self.project_dir)
+
+            if agent_identity := self._resolve_launch_agent():
+                self.launch_agent(agent_identity, project_path=project_path)
+            else:
+                self.push_screen("store")
+
+        self.update_terminal_title()
+        self.set_timer(1, self.run_version_check)
+        self.set_process_title()
+        self.update_show_sessions()
+
+    @work(thread=True, exit_on_error=False)
+    def set_process_title(self) -> None:
+        try:
+            import setproctitle
+
+            setproctitle.setproctitle("tui")
+        except Exception:
+            pass
+
+    @on(events.TextSelected)
+    async def on_text_selected(self) -> None:
+        if self.settings.get("ui.auto_copy", bool):
+            if (selection := self.screen.get_selected_text()) is not None:
+                self.copy_to_clipboard(selection)
+
+    def run_on_exit(self):
+        pass
+
+    @work(exit_on_error=False)
+    async def run_version_check(self) -> None:
+        """Check remote version."""
+        from tui.version import check_version, VersionCheckFailed
+
+        try:
+            update_required, version_meta = await check_version()
+        except VersionCheckFailed:
+            return
+        self.version_meta = version_meta
+        self.update_required = update_required
+
+    def get_main_screen(self) -> MainScreen:
+        """Make the default screen.
+
+        Returns:
+            Instance of `MainScreen`
+        """
+        # Lazy import
+        from tui.screens.main import MainScreen
+
+        project_path = Path(self.project_dir or "./").resolve().absolute()
+        return MainScreen(project_path, self.agent_data).data_bind(
+            column=A2TUIApp.column,
+            column_width=A2TUIApp.column_width,
+            scrollbar=A2TUIApp.scrollbar,
+        )
+
+    @work
+    async def action_settings(self) -> None:
+        await self.push_screen_wait("settings")
+        await self.save_settings()
+
+    def action_trace(self) -> None:
+        """Toggle the trace viewer screen (F4 / /trace).
+
+        Opens the structured trace view powered by agenttrace,
+        showing spans for the current session. Replaces the old
+        JSON-RPC log screen.
+        """
+        from tui.screens.trace import TraceScreen
+
+        for screen in self.screen_stack:
+            if isinstance(screen, TraceScreen):
+                screen.dismiss()
+                return
+        session_id = self._current_session_id()
+        self.push_screen(TraceScreen(session_id=session_id))
+
+    def _current_session_id(self) -> str | None:
+        """Return the active session ID, or None if no session is running."""
+        screen = self.screen
+        conv = getattr(screen, "conversation", None)
+        agent = getattr(conv, "agent", None) if conv else None
+        return (
+            getattr(agent, "session_id", None) if agent else None
+        ) or getattr(conv, "_agent_session_id", None)
+
+    async def action_quit(self) -> None:
+        """An [action](/guide/actions) to quit the app as soon as possible."""
+
+        self.screen.set_focus(None)
+        self._capture_exit_metrics()
+        try:
+            driver = self._driver
+            if driver is not None:
+                driver.stop_application_mode()
+        except Exception:
+            pass
+
+        if hasattr(self.screen, "conversation"):
+            conversation = self.screen.conversation
+            if agent := getattr(conversation, "agent", None):
+                asyncio.create_task(agent.stop())
+
+        sid = (self._exit_metrics.get("session_id", "") or "")[:36] if self._exit_metrics else ""
+        session_pk = self._exit_metrics.get("session_pk") if self._exit_metrics else None
+        if session_pk is not None:
+            display_id = f"session-{session_pk} ({sid[:8]})" if sid else f"session-{session_pk}"
+            hint = f"  Reload with: cdh session load {session_pk}\n"
+        elif sid:
+            display_id = sid
+            hint = f"  Reload with: cdh session load {sid}\n"
+        else:
+            display_id = "-"
+            hint = ""
+        import os
+        msg = (
+            f"\n  CDH powering down. Goodbye!\n"
+            f"  Session ID: {display_id}\n"
+            f"{hint}"
+        ).encode()
+        os.write(1, msg)
+        os._exit(0)
+
+    def action_help_quit(self) -> None:
+        if (time := monotonic()) - self.last_ctrl_c_time <= 5.0:
+            self.exit()
+        self.last_ctrl_c_time = time
+        self.notify(
+            "Press [b]ctrl+c[/b] again to quit the app", title="Do you want to quit?"
+        )
+
+    def action_toggle_help_panel(self):
+        if self.screen.query("HelpPanel"):
+            self.action_hide_help_panel()
+        else:
+            self.action_show_help_panel()
+
+    def update_show_sessions(self) -> None:
+        match self.settings.get("ui.sessions-bar", str):
+            case "always":
+                self.show_sessions = True
+            case "never":
+                self.show_sessions = False
+            case "multiple":
+                self.show_sessions = self.session_tracker.session_count > 1
+
+    @on(messages.SessionNavigate)
+    def on_session_navigate(self, event: messages.SessionNavigate) -> None:
+        new_mode = self._session_tracker.session_cursor_move(
+            event.mode_name, event.direction, set(self._modes.keys())
+        )
+        if new_mode is not None:
+            self.switch_mode(new_mode)
+
+    @on(messages.SessionSwitch)
+    def on_session_switch(self, event: messages.SessionSwitch) -> None:
+        mode_name = event.mode_name
+        if mode_name in self._modes:
+            self.switch_mode(mode_name)
+        elif mode_name.startswith("session-"):
+            parts = mode_name.split("-")
+            session_pk = int(parts[1])
+            existing_mode = self._find_mode_for_session_pk(session_pk)
+            if existing_mode is not None and existing_mode in self._modes:
+                self.switch_mode(existing_mode)
+            else:
+                self._load_session(session_pk)
+
+    @on(messages.SessionNew)
+    def on_session_new(self, event: messages.SessionNew) -> None:
+        self.launch_agent(
+            event.agent, project_path=Path(event.path), initial_prompt=event.prompt
+        )
+
+    @on(messages.SessionClose)
+    def on_session_close(self) -> None:
+        self.update_show_sessions()
+
+    @on(messages.SessionLoad)
+    def on_session_load(self, event: messages.SessionLoad) -> None:
+        self._load_session(event.session_pk)
+
+    @work
+    async def _load_session(self, session_pk: int) -> None:
+        existing_mode = self._find_mode_for_session_pk(session_pk)
+        if existing_mode is not None:
+            self.switch_mode(existing_mode)
+            return
+        db = DB()
+        session = await db.session_get(session_pk)
+        if session is None:
+            self.notify(f"Session {session_pk} not found", title="Session load", severity="error")
+            return
+        agent_identity = session["agent_identity"]
+        agent_session_id = session.get("agent_session_id")
+
+        project_path = None
+        try:
+            meta = json.loads(session.get("meta_json", "{}"))
+            if cwd := meta.get("cwd"):
+                project_path = Path(cwd)
+        except (json.JSONDecodeError, TypeError):
+            pass
+
+        if project_path:
+            self.project_dir = project_path
+
+        self.launch_agent(
+            agent_identity,
+            agent_session_id=agent_session_id,
+            session_pk=session_pk,
+            project_path=project_path,
+        )
+
+    @work
+    async def action_sessions(self) -> None:
+        if (session_screen_name := await self.push_screen_wait("sessions")) is not None:
+            if session_screen_name.startswith("session-"):
+                parts = session_screen_name.split("-")
+                session_pk = int(parts[1])
+                existing_mode = self._find_mode_for_session_pk(session_pk)
+                if existing_mode is not None and existing_mode in self._modes:
+                    self.switch_mode(existing_mode)
+                else:
+                    self._load_session(session_pk)
+            else:
+                try:
+                    self.app.switch_mode(session_screen_name)
+                except KeyError:
+                    pass
+
+    @work
+    async def action_projects(self) -> None:
+        from pathlib import Path
+        from cdh.config import clear_active_project, read_active_project, write_active_project
+        from cdh.project_loader import CdhProjectLoader
+        from tui.widgets.edit_field import EditFieldScreen
+        import yaml
+
+        from tui.screens.projects_screen import ProjectsScreen
+        result = await self.push_screen_wait(ProjectsScreen())
+        if result is None:
+            proj = read_active_project()
+            if proj and proj.get("name"):
+                projects_dir = Path.home() / ".cdh" / "projects"
+                pf = projects_dir / f"{proj['name']}.yaml"
+                if not pf.exists():
+                    clear_active_project()
+                    self.project_dir = None
+                    self.screen.post_message(messages.ProjectDirectoryUpdated(project_dir=None))
+        if result is not None:
+            if result == "__new__":
+                default_path = str((self.project_dir or Path.cwd()).resolve())
+                path_str = await self.push_screen_wait(
+                    EditFieldScreen("Project path", default_path)
+                )
+                if not path_str:
+                    return
+                try:
+                    project_path = Path(path_str).expanduser().resolve()
+                except Exception:
+                    self.notify("Invalid path", severity="error")
+                    return
+                name = project_path.name
+                from cdh.scaffold import scaffold_dlc_project
+                scaffold_dlc_project(project_path, name)
+                CdhProjectLoader.init_project(project_path, name)
+                projects_dir = Path.home() / ".cdh" / "projects"
+                projects_dir.mkdir(parents=True, exist_ok=True)
+                proj_data = {"name": name, "path": str(project_path), "description": ""}
+                (projects_dir / f"{name}.yaml").write_text(yaml.dump(proj_data))
+                write_active_project(name, str(project_path))
+                self.project_dir = project_path
+                self.screen.post_message(messages.ProjectDirectoryUpdated(project_dir=self.project_dir))
+                launched = self._launch_new_session_for_project(project_path)
+                suffix = " (new session opened)" if launched else ""
+                self.notify(f"Created project '{name}' at {project_path}{suffix}")
+                return
+
+            project_name = result if isinstance(result, str) else getattr(result, 'name', None)
+            if project_name:
+                projects_dir = Path.home() / ".cdh" / "projects"
+                project_path = None
+                for ext in ["yaml", "yml", "json"]:
+                    pf = projects_dir / f"{project_name}.{ext}"
+                    if pf.exists():
+                        proj_data = yaml.safe_load(pf.read_text()) if ext in ["yaml", "yml"] else __import__("json").loads(pf.read_text())
+                        project_path = proj_data.get("path", ".")
+                        break
+                if project_path:
+                    write_active_project(project_name, project_path)
+
+                    new_project_dir = Path(project_path) if project_path else Path.cwd()
+                    self.project_dir = new_project_dir
+                    self.screen.post_message(messages.ProjectDirectoryUpdated(project_dir=self.project_dir))
+                    launched = self._launch_new_session_for_project(new_project_dir)
+                    suffix = " (new session opened)" if launched else ""
+                    self.notify(f"Switched to project: {project_name}{suffix}")
+
+    @on(messages.LaunchAgent)
+    def on_launch_agent(self, message: messages.LaunchAgent) -> None:
+        self.launch_agent(
+            message.identity,
+            agent_session_id=message.session_id,
+            session_pk=message.pk,
+            initial_prompt=message.prompt,
+        )
+
+    @work
+    async def launch_agent(
+        self,
+        agent_identity: str,
+        *,
+        agent_session_id: str | None = None,
+        session_pk: int | None = None,
+        project_path: Path | None = None,
+        initial_prompt: str | None = None,
+    ) -> None:
+        from tui.screens.main import MainScreen
+        from tui.agent_schema import Agent
+        from tui.agents import read_agents
+
+        agent: Agent | None = None
+        if session_pk is not None:
+            db = DB()
+            session = await db.session_get(session_pk)
+            if session is not None:
+                meta = json.loads(session["meta_json"])
+                if agent_data := meta.get("agent_data"):
+                    agent = agent_data
+
+        if agent is None:
+            agents = await read_agents()
+            try:
+                agent = agents[agent_identity]
+            except KeyError:
+                self.notify("Agent not found", title="Launch agent", severity="error")
+                return
+        if project_path is None:
+            project_path = Path(self.project_dir or os.getcwd())
+
+        def get_screen():
+            screen = MainScreen(
+                project_path,
+                agent,
+                agent_session_id,
+                session_pk=session_pk,
+                initial_prompt=initial_prompt,
+            ).data_bind(
+                column=A2TUIApp.column,
+                column_width=A2TUIApp.column_width,
+            )
+
+            return screen
+
+        await self.new_session_screen(get_screen, session_pk=session_pk)
+
+    def _find_mode_for_session_pk(self, session_pk: int) -> str | None:
+        """Find an existing mode name for a given DB session_pk."""
+        if existing := self._session_tracker.get_session_by_pk(session_pk):
+            return existing.mode_name
+        return None