aline-ai 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

realign/dashboard/widgets/terminal_panel.py

@@ -1,8 +1,12 @@
-"""Terminal controls panel (tmux-backed).
+"""Terminal controls panel with native terminal and tmux support.
 
-This panel does not embed a terminal widget. Instead it controls a tmux layout:
-- Left pane: Aline dashboard
-- Right pane: an inner tmux session with multiple "terminal tabs" as tmux windows
+This panel controls terminal tabs in either:
+1. Native terminals (iTerm2/Kitty) - for better performance with high-frequency updates
+2. tmux - the traditional approach with embedded terminal rendering
+
+The mode is determined by the ALINE_TERMINAL_MODE environment variable:
+- "native" or "iterm2" or "kitty": Use native terminal backend
+- "tmux" or unset: Use tmux backend (default)
 """
 
 from __future__ import annotations
@@ -13,7 +17,7 @@ import re
 import shlex
 import traceback
 from pathlib import Path
-from typing import Callable
+from typing import Callable, Union
 
 from textual.app import ComposeResult
 from textual.containers import Container, Horizontal, Vertical, VerticalScroll
@@ -22,6 +26,7 @@ from textual.widgets import Button, Static
 from rich.text import Text
 
 from .. import tmux_manager
+from ..terminal_backend import TerminalBackend, TerminalInfo
 from ...logging_config import setup_logger
 
 logger = setup_logger("realign.dashboard.terminal", "dashboard.log")
@@ -30,6 +35,19 @@ logger = setup_logger("realign.dashboard.terminal", "dashboard.log")
 # Signal directory for permission request notifications
 PERMISSION_SIGNAL_DIR = Path.home() / ".aline" / ".signals" / "permission_request"
 
+# Environment variable to control terminal mode
+ENV_TERMINAL_MODE = "ALINE_TERMINAL_MODE"
+
+# Terminal mode constants
+MODE_TMUX = "tmux"
+MODE_NATIVE = "native"
+MODE_ITERM2 = "iterm2"
+MODE_KITTY = "kitty"
+
+
+# Type for window data (either tmux InnerWindow or native TerminalInfo)
+WindowData = Union[tmux_manager.InnerWindow, TerminalInfo]
+
 
 class _SignalFileWatcher:
     """Watches for new signal files in the permission_request directory.
@@ -128,8 +146,75 @@ class _SignalFileWatcher:
             pass
 
 
+def _detect_terminal_mode() -> str:
+    """Detect which terminal mode to use.
+
+    Returns:
+        Terminal mode string (MODE_TMUX, MODE_ITERM2, or MODE_KITTY)
+    """
+    mode = os.environ.get(ENV_TERMINAL_MODE, "").strip().lower()
+
+    if mode in {MODE_ITERM2, "iterm"}:
+        return MODE_ITERM2
+    if mode == MODE_KITTY:
+        return MODE_KITTY
+    if mode == MODE_NATIVE:
+        # Auto-detect best native terminal
+        term_program = os.environ.get("TERM_PROGRAM", "").strip()
+        if term_program in {"iTerm.app", "iTerm2"} or term_program.startswith("iTerm"):
+            return MODE_ITERM2
+        if term_program == "kitty":
+            return MODE_KITTY
+        # Default to iTerm2 on macOS
+        import sys
+        if sys.platform == "darwin":
+            return MODE_ITERM2
+        return MODE_TMUX
+
+    # Default to tmux
+    return MODE_TMUX
+
+
+async def _get_native_backend(mode: str) -> TerminalBackend | None:
+    """Get the appropriate native terminal backend.
+
+    Args:
+        mode: Terminal mode (MODE_ITERM2 or MODE_KITTY)
+
+    Returns:
+        Backend instance if available, None otherwise
+    """
+    if mode == MODE_ITERM2:
+        try:
+            from ..backends.iterm2 import ITermBackend
+
+            # Check for split pane session ID from environment
+            right_pane_session_id = os.environ.get("ALINE_ITERM2_RIGHT_PANE")
+            if right_pane_session_id:
+                logger.debug(f"Using split pane mode with right pane: {right_pane_session_id}")
+
+            backend = ITermBackend(right_pane_session_id=right_pane_session_id)
+            if await backend.is_available():
+                return backend
+        except Exception as e:
+            logger.debug(f"iTerm2 backend not available: {e}")
+    elif mode == MODE_KITTY:
+        try:
+            from ..backends.kitty import KittyBackend
+            backend = KittyBackend()
+            if await backend.is_available():
+                return backend
+        except Exception as e:
+            logger.debug(f"Kitty backend not available: {e}")
+
+    return None
+
+
 class TerminalPanel(Container, can_focus=True):
-    """Terminal controls panel with permission request notifications."""
+    """Terminal controls panel with permission request notifications.
+
+    Supports both native terminal backends (iTerm2/Kitty) and tmux.
+    """
 
     class PermissionRequestDetected(Message):
         """Posted when a new permission request signal file is detected."""
@@ -258,42 +343,83 @@ class TerminalPanel(Container, can_focus=True):
 
     @staticmethod
     def supported() -> bool:
-        return (
-            tmux_manager.tmux_available()
-            and tmux_manager.in_tmux()
-            and tmux_manager.managed_env_enabled()
-        )
+        """Check if terminal controls are supported.
+
+        Supports both native terminal mode and tmux mode.
+        """
+        mode = _detect_terminal_mode()
+
+        if mode == MODE_TMUX:
+            return (
+                tmux_manager.tmux_available()
+                and tmux_manager.in_tmux()
+                and tmux_manager.managed_env_enabled()
+            )
+
+        # For native mode, we check availability asynchronously in refresh_data
+        # Here we just return True if native mode is requested
+        return mode in {MODE_ITERM2, MODE_KITTY}
 
     @staticmethod
     def _support_message() -> str:
-        if not tmux_manager.tmux_available():
-            return "tmux not installed. Run `aline add tmux`, then restart `aline`."
-        if not tmux_manager.in_tmux():
-            return "Not running inside tmux. Restart with `aline` to enable terminal controls."
-        if not tmux_manager.managed_env_enabled():
-            return "Not in an Aline-managed tmux session. Start via `aline` to enable terminal controls."
+        mode = _detect_terminal_mode()
+
+        if mode == MODE_TMUX:
+            if not tmux_manager.tmux_available():
+                return "tmux not installed. Run `aline add tmux`, then restart `aline`."
+            if not tmux_manager.in_tmux():
+                return "Not running inside tmux. Restart with `aline` to enable terminal controls."
+            if not tmux_manager.managed_env_enabled():
+                return "Not in an Aline-managed tmux session. Start via `aline` to enable terminal controls."
+        elif mode == MODE_ITERM2:
+            return "iTerm2 Python API not available. Install with: pip install iterm2"
+        elif mode == MODE_KITTY:
+            return "Kitty remote control not available. Configure listen_on in kitty.conf"
+
         return ""
 
     @staticmethod
-    def _is_claude_window(w: tmux_manager.InnerWindow) -> bool:
-        # Prefer an explicit "cc"/"cc-N" window name because those are created by the dashboard.
-        # This avoids accidental relabeling when external hooks set @aline_provider/@aline_session_type
-        # on unrelated windows (e.g. "codex-2").
+    def _is_claude_window(w: WindowData) -> bool:
+        """Check if a window is a Claude terminal."""
+        if isinstance(w, TerminalInfo):
+            # Native terminal: check provider
+            return w.provider == "claude"
+
+        # tmux: check window name and tags
         window_name = (w.window_name or "").strip().lower()
         if re.fullmatch(r"cc(?:-\d+)?", window_name or ""):
             return True
 
-        # Fallback: treat as Claude only when it looks Aline-managed (terminal_id/context_id),
-        # not merely because a hook tagged the window.
         is_claude_tagged = (w.provider == "claude") or (w.session_type == "claude")
         return bool(is_claude_tagged and (w.terminal_id or w.context_id))
 
-    def __init__(self) -> None:
+    def __init__(self, use_native_terminal: bool | None = None) -> None:
+        """Initialize the terminal panel.
+
+        Args:
+            use_native_terminal: If True, use native terminal backend.
+                                 If False, use tmux.
+                                 If None (default), auto-detect from environment.
+        """
         super().__init__()
         self._refresh_lock = asyncio.Lock()
         self._expanded_window_id: str | None = None
         self._signal_watcher: _SignalFileWatcher | None = None
 
+        # Determine terminal mode
+        if use_native_terminal is True:
+            self._mode = _detect_terminal_mode()
+            if self._mode == MODE_TMUX:
+                self._mode = MODE_ITERM2  # Default to iTerm2 if native requested
+        elif use_native_terminal is False:
+            self._mode = MODE_TMUX
+        else:
+            self._mode = _detect_terminal_mode()
+
+        # Native backend (initialized lazily)
+        self._native_backend: TerminalBackend | None = None
+        self._native_backend_checked = False
+
     def compose(self) -> ComposeResult:
         logger.debug("TerminalPanel.compose() started")
         try:
@@ -318,9 +444,6 @@ class TerminalPanel(Container, can_focus=True):
             raise
 
     def on_show(self) -> None:
-        # Don't `await refresh_data()` directly here: Textual may do an initial layout pass with
-        # width=0 while a widget becomes visible, and Rich can raise when wrapping text at width 0.
-        # Scheduling after the next refresh avoids a hard crash ("flash exit") when entering the tab.
         self.call_after_refresh(
             lambda: self.run_worker(
                 self.refresh_data(),
@@ -328,11 +451,9 @@ class TerminalPanel(Container, can_focus=True):
                 exclusive=True,
             )
         )
-        # Start watching for permission request signals
         self._start_signal_watcher()
 
     def on_hide(self) -> None:
-        # Stop watching when panel is hidden
         self._stop_signal_watcher()
 
     def _start_signal_watcher(self) -> None:
@@ -350,7 +471,6 @@ class TerminalPanel(Container, can_focus=True):
 
     def _on_permission_signal(self) -> None:
         """Called when a new permission request signal is detected."""
-        # Post message to trigger refresh on the main thread
         self.post_message(self.PermissionRequestDetected())
 
     def on_terminal_panel_permission_request_detected(
@@ -363,52 +483,135 @@ class TerminalPanel(Container, can_focus=True):
             exclusive=True,
         )
 
+    async def _ensure_native_backend(self) -> TerminalBackend | None:
+        """Ensure native backend is initialized."""
+        if self._native_backend_checked:
+            return self._native_backend
+
+        self._native_backend_checked = True
+
+        if self._mode in {MODE_ITERM2, MODE_KITTY}:
+            self._native_backend = await _get_native_backend(self._mode)
+
+        return self._native_backend
+
+    def _is_native_mode(self) -> bool:
+        """Check if we're using native terminal mode."""
+        return self._mode in {MODE_ITERM2, MODE_KITTY}
+
     async def refresh_data(self) -> None:
         async with self._refresh_lock:
+            if self._is_native_mode():
+                await self._refresh_native_data()
+            else:
+                await self._refresh_tmux_data()
+
+    async def _refresh_native_data(self) -> None:
+        """Refresh data using native terminal backend."""
+        backend = await self._ensure_native_backend()
+        if not backend:
+            # Fall back to showing error message
             try:
-                supported = self.supported()
+                container = self.query_one("#terminals", Vertical)
+                await container.remove_children()
+                await container.mount(Static(self._support_message()))
             except Exception:
-                return
+                pass
+            return
 
-            if not supported:
-                return
+        try:
+            windows = await backend.list_tabs()
+        except Exception as e:
+            logger.error(f"Failed to list native terminals: {e}")
+            return
 
-            try:
-                windows = tmux_manager.list_inner_windows()
-            except Exception:
-                return
-            active_window_id = next((w.window_id for w in windows if w.active), None)
-            if self._expanded_window_id and self._expanded_window_id != active_window_id:
-                self._expanded_window_id = None
-            claude_ids = [
-                w.session_id for w in windows if self._is_claude_window(w) and w.session_id
-            ]
-            titles = self._fetch_claude_session_titles(claude_ids)
-
-            context_info_by_context_id: dict[str, tuple[list[str], int, int]] = {}
-            all_context_session_ids: set[str] = set()
-            for w in windows:
-                if not self._is_claude_window(w) or not w.context_id:
-                    continue
-                session_ids, session_count, event_count = self._get_loaded_context_info(
-                    w.context_id
-                )
-                if not session_ids and session_count == 0 and event_count == 0:
-                    continue
-                context_info_by_context_id[w.context_id] = (
-                    session_ids,
-                    session_count,
-                    event_count,
-                )
-                all_context_session_ids.update(session_ids)
+        active_window_id = next(
+            (w.session_id for w in windows if w.active), None
+        )
+        if self._expanded_window_id and self._expanded_window_id != active_window_id:
+            self._expanded_window_id = None
 
-            if all_context_session_ids:
-                titles.update(self._fetch_claude_session_titles(sorted(all_context_session_ids)))
+        # Get Claude session IDs for title lookup
+        claude_ids = [
+            w.claude_session_id for w in windows
+            if self._is_claude_window(w) and w.claude_session_id
+        ]
+        titles = self._fetch_claude_session_titles(claude_ids)
 
-            try:
-                await self._render_terminals(windows, titles, context_info_by_context_id)
-            except Exception:
-                return
+        # Get context info
+        context_info_by_context_id: dict[str, tuple[list[str], int, int]] = {}
+        all_context_session_ids: set[str] = set()
+        for w in windows:
+            if not self._is_claude_window(w) or not w.context_id:
+                continue
+            session_ids, session_count, event_count = self._get_loaded_context_info(
+                w.context_id
+            )
+            if not session_ids and session_count == 0 and event_count == 0:
+                continue
+            context_info_by_context_id[w.context_id] = (
+                session_ids,
+                session_count,
+                event_count,
+            )
+            all_context_session_ids.update(session_ids)
+
+        if all_context_session_ids:
+            titles.update(self._fetch_claude_session_titles(sorted(all_context_session_ids)))
+
+        try:
+            await self._render_terminals_native(windows, titles, context_info_by_context_id)
+        except Exception:
+            return
+
+    async def _refresh_tmux_data(self) -> None:
+        """Refresh data using tmux backend."""
+        try:
+            supported = self.supported()
+        except Exception:
+            return
+
+        if not supported:
+            return
+
+        try:
+            windows = tmux_manager.list_inner_windows()
+        except Exception:
+            return
+
+        active_window_id = next((w.window_id for w in windows if w.active), None)
+        if self._expanded_window_id and self._expanded_window_id != active_window_id:
+            self._expanded_window_id = None
+
+        claude_ids = [
+            w.session_id for w in windows if self._is_claude_window(w) and w.session_id
+        ]
+        titles = self._fetch_claude_session_titles(claude_ids)
+
+        context_info_by_context_id: dict[str, tuple[list[str], int, int]] = {}
+        all_context_session_ids: set[str] = set()
+        for w in windows:
+            if not self._is_claude_window(w) or not w.context_id:
+                continue
+            session_ids, session_count, event_count = self._get_loaded_context_info(
+                w.context_id
+            )
+            if not session_ids and session_count == 0 and event_count == 0:
+                continue
+            context_info_by_context_id[w.context_id] = (
+                session_ids,
+                session_count,
+                event_count,
+            )
+            all_context_session_ids.update(session_ids)
+
+        if all_context_session_ids:
+            titles.update(self._fetch_claude_session_titles(sorted(all_context_session_ids)))
+
+        try:
+            await self._render_terminals_tmux(windows, titles, context_info_by_context_id)
+        except Exception:
+            return
 
     def _fetch_claude_session_titles(self, session_ids: list[str]) -> dict[str, str]:
         if not session_ids:
@@ -428,10 +631,7 @@ class TerminalPanel(Container, can_focus=True):
             return {}
 
     def _get_loaded_context_info(self, context_id: str) -> tuple[list[str], int, int]:
-        """Best-effort: read ~/.aline/load.json for a context_id, and return its session ids.
-
-        Also expands any context event ids to their constituent sessions (when DB is available).
-        """
+        """Best-effort: read ~/.aline/load.json for a context_id, and return its session ids."""
         context_id = (context_id or "").strip()
         if not context_id:
             return ([], 0, 0)
@@ -473,12 +673,103 @@ class TerminalPanel(Container, can_focus=True):
         except Exception:
             return ([], 0, 0)
 
-    async def _render_terminals(
+    async def _render_terminals_native(
+        self,
+        windows: list[TerminalInfo],
+        titles: dict[str, str],
+        context_info_by_context_id: dict[str, tuple[list[str], int, int]],
+    ) -> None:
+        """Render terminal list for native backend."""
+        container = self.query_one("#terminals", Vertical)
+        await container.remove_children()
+
+        if not windows:
+            await container.mount(
+                Static("No terminals yet. Click 'Create' to open a new agent terminal.")
+            )
+            return
+
+        for w in windows:
+            safe = self._safe_id_fragment(w.session_id)
+            row = Horizontal(classes="terminal-row")
+            await container.mount(row)
+
+            if w.attention:
+                await row.mount(Static("●", classes="attention-dot"))
+
+            switch_classes = "terminal-switch active" if w.active else "terminal-switch"
+            loaded_ids: list[str] = []
+            raw_sessions = 0
+            raw_events = 0
+            if self._is_claude_window(w) and w.context_id:
+                loaded_ids, raw_sessions, raw_events = context_info_by_context_id.get(
+                    w.context_id, ([], 0, 0)
+                )
+
+            label = self._window_label_native(w, titles, raw_sessions, raw_events)
+            await row.mount(
+                Button(
+                    label,
+                    id=f"switch-{safe}",
+                    name=w.session_id,
+                    classes=switch_classes,
+                )
+            )
+
+            can_toggle_ctx = bool(
+                self._is_claude_window(w) and w.context_id and (raw_sessions or raw_events)
+            )
+            expanded = bool(w.active and w.session_id == self._expanded_window_id)
+            if w.active and can_toggle_ctx:
+                await row.mount(
+                    Button(
+                        "▼" if expanded else "▶",
+                        id=f"toggle-{safe}",
+                        name=w.session_id,
+                        variant="default",
+                        classes="terminal-toggle",
+                    )
+                )
+
+            await row.mount(
+                Button(
+                    "✕",
+                    id=f"close-{safe}",
+                    name=w.session_id,
+                    variant="error",
+                    classes="terminal-close",
+                )
+            )
+
+            if w.active and self._is_claude_window(w) and w.context_id and expanded:
+                ctx = VerticalScroll(id=f"ctx-{safe}", classes="context-sessions")
+                await container.mount(ctx)
+                if loaded_ids:
+                    for idx, sid in enumerate(loaded_ids):
+                        title = titles.get(sid, "").strip() or "(no title)"
+                        await ctx.mount(
+                            Button(
+                                f"{title} ({self._short_id(sid)})",
+                                id=f"ctxsess-{safe}-{idx}",
+                                name=sid,
+                                variant="default",
+                                classes="context-session",
+                            )
+                        )
+                else:
+                    await ctx.mount(
+                        Static(
+                            "[dim]Context loaded, but session list isn't available (events not expanded).[/dim]"
+                        )
+                    )
+
+    async def _render_terminals_tmux(
         self,
         windows: list[tmux_manager.InnerWindow],
         titles: dict[str, str],
         context_info_by_context_id: dict[str, tuple[list[str], int, int]],
     ) -> None:
+        """Render terminal list for tmux backend."""
         container = self.query_one("#terminals", Vertical)
         await container.remove_children()
 
@@ -503,7 +794,7 @@ class TerminalPanel(Container, can_focus=True):
                 loaded_ids, raw_sessions, raw_events = context_info_by_context_id.get(
                     w.context_id, ([], 0, 0)
                 )
-            label = self._window_label(w, titles, raw_sessions, raw_events)
+            label = self._window_label_tmux(w, titles, raw_sessions, raw_events)
             await row.mount(
                 Button(
                     label,
@@ -528,7 +819,6 @@ class TerminalPanel(Container, can_focus=True):
                 )
             await row.mount(
                 Button(
-                    # Avoid Rich crash when measured with width=0.
                     "✕",
                     id=f"close-{safe}",
                     name=w.window_id,
@@ -570,13 +860,45 @@ class TerminalPanel(Container, can_focus=True):
             return "ctx 0"
         return "ctx " + " ".join(parts)
 
-    def _window_label(
+    def _window_label_native(
+        self,
+        w: TerminalInfo,
+        titles: dict[str, str],
+        raw_sessions: int = 0,
+        raw_events: int = 0,
+    ) -> str | Text:
+        """Generate label for native terminal window."""
+        if not self._is_claude_window(w):
+            return Text(w.name, no_wrap=True, overflow="ellipsis")
+
+        title = titles.get(w.claude_session_id or "", "").strip() if w.claude_session_id else ""
+        header = title or ("Claude" if w.claude_session_id else "New Claude")
+
+        details = Text(no_wrap=True, overflow="ellipsis")
+        details.append(header)
+        details.append("\n")
+
+        detail_line = "[Claude]"
+        if w.claude_session_id:
+            detail_line = f"{detail_line} #{self._short_id(w.claude_session_id)}"
+        if w.active:
+            loaded_count = raw_sessions + raw_events
+            detail_line = f"{detail_line} | loaded context: {loaded_count}"
+        else:
+            detail_line = (
+                f"{detail_line} · {self._format_context_summary(raw_sessions, raw_events)}"
+            )
+        details.append(detail_line, style="dim not bold")
+        return details
+
+    def _window_label_tmux(
         self,
         w: tmux_manager.InnerWindow,
         titles: dict[str, str],
         raw_sessions: int = 0,
         raw_events: int = 0,
     ) -> str | Text:
+        """Generate label for tmux window."""
         if not self._is_claude_window(w):
             return Text(w.window_name, no_wrap=True, overflow="ellipsis")
 
@@ -587,7 +909,6 @@ class TerminalPanel(Container, can_focus=True):
         details.append(header)
         details.append("\n")
 
-        # Build detail line with Claude label
         detail_line = "[Claude]"
         if w.session_id:
             detail_line = f"{detail_line} #{self._short_id(w.session_id)}"
@@ -653,6 +974,59 @@ class TerminalPanel(Container, can_focus=True):
         self, workspace: str, *, skip_permissions: bool = False
     ) -> None:
         """Create a new Claude terminal."""
+        if self._is_native_mode():
+            await self._create_claude_terminal_native(workspace, skip_permissions=skip_permissions)
+        else:
+            await self._create_claude_terminal_tmux(workspace, skip_permissions=skip_permissions)
+
+    async def _create_claude_terminal_native(
+        self, workspace: str, *, skip_permissions: bool = False
+    ) -> None:
+        """Create a new Claude terminal using native backend."""
+        backend = await self._ensure_native_backend()
+        if not backend:
+            self.app.notify(
+                "Native terminal backend not available",
+                title="Terminal",
+                severity="error",
+            )
+            return
+
+        terminal_id = tmux_manager.new_terminal_id()
+        context_id = tmux_manager.new_context_id("cc")
+
+        env = {
+            tmux_manager.ENV_TERMINAL_ID: terminal_id,
+            tmux_manager.ENV_TERMINAL_PROVIDER: "claude",
+            tmux_manager.ENV_CONTEXT_ID: context_id,
+        }
+
+        # Install hooks
+        self._install_claude_hooks(workspace)
+
+        claude_cmd = "claude"
+        if skip_permissions:
+            claude_cmd = "claude --dangerously-skip-permissions"
+
+        session_id = await backend.create_tab(
+            command=claude_cmd,
+            terminal_id=terminal_id,
+            name="Claude Code",
+            env=env,
+            cwd=workspace,
+        )
+
+        if not session_id:
+            self.app.notify(
+                "Failed to open Claude terminal",
+                title="Terminal",
+                severity="error",
+            )
+
+    async def _create_claude_terminal_tmux(
+        self, workspace: str, *, skip_permissions: bool = False
+    ) -> None:
+        """Create a new Claude terminal using tmux backend."""
         terminal_id = tmux_manager.new_terminal_id()
         context_id = tmux_manager.new_context_id("cc")
         env = {
@@ -663,6 +1037,27 @@ class TerminalPanel(Container, can_focus=True):
             tmux_manager.ENV_CONTEXT_ID: context_id,
         }
 
+        # Install hooks
+        self._install_claude_hooks(workspace)
+
+        claude_cmd = "claude"
+        if skip_permissions:
+            claude_cmd = "claude --dangerously-skip-permissions"
+        command = self._command_in_directory(
+            tmux_manager.zsh_run_and_keep_open(claude_cmd), workspace
+        )
+        created = tmux_manager.create_inner_window(
+            "cc",
+            tmux_manager.shell_command_with_env(command, env),
+            terminal_id=terminal_id,
+            provider="claude",
+            context_id=context_id,
+        )
+        if not created:
+            self.app.notify("Failed to open Claude terminal", title="Terminal", severity="error")
+
+    def _install_claude_hooks(self, workspace: str) -> None:
+        """Install Claude hooks for a workspace."""
         try:
             from ...claude_hooks.stop_hook_installer import (
                 ensure_stop_hook_installed,
@@ -712,24 +1107,25 @@ class TerminalPanel(Container, can_focus=True):
         except Exception:
             pass
 
-        claude_cmd = "claude"
-        if skip_permissions:
-            claude_cmd = "claude --dangerously-skip-permissions"
-        command = self._command_in_directory(
-            tmux_manager.zsh_run_and_keep_open(claude_cmd), workspace
-        )
-        created = tmux_manager.create_inner_window(
-            "cc",
-            tmux_manager.shell_command_with_env(command, env),
-            terminal_id=terminal_id,
-            provider="claude",
-            context_id=context_id,
-        )
-        if not created:
-            self.app.notify("Failed to open Claude terminal", title="Terminal", severity="error")
-
     async def _create_codex_terminal(self, workspace: str) -> None:
         """Create a new Codex terminal."""
+        if self._is_native_mode():
+            backend = await self._ensure_native_backend()
+            if backend:
+                terminal_id = tmux_manager.new_terminal_id()
+                session_id = await backend.create_tab(
+                    command="codex",
+                    terminal_id=terminal_id,
+                    name="Codex",
+                    cwd=workspace,
+                )
+                if not session_id:
+                    self.app.notify(
+                        "Failed to open Codex terminal", title="Terminal", severity="error"
+                    )
+                return
+
+        # Tmux fallback
         command = self._command_in_directory(
             tmux_manager.zsh_run_and_keep_open("codex"), workspace
         )
@@ -739,6 +1135,23 @@ class TerminalPanel(Container, can_focus=True):
 
     async def _create_opencode_terminal(self, workspace: str) -> None:
         """Create a new Opencode terminal."""
+        if self._is_native_mode():
+            backend = await self._ensure_native_backend()
+            if backend:
+                terminal_id = tmux_manager.new_terminal_id()
+                session_id = await backend.create_tab(
+                    command="opencode",
+                    terminal_id=terminal_id,
+                    name="Opencode",
+                    cwd=workspace,
+                )
+                if not session_id:
+                    self.app.notify(
+                        "Failed to open Opencode terminal", title="Terminal", severity="error"
+                    )
+                return
+
+        # Tmux fallback
         command = self._command_in_directory(
             tmux_manager.zsh_run_and_keep_open("opencode"), workspace
         )
@@ -748,6 +1161,23 @@ class TerminalPanel(Container, can_focus=True):
 
     async def _create_zsh_terminal(self, workspace: str) -> None:
         """Create a new zsh terminal."""
+        if self._is_native_mode():
+            backend = await self._ensure_native_backend()
+            if backend:
+                terminal_id = tmux_manager.new_terminal_id()
+                session_id = await backend.create_tab(
+                    command="zsh -l",
+                    terminal_id=terminal_id,
+                    name="zsh",
+                    cwd=workspace,
+                )
+                if not session_id:
+                    self.app.notify(
+                        "Failed to open zsh terminal", title="Terminal", severity="error"
+                    )
+                return
+
+        # Tmux fallback
         command = self._command_in_directory("zsh", workspace)
         created = tmux_manager.create_inner_window("zsh", command)
         if not created:
@@ -771,14 +1201,7 @@ class TerminalPanel(Container, can_focus=True):
             return
 
         if button_id.startswith("switch-"):
-            window_id = event.button.name or ""
-            if not window_id or not tmux_manager.select_inner_window(window_id):
-                self.app.notify("Failed to switch terminal", title="Terminal", severity="error")
-            # Clear attention when user clicks on terminal
-            if window_id:
-                tmux_manager.clear_attention(window_id)
-            self._expanded_window_id = None
-            await self.refresh_data()
+            await self._handle_switch(event.button.name or "")
             return
 
         if button_id.startswith("toggle-"):
@@ -805,7 +1228,46 @@ class TerminalPanel(Container, can_focus=True):
             return
 
         if button_id.startswith("close-"):
-            window_id = event.button.name or ""
-            if not window_id or not tmux_manager.kill_inner_window(window_id):
+            await self._handle_close(event.button.name or "")
+            return
+
+    async def _handle_switch(self, window_id: str) -> None:
+        """Handle switching to a terminal."""
+        if not window_id:
+            return
+
+        if self._is_native_mode():
+            backend = await self._ensure_native_backend()
+            if backend:
+                success = await backend.focus_tab(window_id, steal_focus=False)
+                if not success:
+                    self.app.notify(
+                        "Failed to switch terminal", title="Terminal", severity="error"
+                    )
+        else:
+            if not tmux_manager.select_inner_window(window_id):
+                self.app.notify("Failed to switch terminal", title="Terminal", severity="error")
+            # Clear attention when user clicks on terminal
+            tmux_manager.clear_attention(window_id)
+
+        self._expanded_window_id = None
+        await self.refresh_data()
+
+    async def _handle_close(self, window_id: str) -> None:
+        """Handle closing a terminal."""
+        if not window_id:
+            return
+
+        if self._is_native_mode():
+            backend = await self._ensure_native_backend()
+            if backend:
+                success = await backend.close_tab(window_id)
+                if not success:
+                    self.app.notify(
+                        "Failed to close terminal", title="Terminal", severity="error"
+                    )
+        else:
+            if not tmux_manager.kill_inner_window(window_id):
                 self.app.notify("Failed to close terminal", title="Terminal", severity="error")
-            await self.refresh_data()
+
+        await self.refresh_data()