aline-ai 0.6.4__py3-none-any.whl → 0.6.5__py3-none-any.whl

{aline_ai-0.6.4.dist-info → aline_ai-0.6.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aline-ai
-Version: 0.6.4
+Version: 0.6.5
 Summary: Shared AI memory; everyone knows everything in teams
 Author: Sharemind
 License: MIT

{aline_ai-0.6.4.dist-info → aline_ai-0.6.5.dist-info}/RECORD

@@ -1,5 +1,5 @@
-aline_ai-0.6.4.dist-info/licenses/LICENSE,sha256=H8wTqV5IF1oHw_HbBtS1PSDU8G_q81yblEIL_JfV8Vo,1077
-realign/__init__.py,sha256=rnvZkVu_IlHB3KpP9LQEl-T4lLSwL0cvZOT9ycHF13o,1623
+aline_ai-0.6.5.dist-info/licenses/LICENSE,sha256=H8wTqV5IF1oHw_HbBtS1PSDU8G_q81yblEIL_JfV8Vo,1077
+realign/__init__.py,sha256=02FiDcPQx1TGbGJO98rtDO7k-JAA9WrZKtygoavnEY8,1623
 realign/auth.py,sha256=d_1yvCwluN5iIrdgjtuSKpOYAksDzrzNgntKacLVJrw,16583
 realign/claude_detector.py,sha256=ZLSJacMo6zzQclXByABKA70UNpstxqIv3fPGqdpA934,2792
 realign/cli.py,sha256=HZ_1Rm50z1oszCwvPAZcAdPt0Gl-dj0S0NMLy2sWu_4,35665
@@ -38,7 +38,7 @@ realign/commands/add.py,sha256=_Xzt9P15mwndA3JvBBVrki8tn9Cc0UP6SiLwM4RS8Nc,27232
 realign/commands/auth.py,sha256=QrPukpP-ogYEDSwztV0NOYI-HDgn5fPxlCQ1-e2n7gU,11082
 realign/commands/config.py,sha256=nYnu_h2pk7GODcrzrV04K51D-s7v06FlRXHJ0HJ-gvU,6732
 realign/commands/context.py,sha256=pM2KfZHVkB-ou4nBhFvKSwnYliLBzwN3zerLyBAbhfE,7095
-realign/commands/doctor.py,sha256=CpS8feMMuV2VvqzSCLal7yWDVSQHan5VbC2LbkLHB5Y,18173
+realign/commands/doctor.py,sha256=q5UOrUR5Uai4AxgaeOnK1Hig5I5UX7m3Vt00tPnUllg,18289
 realign/commands/export_shares.py,sha256=WNOR7FBE2om9qPO_28edZKhs94lyUAcbRgP_kNaDi5M,132574
 realign/commands/import_shares.py,sha256=HiswLlYHqR0dR3wgB7Rs54_WownqahIs5IdyJOHuot8,25572
 realign/commands/init.py,sha256=6rBr1LVIrQLbUH_UvoDhkF1qXmMh2xkjNWCYAUz5Tho,35274
@@ -48,10 +48,10 @@ realign/commands/upgrade.py,sha256=L3PLOUIN5qAQTbkfoVtSsIbbzEezA_xjjk9F1GMVfjw,1
 realign/commands/watcher.py,sha256=4WTThIgr-Z5guKh_JqGDcPmerr97XiHrVaaijmckHsA,134350
 realign/commands/worker.py,sha256=jTu7Pj60nTnn7SsH3oNCNnO6zl4TIFCJVNSC1OoQ_0o,23363
 realign/dashboard/__init__.py,sha256=QZkHTsGityH8UkF8rmvA3xW7dMXNe0swEWr443qfgCM,128
-realign/dashboard/app.py,sha256=xCYICKoEsvPli8SCUgfPkInCQp6VDrymnVoRhOizYwY,15872
+realign/dashboard/app.py,sha256=aB1pvuJu-qJ94UqNegB4lvIxUzQJovuC82WQjFnQIFc,10464
 realign/dashboard/layout.py,sha256=sZxmFj6QTbkois9MHTvBEMMcnaRVehCDqugdbiFx10k,9072
 realign/dashboard/terminal_backend.py,sha256=MlDfwtqhftyQK6jDNizQGFjAWIo5Bx2TDpSnP3MCZVM,3375
-realign/dashboard/tmux_manager.py,sha256=1DqMLdgE1m_MHABAilPpfizawk8D8c9QMVmnJ7Au4sg,30963
+realign/dashboard/tmux_manager.py,sha256=Fc6OQbnOO4YV47BnrIkcr0SHnQuSFwUSqhepNkpqKLs,32942
 realign/dashboard/backends/__init__.py,sha256=POROX7YKtukYZcLB1pi_kO0sSEpuO3y-hwmF3WIN1Kk,163
 realign/dashboard/backends/iterm2.py,sha256=XYYJT5lrrp4pW_MyEqPZYkRI0qyKUwJlezwMidgnsHc,21390
 realign/dashboard/backends/kitty.py,sha256=5jdkR1f2PwB8a4SnS3EG6uOQ2XU-PB7-cpKBfIJq3hU,12066
@@ -64,13 +64,13 @@ realign/dashboard/screens/session_detail.py,sha256=TBkHqSHyMxsLB2QdZq9m1EoiH8oRV
 realign/dashboard/screens/share_import.py,sha256=hl2x0yGVycsoUI76AmdZTAV-br3Q6191g5xHHrZ8hOA,6318
 realign/dashboard/styles/dashboard.tcss,sha256=ewonevBGLN-dfSsgxUk4VBCPchtxY4rx_vj1u6Ox2Fw,3454
 realign/dashboard/widgets/__init__.py,sha256=3Pf2_K9obrertgv_psfxradgkI9RXlmjoXYQH7oBKm0,583
-realign/dashboard/widgets/config_panel.py,sha256=v9wQIsH9CK7Q6HFz-C14IQ1SYBcJL3RjhV_ngTk0KH0,15723
+realign/dashboard/widgets/config_panel.py,sha256=eRJRuqImQ8eJIKCEj4O8EvYxI-ht_anrcYbT5JskWyU,15972
 realign/dashboard/widgets/events_table.py,sha256=MKB1G1_xdQCujEhmMz_GKI4hs-PeEiqGEAH7Y3ZGanE,30852
 realign/dashboard/widgets/header.py,sha256=0HHCFXX7F3C6HII-WDwOJwWkJrajmKPWmdoMWyOkn9E,1587
 realign/dashboard/widgets/openable_table.py,sha256=GeJPDEYp0kRHShqvmPMzAePpYXRZHUNqcWNnxqsqxjA,1963
 realign/dashboard/widgets/search_panel.py,sha256=ZNJDfwDSxUFnCeltYQYsQsPJ6t4HDeNWpENoTOoBdVM,8951
 realign/dashboard/widgets/sessions_table.py,sha256=oMkYhQ55pUGOGYxEXM5P37mpGYA350BK8Rb8fVq9AS4,34008
-realign/dashboard/widgets/terminal_panel.py,sha256=VM0eyE8VDldhrc130JjSvCkkcpr5Io0Gx16i5cbdJgM,57854
+realign/dashboard/widgets/terminal_panel.py,sha256=8WX2_EewlyFlxJYokw2akEqkJUjNt_-F8tzE7St3084,60132
 realign/dashboard/widgets/watcher_panel.py,sha256=emVY1-aot9Dnf5UI9yyNeEmp4d2Gb-lrC28DjkeLjKA,19575
 realign/dashboard/widgets/worker_panel.py,sha256=F_jKWABuCNmjQgeeuCr4KnFRKdY4CLTNcEXMYwsNaSk,18691
 realign/db/__init__.py,sha256=65LsNdsq_rkwNC1eg1OAr3HC0ORXtelOh0I8MhNGr-g,3288
@@ -97,8 +97,8 @@ realign/triggers/next_turn_trigger.py,sha256=-x80_I-WmIjXXzQHEPBykgx_GQW6oKaLDQx
 realign/triggers/registry.py,sha256=dkIjSd8Bg-hF0nxaO2Fi2K-0Zipqv6vVjc-HYSrA_fY,3656
 realign/triggers/turn_status.py,sha256=wAZEhXDAmDoX5F-ohWfSnZZ0eA6DAJ9svSPiSv_f6sg,6041
 realign/triggers/turn_summary.py,sha256=f3hEUshgv9skJ9AbfWpoYs417lsv_HK2A_vpPjgryO4,4467
-aline_ai-0.6.4.dist-info/METADATA,sha256=NkBV9ESnpMtnqqp3cn6XcEYhJUjtSMndUS5QIpYP5oY,1597
-aline_ai-0.6.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-aline_ai-0.6.4.dist-info/entry_points.txt,sha256=TvYELpMoWsUTcQdMV8tBHxCbEf_LbK4sESqK3r8PM6Y,78
-aline_ai-0.6.4.dist-info/top_level.txt,sha256=yIL3s2xv9nf1GwD5n71Aq_JEIV4AfzCIDNKBzewuRm4,8
-aline_ai-0.6.4.dist-info/RECORD,,
+aline_ai-0.6.5.dist-info/METADATA,sha256=RmD0VjSn_0nGStyFKgkNYUL3i2foaqg8UWUT3kOUTOc,1597
+aline_ai-0.6.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+aline_ai-0.6.5.dist-info/entry_points.txt,sha256=TvYELpMoWsUTcQdMV8tBHxCbEf_LbK4sESqK3r8PM6Y,78
+aline_ai-0.6.5.dist-info/top_level.txt,sha256=yIL3s2xv9nf1GwD5n71Aq_JEIV4AfzCIDNKBzewuRm4,8
+aline_ai-0.6.5.dist-info/RECORD,,

realign/__init__.py

@@ -3,7 +3,7 @@
 import hashlib
 from pathlib import Path
 
-__version__ = "0.6.4"
+__version__ = "0.6.5"
 
 
 def get_realign_dir(project_root: Path) -> Path:

realign/commands/doctor.py

@@ -308,6 +308,7 @@ def run_doctor(
     start_if_not_running: bool,
     verbose: bool,
     clear_cache: bool,
+    auto_fix: bool = False,
 ) -> int:
     """
     Core doctor logic.
@@ -317,6 +318,7 @@ def run_doctor(
         start_if_not_running: If True and restart_daemons is True, start daemons even if not running.
         verbose: Print details.
         clear_cache: Clear Python bytecode cache for the installed package directory.
+        auto_fix: If True, automatically fix failed jobs without prompting.
     """
     from ..auth import is_logged_in
     from . import watcher as watcher_cmd
@@ -417,7 +419,7 @@ def run_doctor(
                 console.print(f"  [yellow]![/yellow] Found {llm_error_count} turn(s) with LLM API errors")
 
             # Ask user if they want to fix
-            if typer.confirm("\n  Do you want to requeue these for regeneration?", default=True):
+            if auto_fix or typer.confirm("\n  Do you want to requeue these for regeneration?", default=True):
                 requeued_jobs = 0
                 requeued_turns = 0
 

realign/dashboard/app.py

@@ -5,7 +5,6 @@ import subprocess
 import sys
 import time
 import traceback
-from pathlib import Path
 
 from textual.app import App, ComposeResult
 from textual.binding import Binding
@@ -16,10 +15,7 @@ from .widgets import (
     AlineHeader,
     WatcherPanel,
     WorkerPanel,
-    SessionsTable,
-    EventsTable,
     ConfigPanel,
-    SearchPanel,
     TerminalPanel,
 )
 
@@ -71,9 +67,6 @@ class AlineDashboard(App):
         Binding("n", "page_next", "Next Page", show=False),
         Binding("p", "page_prev", "Prev Page", show=False),
         Binding("s", "switch_view", "Switch View", show=False),
-        Binding("c", "create_event", "Create Event", show=False),
-        Binding("l", "load_context", "Load Context", show=False),
-        Binding("y", "share_import", "Share Import", show=False),
         Binding("ctrl+c", "quit_confirm", "Quit", priority=True),
     ]
 
@@ -119,14 +112,8 @@ class AlineDashboard(App):
                         yield WatcherPanel()
                     with TabPane("Worker", id="worker"):
                         yield WorkerPanel()
-                with TabPane("Contexts", id="sessions"):
-                    yield SessionsTable()
-                with TabPane("Share", id="events"):
-                    yield EventsTable()
                 with TabPane("Config", id="config"):
                     yield ConfigPanel()
-                with TabPane("Search", id="search"):
-                    yield SearchPanel()
             yield Footer()
             logger.debug("compose() completed successfully")
         except Exception as e:
@@ -135,8 +122,8 @@ class AlineDashboard(App):
 
     def _tab_ids(self) -> list[str]:
         if self.dev_mode:
-            return ["terminal", "watcher", "worker", "sessions", "events", "config", "search"]
-        return ["terminal", "sessions", "events", "config", "search"]
+            return ["terminal", "watcher", "worker", "config"]
+        return ["terminal", "config"]
 
     def on_mount(self) -> None:
         """Apply theme based on system settings and watch for changes."""
@@ -222,14 +209,8 @@ class AlineDashboard(App):
             self.query_one(WatcherPanel).refresh_data()
         elif active_tab_id == "worker":
             self.query_one(WorkerPanel).refresh_data()
-        elif active_tab_id == "sessions":
-            self.query_one(SessionsTable).refresh_data()
-        elif active_tab_id == "events":
-            self.query_one(EventsTable).refresh_data()
         elif active_tab_id == "config":
             self.query_one(ConfigPanel).refresh_data()
-        elif active_tab_id == "search":
-            pass  # Search is manual
         elif active_tab_id == "terminal":
             await self.query_one(TerminalPanel).refresh_data()
 
@@ -242,7 +223,6 @@ class AlineDashboard(App):
             self.query_one(WatcherPanel).action_next_page()
         elif active_tab_id == "worker":
             self.query_one(WorkerPanel).action_next_page()
-        # sessions and events tabs use scrolling instead of pagination
 
     def action_page_prev(self) -> None:
         """Go to previous page in current panel."""
@@ -253,7 +233,6 @@ class AlineDashboard(App):
             self.query_one(WatcherPanel).action_prev_page()
         elif active_tab_id == "worker":
             self.query_one(WorkerPanel).action_prev_page()
-        # sessions and events tabs use scrolling instead of pagination
 
     def action_switch_view(self) -> None:
         """Switch view in current panel (if supported)."""
@@ -264,10 +243,6 @@ class AlineDashboard(App):
             self.query_one(WatcherPanel).action_switch_view()
         elif active_tab_id == "worker":
             self.query_one(WorkerPanel).action_switch_view()
-        elif active_tab_id == "sessions":
-            self.query_one(SessionsTable).action_switch_view()
-        elif active_tab_id == "events":
-            self.query_one(EventsTable).action_switch_view()
 
     def action_help(self) -> None:
         """Show help information."""
@@ -286,130 +261,6 @@ class AlineDashboard(App):
         self._quit_confirm_deadline = now + self._quit_confirm_window_s
         self.notify("Press Ctrl+C again to quit", title="Quit", timeout=2)
 
-    def action_create_event(self) -> None:
-        """Create an event from selected sessions (Sessions tab only)."""
-        tabbed_content = self.query_one(TabbedContent)
-        if tabbed_content.active != "sessions":
-            self.notify(
-                "Switch to the Sessions tab to create an event", title="Create Event", timeout=3
-            )
-            return
-
-        sessions_panel = self.query_one(SessionsTable)
-        session_ids = sessions_panel.get_selected_session_ids()
-        if not session_ids:
-            self.notify(
-                "No sessions selected (use space / cmd-click / shift-click)",
-                title="Create Event",
-                timeout=3,
-            )
-            return
-
-        from .screens import CreateEventScreen
-
-        self.push_screen(CreateEventScreen(session_ids))
-
-    def action_share_import(self) -> None:
-        """Import a share URL (Events tab only)."""
-        tabbed_content = self.query_one(TabbedContent)
-        if tabbed_content.active != "events":
-            self.notify(
-                "Switch to the Events tab to import a share", title="Share Import", timeout=3
-            )
-            return
-
-        from .screens import ShareImportScreen
-
-        self.push_screen(ShareImportScreen())
-
-    async def action_load_context(self) -> None:
-        """Load selected sessions/events into the active terminal context (Claude/Codex)."""
-        tabbed_content = self.query_one(TabbedContent)
-        active_tab_id = tabbed_content.active
-
-        try:
-            from . import tmux_manager
-
-            context_id = tmux_manager.get_active_context_id(
-                allowed_providers={"claude", "codex"}
-            )
-        except Exception:
-            context_id = None
-
-        if not context_id:
-            self.notify(
-                "No active context found. Use the Terminal tab and select a Claude ('cc') or Codex terminal.",
-                title="Load Context",
-                severity="warning",
-                timeout=4,
-            )
-            return
-
-        sessions: list[str] = []
-        events: list[str] = []
-
-        if active_tab_id == "sessions":
-            sessions = self.query_one(SessionsTable).get_selected_session_ids()
-            if not sessions:
-                self.notify(
-                    "No sessions selected (use space / cmd-click / shift-click)",
-                    title="Load Context",
-                    severity="warning",
-                    timeout=3,
-                )
-                return
-        elif active_tab_id == "events":
-            events = self.query_one(EventsTable).get_selected_event_ids()
-            if not events:
-                self.notify(
-                    "No events selected (use space / cmd-click / shift-click)",
-                    title="Load Context",
-                    severity="warning",
-                    timeout=3,
-                )
-                return
-        else:
-            self.notify(
-                "Switch to Sessions or Events to load selection into context",
-                title="Load Context",
-                timeout=3,
-            )
-            return
-
-        try:
-            from ..context import add_context
-
-            add_context(
-                sessions=sessions or None,
-                events=events or None,
-                context_id=context_id,
-            )
-        except Exception as e:
-            self.notify(
-                f"Failed to load context: {e}",
-                title="Load Context",
-                severity="error",
-                timeout=4,
-            )
-            return
-
-        try:
-            from .widgets.terminal_panel import TerminalPanel
-
-            if TerminalPanel.supported():
-                await self.query_one(TerminalPanel).refresh_data()
-        except Exception:
-            pass
-
-        parts: list[str] = []
-        if sessions:
-            parts.append(f"{len(sessions)} sessions")
-        if events:
-            parts.append(f"{len(events)} events")
-        what = ", ".join(parts) if parts else "selection"
-        self.notify(f"Loaded {what} into {context_id}", title="Load Context", timeout=3)
-
-
 def run_dashboard(use_native_terminal: bool | None = None) -> None:
     """Run the Aline Dashboard.
 

realign/dashboard/tmux_manager.py

@@ -195,11 +195,17 @@ def _session_id_from_transcript_path(transcript_path: str | None) -> str | None:
 
 def _load_terminal_state_from_db() -> dict[str, dict[str, str]]:
     """Load terminal state from database (best-effort)."""
+    import time as _time
+    t0 = _time.time()
     try:
         from ..db import get_database
 
+        t1 = _time.time()
         db = get_database(read_only=True)
+        logger.info(f"[PERF] _load_terminal_state_from_db get_database: {_time.time() - t1:.3f}s")
+        t2 = _time.time()
         agents = db.list_agents(status="active", limit=100)
+        logger.info(f"[PERF] _load_terminal_state_from_db list_agents: {_time.time() - t2:.3f}s")
 
         out: dict[str, dict[str, str]] = {}
         for agent in agents:
@@ -510,8 +516,18 @@ def bootstrap_dashboard_into_tmux() -> None:
     os.execvp("tmux", ["tmux", "-L", OUTER_SOCKET, "attach", "-t", OUTER_SESSION])
 
 
+_inner_session_configured = False
+
+
 def ensure_inner_session() -> bool:
-    """Ensure the inner tmux server/session exists (returns True on success)."""
+    """Ensure the inner tmux server/session exists (returns True on success).
+
+    The full configuration (mouse, status bar, border styles, home window setup) is
+    only applied once per process lifetime.  Subsequent calls just verify the session
+    is still alive via a cheap ``has-session`` check.
+    """
+    global _inner_session_configured
+
     if not (tmux_available() and in_tmux() and managed_env_enabled()):
         return False
 
@@ -523,6 +539,13 @@ def ensure_inner_session() -> bool:
             != 0
         ):
             return False
+        # Force re-configuration after creating a new session.
+        _inner_session_configured = False
+
+    if _inner_session_configured:
+        return True
+
+    # --- One-time configuration below ---
 
     # Ensure the default/home window stays named "home" (tmux auto-rename would otherwise
     # change it to "zsh"/"opencode" depending on the last foreground command).
@@ -546,6 +569,8 @@ def ensure_inner_session() -> bool:
     _run_inner_tmux(["set-option", "-g", "pane-border-indicators", "arrows"])
 
     _source_aline_tmux_config(_run_inner_tmux)
+
+    _inner_session_configured = True
     return True
 
 
@@ -632,14 +657,12 @@ def _ensure_inner_home_window() -> None:
     _run_inner_tmux(["set-option", "-w", "-t", window_id, "allow-rename", "off"])
 
     # Mark as internal/no-track so UI can hide it.
+    # NOTE: We use _run_inner_tmux directly here instead of set_inner_window_options
+    # to avoid recursion: set_inner_window_options → ensure_inner_session →
+    # _ensure_inner_home_window → set_inner_window_options.
     try:
-        set_inner_window_options(
-            window_id,
-            {
-                OPT_NO_TRACK: "1",
-                OPT_CREATED_AT: str(time.time()),
-            },
-        )
+        _run_inner_tmux(["set-option", "-w", "-t", window_id, OPT_NO_TRACK, "1"])
+        _run_inner_tmux(["set-option", "-w", "-t", window_id, OPT_CREATED_AT, str(time.time())])
     except Exception:
         pass
 
@@ -687,9 +710,14 @@ def ensure_right_pane(width_percent: int = 50) -> bool:
 
 
 def list_inner_windows() -> list[InnerWindow]:
+    import time as _time
+    t0 = _time.time()
     if not ensure_inner_session():
         return []
+    logger.info(f"[PERF] list_inner_windows ensure_inner_session: {_time.time() - t0:.3f}s")
+    t1 = _time.time()
     state = _load_terminal_state()
+    logger.info(f"[PERF] list_inner_windows _load_terminal_state: {_time.time() - t1:.3f}s")
     out = (
         _run_inner_tmux(
             [
@@ -785,13 +813,16 @@ def list_inner_windows() -> list[InnerWindow]:
 
 
 def set_inner_window_options(window_id: str, options: dict[str, str]) -> bool:
+    import time as _time
     if not ensure_inner_session():
         return False
     ok = True
     for key, value in options.items():
+        t0 = _time.time()
         # Important: these are per-window (not session-wide) to avoid cross-tab clobbering.
         if _run_inner_tmux(["set-option", "-w", "-t", window_id, key, value]).returncode != 0:
             ok = False
+        logger.info(f"[PERF] set_inner_window_options {key}: {_time.time() - t0:.3f}s")
     return ok
 
 
@@ -810,15 +841,22 @@ def create_inner_window(
     context_id: str | None = None,
     no_track: bool = False,
 ) -> InnerWindow | None:
+    import time as _time
+    t0 = _time.time()
+    logger.info(f"[PERF] create_inner_window START")
     if not ensure_right_pane():
         return None
+    logger.info(f"[PERF] create_inner_window ensure_right_pane: {_time.time() - t0:.3f}s")
 
+    t1 = _time.time()
     existing = list_inner_windows()
+    logger.info(f"[PERF] create_inner_window list_inner_windows: {_time.time() - t1:.3f}s")
     name = _unique_name((w.window_name for w in existing), base_name)
 
     # Record creation time before creating the window
     created_at = time.time()
 
+    t2 = _time.time()
     proc = _run_inner_tmux(
         [
             "new-window",
@@ -833,6 +871,7 @@ def create_inner_window(
         ],
         capture=True,
     )
+    logger.info(f"[PERF] create_inner_window new-window: {_time.time() - t2:.3f}s")
     if proc.returncode != 0:
         return None
 
@@ -856,7 +895,9 @@ def create_inner_window(
         opts[OPT_NO_TRACK] = "1"
     else:
         opts.setdefault(OPT_NO_TRACK, "")
+    t3 = _time.time()
     set_inner_window_options(window_id, opts)
+    logger.info(f"[PERF] create_inner_window set_options: {_time.time() - t3:.3f}s")
 
     _run_inner_tmux(["select-window", "-t", window_id])
 

realign/dashboard/widgets/config_panel.py

@@ -393,26 +393,32 @@ class ConfigPanel(Static):
             self.app.notify(f"Error saving setting: {e}", title="Config", severity="error")
 
     def _handle_doctor(self) -> None:
-        """Run aline doctor command in background."""
+        """Run aline doctor directly in background thread."""
         self.app.notify("Running Aline Doctor...", title="Doctor")
 
         def do_doctor():
             try:
-                import subprocess
-                result = subprocess.run(
-                    ["aline", "doctor"],
-                    capture_output=True,
-                    text=True,
-                    timeout=60,
-                )
-                if result.returncode == 0:
+                import contextlib
+                import io
+                from ...commands.doctor import run_doctor
+
+                # Suppress Rich console output (would corrupt TUI)
+                with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()):
+                    exit_code = run_doctor(
+                        restart_daemons=True,
+                        start_if_not_running=False,
+                        verbose=False,
+                        clear_cache=True,
+                        auto_fix=True,
+                    )
+
+                if exit_code == 0:
                     self.app.call_from_thread(
                         self.app.notify, "Doctor completed successfully", title="Doctor"
                     )
                 else:
-                    error_msg = result.stderr.strip() if result.stderr else "Unknown error"
                     self.app.call_from_thread(
-                        self.app.notify, f"Doctor failed: {error_msg}", title="Doctor", severity="error"
+                        self.app.notify, "Doctor completed with errors", title="Doctor", severity="error"
                     )
             except Exception as e:
                 self.app.call_from_thread(

realign/dashboard/widgets/terminal_panel.py

@@ -668,13 +668,17 @@ class TerminalPanel(Container, can_focus=True):
 
     async def refresh_data(self) -> None:
         async with self._refresh_lock:
+            t_start = time.time()
             # Check and close stale terminals if enabled
             await self._close_stale_terminals_if_enabled()
+            logger.debug(f"[PERF] _close_stale_terminals_if_enabled: {time.time() - t_start:.3f}s")
 
+            t_refresh = time.time()
             if self._is_native_mode():
                 await self._refresh_native_data()
             else:
                 await self._refresh_tmux_data()
+            logger.debug(f"[PERF] total refresh: {time.time() - t_start:.3f}s")
 
     async def _close_stale_terminals_if_enabled(self) -> None:
         """Close terminals that haven't been updated for the configured hours."""
@@ -741,15 +745,13 @@ class TerminalPanel(Container, can_focus=True):
             logger.error(f"Failed to list native terminals: {e}")
             return
 
-        # Best-effort: bind Codex session ids for native terminals (no watcher required).
-        try:
-            for w in windows:
-                if self._is_codex_window(w) and w.terminal_id:
-                    self._maybe_link_codex_session_for_terminal(
-                        terminal_id=w.terminal_id, created_at=w.created_at
-                    )
-        except Exception:
-            pass
+        # Yield to event loop to keep UI responsive
+        await asyncio.sleep(0)
+
+        # NOTE: _maybe_link_codex_session_for_terminal is intentionally skipped here
+        # because it performs expensive file system scans (find_codex_sessions_for_project)
+        # that can take minutes with many session files. Codex session linking is handled
+        # by the watcher process instead.
 
         active_window_id = next(
             (w.session_id for w in windows if w.active), None
@@ -765,6 +767,9 @@ class TerminalPanel(Container, can_focus=True):
         ]
         titles = self._fetch_claude_session_titles(claude_ids)
 
+        # Yield to event loop after DB query
+        await asyncio.sleep(0)
+
         # Get context info
         context_info_by_context_id: dict[str, tuple[list[str], int, int]] = {}
         all_context_session_ids: set[str] = set()
@@ -793,6 +798,7 @@ class TerminalPanel(Container, can_focus=True):
 
     async def _refresh_tmux_data(self) -> None:
         """Refresh data using tmux backend."""
+        t0 = time.time()
         try:
             supported = self.supported()
         except Exception:
@@ -806,24 +812,29 @@ class TerminalPanel(Container, can_focus=True):
         except Exception:
             return
         windows = [w for w in windows if not self._is_internal_tmux_window(w)]
+        logger.debug(f"[PERF] list_inner_windows: {time.time() - t0:.3f}s")
 
-        # Best-effort: bind Codex session ids for tmux terminals (no watcher required).
-        try:
-            for w in windows:
-                if self._is_codex_window(w) and not w.session_id and w.terminal_id:
-                    self._maybe_link_codex_session_for_terminal(
-                        terminal_id=w.terminal_id, created_at=w.created_at
-                    )
-        except Exception:
-            pass
+        # Yield to event loop to keep UI responsive
+        await asyncio.sleep(0)
+
+        # NOTE: _maybe_link_codex_session_for_terminal is intentionally skipped here
+        # because it performs expensive file system scans (find_codex_sessions_for_project)
+        # that can take minutes with many session files. Codex session linking is handled
+        # by the watcher process instead.
 
         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
 
+        t1 = time.time()
         session_ids = [w.session_id for w in windows if self._supports_context(w) and w.session_id]
         titles = self._fetch_claude_session_titles(session_ids)
+        logger.debug(f"[PERF] fetch_claude_session_titles: {time.time() - t1:.3f}s")
+
+        # Yield to event loop after DB query
+        await asyncio.sleep(0)
 
+        t2 = time.time()
         context_info_by_context_id: dict[str, tuple[list[str], int, int]] = {}
         all_context_session_ids: set[str] = set()
         for w in windows:
@@ -840,14 +851,21 @@ class TerminalPanel(Container, can_focus=True):
                 event_count,
             )
             all_context_session_ids.update(session_ids)
+            # Yield periodically during context info gathering
+            await asyncio.sleep(0)
+        logger.debug(f"[PERF] get_loaded_context_info loop: {time.time() - t2:.3f}s")
 
+        t3 = time.time()
         if all_context_session_ids:
             titles.update(self._fetch_claude_session_titles(sorted(all_context_session_ids)))
+        logger.debug(f"[PERF] fetch context session titles: {time.time() - t3:.3f}s")
 
+        t4 = time.time()
         try:
             await self._render_terminals_tmux(windows, titles, context_info_by_context_id)
         except Exception:
             return
+        logger.debug(f"[PERF] render_terminals_tmux: {time.time() - t4:.3f}s")
 
     def _fetch_claude_session_titles(self, session_ids: list[str]) -> dict[str, str]:
         # Back-compat hook for tests and older call sites.
@@ -1232,13 +1250,23 @@ class TerminalPanel(Container, can_focus=True):
             return
 
         agent_type, workspace, skip_permissions, no_track = result
-        self.run_worker(
-            self._create_agent(
-                agent_type, workspace, skip_permissions=skip_permissions, no_track=no_track
-            ),
-            group="terminal-panel-create",
-            exclusive=True,
-        )
+
+        # Capture self reference for use in the deferred callback
+        panel = self
+
+        # Use app.call_later to defer worker creation until after the modal is dismissed.
+        # This ensures the modal screen is fully closed before the worker starts,
+        # preventing UI update conflicts between modal closing and terminal panel refresh.
+        def start_worker() -> None:
+            panel.run_worker(
+                panel._create_agent(
+                    agent_type, workspace, skip_permissions=skip_permissions, no_track=no_track
+                ),
+                group="terminal-panel-create",
+                exclusive=True,
+            )
+
+        self.app.call_later(start_worker)
 
     async def _create_agent(
         self, agent_type: str, workspace: str, *, skip_permissions: bool = False, no_track: bool = False
@@ -1252,7 +1280,14 @@ class TerminalPanel(Container, can_focus=True):
             await self._create_opencode_terminal(workspace)
         elif agent_type == "zsh":
             await self._create_zsh_terminal(workspace)
-        await self.refresh_data()
+        # Schedule refresh in a separate worker to avoid blocking UI.
+        # The refresh involves slow synchronous operations (DB queries, file scans)
+        # that would otherwise freeze the dashboard.
+        self.run_worker(
+            self.refresh_data(),
+            group="terminal-panel-refresh",
+            exclusive=True,
+        )
 
     async def _create_claude_terminal(
         self, workspace: str, *, skip_permissions: bool = False, no_track: bool = False
@@ -1495,6 +1530,8 @@ class TerminalPanel(Container, can_focus=True):
 
     async def _create_zsh_terminal(self, workspace: str) -> None:
         """Create a new zsh terminal."""
+        t0 = time.time()
+        logger.info(f"[PERF] _create_zsh_terminal START")
         if self._is_native_mode():
             backend = await self._ensure_native_backend()
             if backend:
@@ -1509,13 +1546,19 @@ class TerminalPanel(Container, can_focus=True):
                     self.app.notify(
                         "Failed to open zsh terminal", title="Terminal", severity="error"
                     )
+                logger.info(f"[PERF] _create_zsh_terminal native END: {time.time() - t0:.3f}s")
                 return
 
         # Tmux fallback
+        t1 = time.time()
         command = self._command_in_directory("zsh", workspace)
+        logger.info(f"[PERF] _create_zsh_terminal command ready: {time.time() - t1:.3f}s")
+        t2 = time.time()
         created = tmux_manager.create_inner_window("zsh", command)
+        logger.info(f"[PERF] _create_zsh_terminal create_inner_window: {time.time() - t2:.3f}s")
         if not created:
             self.app.notify("Failed to open zsh terminal", title="Terminal", severity="error")
+        logger.info(f"[PERF] _create_zsh_terminal TOTAL: {time.time() - t0:.3f}s")
 
     async def on_button_pressed(self, event: Button.Pressed) -> None:
         button_id = event.button.id or ""