aline-ai 0.7.3__py3-none-any.whl → 0.7.4__py3-none-any.whl

realign/dashboard/screens/create_agent_info.py

@@ -7,7 +7,7 @@ from typing import Optional
 
 from textual.app import ComposeResult
 from textual.binding import Binding
-from textual.containers import Container, Horizontal, Vertical
+from textual.containers import Container, Horizontal
 from textual.screen import ModalScreen
 from textual.widgets import Button, Input, Label, Static
 from textual.worker import Worker, WorkerState
@@ -34,7 +34,8 @@ class CreateAgentInfoScreen(ModalScreen[Optional[dict]]):
     }
 
     CreateAgentInfoScreen #create-agent-info-root {
-        width: 65;
+        width: 100%;
+        max-width: 65;
         height: auto;
         max-height: 80%;
         padding: 1 2;
@@ -57,15 +58,6 @@ class CreateAgentInfoScreen(ModalScreen[Optional[dict]]):
 
     CreateAgentInfoScreen Input {
         margin-top: 0;
-        border: none;
-    }
-
-    CreateAgentInfoScreen #or-separator {
-        height: auto;
-        margin-top: 1;
-        margin-bottom: 0;
-        text-align: center;
-        color: $text-muted;
     }
 
     CreateAgentInfoScreen #import-status {
@@ -74,23 +66,13 @@ class CreateAgentInfoScreen(ModalScreen[Optional[dict]]):
         color: $text-muted;
     }
 
-    CreateAgentInfoScreen #create-buttons {
+    CreateAgentInfoScreen #add-buttons {
         height: auto;
         margin-top: 1;
         align: right middle;
     }
 
-    CreateAgentInfoScreen #import-buttons {
-        height: auto;
-        margin-top: 1;
-        align: right middle;
-    }
-
-    CreateAgentInfoScreen #create-buttons Button {
-        margin-left: 1;
-    }
-
-    CreateAgentInfoScreen #import-buttons Button {
+    CreateAgentInfoScreen #add-buttons Button {
         margin-left: 1;
     }
     """
@@ -103,44 +85,37 @@ class CreateAgentInfoScreen(ModalScreen[Optional[dict]]):
 
     def compose(self) -> ComposeResult:
         with Container(id="create-agent-info-root"):
-            yield Static("Create Agent Profile", id="create-agent-info-title")
-
-            # --- Create New section ---
-            yield Label("Name", classes="section-label")
-            yield Input(placeholder=self._default_name, id="agent-name")
+            yield Static("Add Agent", id="create-agent-info-title")
 
-            with Horizontal(id="create-buttons"):
-                yield Button("Cancel", id="cancel")
-                yield Button("Create", id="create", variant="primary")
-
-            # --- Separator ---
-            yield Static("-- Or --", id="or-separator")
-
-            # --- Import from Link section ---
-            yield Label("Import from Link", classes="section-label")
-            yield Input(placeholder="https://realign-server.vercel.app/share/...", id="share-url")
-
-            yield Label("Password (optional)", classes="section-label")
-            yield Input(placeholder="Leave blank if not password-protected", id="share-password", password=True)
+            yield Label("Name or Share Link", classes="section-label")
+            yield Input(placeholder=self._default_name, id="agent-input")
 
             yield Static("", id="import-status")
 
-            with Horizontal(id="import-buttons"):
-                yield Button("Import", id="import", variant="primary")
+            with Horizontal(id="add-buttons"):
+                yield Button("Cancel", id="cancel")
+                yield Button("Add", id="add", variant="primary")
 
     def on_mount(self) -> None:
-        self.query_one("#agent-name", Input).focus()
+        agent_input = self.query_one("#agent-input", Input)
+        agent_input.styles.border = ("round", "black")
+        agent_input.focus()
+        for btn in (self.query_one("#cancel", Button), self.query_one("#add", Button)):
+            btn.styles.border = ("round", "black")
+            btn.styles.text_align = "center"
+            btn.styles.content_align = ("center", "middle")
 
     def action_close(self) -> None:
         self.dismiss(None)
 
     def _set_busy(self, busy: bool) -> None:
-        self.query_one("#agent-name", Input).disabled = busy
-        self.query_one("#share-url", Input).disabled = busy
-        self.query_one("#share-password", Input).disabled = busy
-        self.query_one("#create", Button).disabled = busy
+        self.query_one("#agent-input", Input).disabled = busy
+        self.query_one("#add", Button).disabled = busy
         self.query_one("#cancel", Button).disabled = busy
-        self.query_one("#import", Button).disabled = busy
+
+    def _is_share_link(self, value: str) -> bool:
+        """Check if the input looks like a share link."""
+        return "/share/" in value
 
     async def on_button_pressed(self, event: Button.Pressed) -> None:
         button_id = event.button.id or ""
@@ -149,28 +124,29 @@ class CreateAgentInfoScreen(ModalScreen[Optional[dict]]):
             self.dismiss(None)
             return
 
-        if button_id == "create":
-            await self._create_agent()
-            return
-
-        if button_id == "import":
-            await self._import_agent()
+        if button_id == "add":
+            await self._add_agent()
             return
 
     async def on_input_submitted(self, event: Input.Submitted) -> None:
         """Handle enter key in input fields."""
-        input_id = event.input.id or ""
-        if input_id == "agent-name":
-            await self._create_agent()
-        elif input_id in ("share-url", "share-password"):
-            await self._import_agent()
+        if event.input.id == "agent-input":
+            await self._add_agent()
 
-    async def _create_agent(self) -> None:
+    async def _add_agent(self) -> None:
+        """Create a new agent or import from link based on input content."""
+        value = self.query_one("#agent-input", Input).value.strip()
+
+        if self._is_share_link(value):
+            await self._import_agent(value)
+        else:
+            await self._create_agent(value)
+
+    async def _create_agent(self, name_input: str) -> None:
         """Create the agent profile."""
         try:
             from ...db import get_database
 
-            name_input = self.query_one("#agent-name", Input).value.strip()
             name = name_input or self._default_name
 
             agent_id = str(uuid.uuid4())
@@ -187,21 +163,8 @@ class CreateAgentInfoScreen(ModalScreen[Optional[dict]]):
             logger.error(f"Failed to create agent: {e}")
             self.app.notify(f"Failed to create agent: {e}", severity="error")
 
-    async def _import_agent(self) -> None:
+    async def _import_agent(self, share_url: str) -> None:
         """Import an agent from a share link."""
-        share_url = self.query_one("#share-url", Input).value.strip()
-        password = self.query_one("#share-password", Input).value.strip() or None
-
-        if not share_url:
-            self.app.notify("Please enter a share URL", severity="warning")
-            self.query_one("#share-url", Input).focus()
-            return
-
-        if "/share/" not in share_url:
-            self.app.notify("Invalid share URL format", severity="warning")
-            self.query_one("#share-url", Input).focus()
-            return
-
         status = self.query_one("#import-status", Static)
         status.update("Importing...")
         self._set_busy(True)
@@ -209,7 +172,7 @@ class CreateAgentInfoScreen(ModalScreen[Optional[dict]]):
         def do_import() -> dict:
             from ...commands.import_shares import import_agent_from_share
 
-            return import_agent_from_share(share_url, password=password)
+            return import_agent_from_share(share_url, password=None)
 
         self._import_worker = self.run_worker(do_import, thread=True, exit_on_error=False)
 

realign/dashboard/tmux_manager.py

@@ -14,6 +14,7 @@ import shutil
 import stat
 import subprocess
 import sys
+import threading
 import time
 import traceback
 import uuid
@@ -47,6 +48,10 @@ OPT_ATTENTION = "@aline_attention"
 OPT_CREATED_AT = "@aline_created_at"
 OPT_NO_TRACK = "@aline_no_track"
 
+# Default outer layout preferences (tmux mode).
+# Note: tmux "pixels" are terminal cell columns; Textual has no notion of pixels.
+DEFAULT_DASHBOARD_PANE_WIDTH_COLS = 45
+
 
 @dataclass(frozen=True)
 class InnerWindow:
@@ -62,6 +67,9 @@ class InnerWindow:
     attention: str | None = None  # "permission_request", "stop", or None
     created_at: float | None = None  # Unix timestamp when window was created
     no_track: bool = False  # Whether tracking is disabled for this terminal
+    pane_pid: int | None = None  # PID of the initial process in the pane
+    pane_current_command: str | None = None  # Foreground process in the pane
+    pane_tty: str | None = None  # Controlling TTY for processes in the pane
 
 
 def tmux_available() -> bool:
@@ -93,26 +101,31 @@ def tmux_version() -> tuple[int, int] | None:
     return int(match.group(1)), int(match.group(2))
 
 
-def _run_tmux(args: Sequence[str], *, capture: bool = False) -> subprocess.CompletedProcess[str]:
-    return subprocess.run(
-        ["tmux", *args],
-        text=True,
-        capture_output=capture,
-        check=False,
-    )
+def _run_tmux(
+    args: Sequence[str], *, capture: bool = False, timeout_s: float | None = None
+) -> subprocess.CompletedProcess[str]:
+    kwargs: dict[str, object] = {
+        "text": True,
+        "capture_output": capture,
+        "check": False,
+    }
+    # Keep keyword list minimal for test fakes that don't accept extra kwargs.
+    if timeout_s is not None:
+        kwargs["timeout"] = timeout_s
+    return subprocess.run(["tmux", *args], **kwargs)  # type: ignore[arg-type]
 
 
 def _run_outer_tmux(
-    args: Sequence[str], *, capture: bool = False
+    args: Sequence[str], *, capture: bool = False, timeout_s: float | None = None
 ) -> subprocess.CompletedProcess[str]:
     """Run tmux commands against the dedicated outer server socket."""
-    return _run_tmux(["-L", OUTER_SOCKET, *args], capture=capture)
+    return _run_tmux(["-L", OUTER_SOCKET, *args], capture=capture, timeout_s=timeout_s)
 
 
 def _run_inner_tmux(
-    args: Sequence[str], *, capture: bool = False
+    args: Sequence[str], *, capture: bool = False, timeout_s: float | None = None
 ) -> subprocess.CompletedProcess[str]:
-    return _run_tmux(["-L", INNER_SOCKET, *args], capture=capture)
+    return _run_tmux(["-L", INNER_SOCKET, *args], capture=capture, timeout_s=timeout_s)
 
 
 def _python_dashboard_command() -> str:
@@ -256,6 +269,12 @@ def _load_terminal_state_from_json() -> dict[str, dict[str, str]]:
         return {}
 
 
+_TERMINAL_STATE_CACHE_LOCK = threading.Lock()
+_TERMINAL_STATE_CACHE: dict[str, dict[str, str]] | None = None
+_TERMINAL_STATE_CACHE_AT: float = 0.0
+_TERMINAL_STATE_CACHE_TTL_S: float = 1.5
+
+
 def _load_terminal_state() -> dict[str, dict[str, str]]:
     """Load terminal state.
 
@@ -265,6 +284,13 @@ def _load_terminal_state() -> dict[str, dict[str, str]]:
 
     Merges both sources, with DB taking precedence.
     """
+    global _TERMINAL_STATE_CACHE, _TERMINAL_STATE_CACHE_AT
+    now = time.monotonic()
+    with _TERMINAL_STATE_CACHE_LOCK:
+        cache = _TERMINAL_STATE_CACHE
+        if cache is not None and (now - _TERMINAL_STATE_CACHE_AT) <= _TERMINAL_STATE_CACHE_TTL_S:
+            return dict(cache)
+
     # Phase 1: Load from database
     db_state = _load_terminal_state_from_db()
 
@@ -275,6 +301,10 @@ def _load_terminal_state() -> dict[str, dict[str, str]]:
     result = dict(json_state)
     result.update(db_state)
 
+    with _TERMINAL_STATE_CACHE_LOCK:
+        _TERMINAL_STATE_CACHE = dict(result)
+        _TERMINAL_STATE_CACHE_AT = time.monotonic()
+
     return result
 
 
@@ -471,6 +501,7 @@ def bootstrap_dashboard_into_tmux() -> None:
 
     # Enable mouse for the managed session only.
     _run_outer_tmux(["set-option", "-t", OUTER_SESSION, "mouse", "on"])
+    _disable_outer_border_resize()
 
     # Disable status bar for cleaner UI (Aline sessions only).
     _run_outer_tmux(["set-option", "-t", OUTER_SESSION, "status", "off"])
@@ -506,6 +537,9 @@ def bootstrap_dashboard_into_tmux() -> None:
     )
     _run_outer_tmux(["select-window", "-t", f"{OUTER_SESSION}:{OUTER_WINDOW}"])
 
+    # Best-effort: enforce a stable dashboard pane width if the terminal pane already exists.
+    _set_outer_dashboard_pane_width(DEFAULT_DASHBOARD_PANE_WIDTH_COLS)
+
     # Sanity-check before exec'ing into tmux attach. If this fails, fall back to non-tmux mode.
     ready = _run_outer_tmux(["has-session", "-t", OUTER_SESSION], capture=True)
     if ready.returncode != 0:
@@ -691,6 +725,7 @@ def ensure_right_pane(width_percent: int = 50) -> bool:
     )
     panes = _parse_lines(panes_out)
     if len(panes) >= 2:
+        _set_outer_dashboard_pane_width(DEFAULT_DASHBOARD_PANE_WIDTH_COLS)
         return True
 
     # Split from the dashboard pane to keep it on the left.
@@ -705,9 +740,144 @@ def ensure_right_pane(width_percent: int = 50) -> bool:
             f"{OUTER_SESSION}:{OUTER_WINDOW}.0",
             "-d",
             attach_cmd,
-        ]
+        ],
+        capture=True,
     )
-    return split.returncode == 0
+    if split.returncode != 0:
+        detail = (split.stderr or split.stdout or "").strip()
+        if detail:
+            logger.warning(f"ensure_right_pane split-window failed: {detail}")
+    if split.returncode == 0:
+        _set_outer_dashboard_pane_width(DEFAULT_DASHBOARD_PANE_WIDTH_COLS)
+        return True
+    return False
+
+
+def ensure_right_pane_ready(width_percent: int = 50) -> bool:
+    """Ensure the right pane exists and is attached to the inner tmux session."""
+    try:
+        ok = ensure_right_pane(width_percent)
+    except TypeError:
+        # Tests and some callers monkeypatch ensure_right_pane() as a no-arg lambda.
+        ok = ensure_right_pane()
+    if not ok:
+        return False
+
+    # Best-effort: enforce a stable dashboard pane width whenever we touch the outer layout.
+    _set_outer_dashboard_pane_width(DEFAULT_DASHBOARD_PANE_WIDTH_COLS)
+
+    attach_cmd = shlex.join(["tmux", "-L", INNER_SOCKET, "attach", "-t", INNER_SESSION])
+
+    # If the right pane exists but isn't running `tmux attach`, it may look "blank" or stale.
+    try:
+        proc = _run_outer_tmux(
+            [
+                "display-message",
+                "-p",
+                "-t",
+                f"{OUTER_SESSION}:{OUTER_WINDOW}.1",
+                "#{pane_current_command}",
+            ],
+            capture=True,
+        )
+        current_cmd = (proc.stdout or "").strip()
+    except Exception:
+        current_cmd = ""
+
+    if current_cmd and current_cmd != "tmux":
+        respawn = _run_outer_tmux(
+            [
+                "respawn-pane",
+                "-k",
+                "-t",
+                f"{OUTER_SESSION}:{OUTER_WINDOW}.1",
+                attach_cmd,
+            ],
+            capture=True,
+        )
+        if respawn.returncode != 0:
+            detail = (respawn.stderr or respawn.stdout or "").strip()
+            if detail:
+                logger.warning(f"ensure_right_pane_ready respawn failed: {detail}")
+            return False
+
+    return True
+
+
+def _disable_outer_border_resize() -> None:
+    """Disable mouse drag-to-resize on pane borders (outer dashboard tmux server only)."""
+    try:
+        # tmux enables border resizing via MouseDrag1Border. Unbind it on our dedicated server
+        # to avoid accidental resizing when selecting text near the pane divider.
+        for key in ("MouseDrag1Border", "MouseDown1Border", "MouseDragEnd1Border", "MouseUp1Border"):
+            _run_outer_tmux(["unbind-key", "-T", "root", key], capture=True)
+    except Exception:
+        return
+
+
+def _set_outer_dashboard_pane_width(width_cols: int) -> None:
+    """Best-effort: size the left dashboard pane to a fixed width (in terminal columns)."""
+    try:
+        w = int(width_cols)
+        if w <= 0:
+            return
+    except Exception:
+        return
+
+    try:
+        # Avoid assuming pane indexes are 0/1. Determine the leftmost pane by geometry.
+        panes_out = (
+            _run_outer_tmux(
+                [
+                    "list-panes",
+                    "-t",
+                    f"{OUTER_SESSION}:{OUTER_WINDOW}",
+                    "-F",
+                    "#{pane_id}\t#{pane_left}\t#{pane_index}",
+                ],
+                capture=True,
+                timeout_s=0.2,
+            ).stdout
+            or ""
+        )
+        panes: list[tuple[int, int, str]] = []
+        for line in _parse_lines(panes_out):
+            parts = line.split("\t")
+            if len(parts) < 2:
+                continue
+            pane_id = (parts[0] or "").strip()
+            if not pane_id:
+                continue
+            try:
+                pane_left = int((parts[1] or "0").strip())
+            except Exception:
+                continue
+            pane_index = 0
+            if len(parts) > 2 and (parts[2] or "").strip():
+                try:
+                    pane_index = int(parts[2].strip())
+                except Exception:
+                    pane_index = 0
+            panes.append((pane_left, pane_index, pane_id))
+
+        # Only enforce widths when there are two panes (dashboard + terminal).
+        if len(panes) < 2:
+            return
+
+        panes.sort(key=lambda t: (t[0], t[1]))
+        leftmost_pane_id = panes[0][2]
+        _run_outer_tmux(
+            ["resize-pane", "-t", leftmost_pane_id, "-x", str(w)],
+            capture=True,
+            timeout_s=0.2,
+        )
+    except Exception:
+        return
+
+
+def enforce_outer_dashboard_pane_width(width_cols: int = DEFAULT_DASHBOARD_PANE_WIDTH_COLS) -> None:
+    """Best-effort: enforce the fixed dashboard pane width for the outer tmux layout."""
+    _set_outer_dashboard_pane_width(width_cols)
 
 
 def list_inner_windows() -> list[InnerWindow]:
@@ -745,7 +915,7 @@ def list_inner_windows() -> list[InnerWindow]:
                 + OPT_CREATED_AT
                 + "}\t#{"
                 + OPT_NO_TRACK
-                + "}",
+                + "}\t#{pane_pid}\t#{pane_current_command}\t#{pane_tty}",
             ],
             capture=True,
         ).stdout
@@ -775,6 +945,15 @@ def list_inner_windows() -> list[InnerWindow]:
                 pass
         no_track_str = parts[11] if len(parts) > 11 and parts[11] else None
         no_track = no_track_str == "1"
+        pane_pid_str = parts[12] if len(parts) > 12 and parts[12] else None
+        pane_pid: int | None = None
+        if pane_pid_str:
+            try:
+                pane_pid = int(pane_pid_str)
+            except ValueError:
+                pass
+        pane_current_command = parts[13] if len(parts) > 13 and parts[13] else None
+        pane_tty = parts[14] if len(parts) > 14 and parts[14] else None
 
         if terminal_id:
             persisted = state.get(terminal_id) or {}
@@ -833,6 +1012,9 @@ def list_inner_windows() -> list[InnerWindow]:
                 attention=attention,
                 created_at=created_at,
                 no_track=no_track,
+                pane_pid=pane_pid,
+                pane_current_command=pane_current_command,
+                pane_tty=pane_tty,
             )
         )
     # Sort by creation time (newest first). Windows without created_at go to the bottom.
@@ -840,6 +1022,33 @@ def list_inner_windows() -> list[InnerWindow]:
     return windows
 
 
+def list_outer_panes(*, timeout_s: float = 0.2) -> list[str]:
+    """List panes in the outer dashboard window (best-effort).
+
+    Intended for lightweight watchdog checks; returns tab-delimited lines in the same
+    format as `collect_tmux_debug_state()["outer_panes"]["stdout"]`.
+    """
+    if not tmux_available():
+        return []
+    try:
+        proc = _run_outer_tmux(
+            [
+                "list-panes",
+                "-t",
+                f"{OUTER_SESSION}:{OUTER_WINDOW}",
+                "-F",
+                "#{pane_index}\t#{pane_active}\t#{pane_current_command}\t#{pane_pid}\t#{pane_tty}",
+            ],
+            capture=True,
+            timeout_s=timeout_s,
+        )
+    except Exception:
+        return []
+    if proc.returncode != 0:
+        return []
+    return [ln for ln in (proc.stdout or "").splitlines() if ln.strip()]
+
+
 def set_inner_window_options(window_id: str, options: dict[str, str]) -> bool:
     import time as _time
 
@@ -874,7 +1083,8 @@ def create_inner_window(
 
     t0 = _time.time()
     logger.debug("[PERF] create_inner_window START")
-    if not ensure_right_pane():
+    if not ensure_right_pane_ready():
+        logger.warning("create_inner_window: right pane unavailable")
         return None
     logger.debug(f"[PERF] create_inner_window ensure_right_pane: {_time.time() - t0:.3f}s")
 
@@ -903,6 +1113,9 @@ def create_inner_window(
     )
     logger.debug(f"[PERF] create_inner_window new-window: {_time.time() - t2:.3f}s")
     if proc.returncode != 0:
+        detail = (proc.stderr or proc.stdout or "").strip()
+        if detail:
+            logger.warning(f"create_inner_window new-window failed: {detail}")
         return None
 
     created = _parse_lines(proc.stdout or "")
@@ -943,16 +1156,26 @@ def create_inner_window(
 
 
 def select_inner_window(window_id: str) -> bool:
-    if not ensure_right_pane():
+    if not ensure_right_pane_ready():
+        return False
+    proc = _run_inner_tmux(["select-window", "-t", window_id], capture=True)
+    if proc.returncode != 0:
+        detail = (proc.stderr or proc.stdout or "").strip()
+        if detail:
+            logger.warning(f"select_inner_window failed ({window_id}): {detail}")
         return False
-    return _run_inner_tmux(["select-window", "-t", window_id]).returncode == 0
+    return True
 
 
 def focus_right_pane() -> bool:
     """Focus the right pane (terminal area) in the outer tmux layout."""
-    return (
-        _run_outer_tmux(["select-pane", "-t", f"{OUTER_SESSION}:{OUTER_WINDOW}.1"]).returncode == 0
-    )
+    proc = _run_outer_tmux(["select-pane", "-t", f"{OUTER_SESSION}:{OUTER_WINDOW}.1"], capture=True)
+    if proc.returncode != 0:
+        detail = (proc.stderr or proc.stdout or "").strip()
+        if detail:
+            logger.warning(f"focus_right_pane failed: {detail}")
+        return False
+    return True
 
 
 def clear_attention(window_id: str) -> bool:
@@ -992,3 +1215,94 @@ def get_active_context_id(*, allowed_providers: set[str] | None = None) -> str |
 
     context_id = (active.context_id or "").strip()
     return context_id or None
+
+
+def collect_tmux_debug_state() -> dict[str, object]:
+    """Best-effort snapshot of tmux state for diagnosing blank/stuck panes.
+
+    This must be non-intrusive: it should not create sessions or change state.
+    """
+
+    def _cap(proc: subprocess.CompletedProcess[str] | None) -> dict[str, object]:
+        if proc is None:
+            return {}
+
+        def _trim(s: str | None) -> str:
+            text = (s or "").strip()
+            if len(text) > 4000:
+                return text[:4000] + "…(truncated)"
+            return text
+
+        return {
+            "rc": int(getattr(proc, "returncode", -1)),
+            "stdout": _trim(getattr(proc, "stdout", "")),
+            "stderr": _trim(getattr(proc, "stderr", "")),
+        }
+
+    state: dict[str, object] = {
+        "tmux_available": tmux_available(),
+        "in_tmux": in_tmux(),
+        "managed_env": managed_env_enabled(),
+        "outer_socket": OUTER_SOCKET,
+        "inner_socket": INNER_SOCKET,
+        "outer_session": OUTER_SESSION,
+        "outer_window": OUTER_WINDOW,
+        "inner_session": INNER_SESSION,
+    }
+
+    if not tmux_available():
+        return state
+
+    try:
+        state["outer_has_session"] = _cap(
+            _run_outer_tmux(["has-session", "-t", OUTER_SESSION], capture=True, timeout_s=0.5)
+        )
+        state["outer_panes"] = _cap(
+            _run_outer_tmux(
+                [
+                    "list-panes",
+                    "-t",
+                    f"{OUTER_SESSION}:{OUTER_WINDOW}",
+                    "-F",
+                    "#{pane_index}\t#{pane_active}\t#{pane_current_command}\t#{pane_pid}\t#{pane_tty}",
+                ],
+                capture=True,
+                timeout_s=0.5,
+            )
+        )
+    except Exception:
+        pass
+
+    try:
+        state["inner_has_session"] = _cap(
+            _run_inner_tmux(["has-session", "-t", INNER_SESSION], capture=True, timeout_s=0.5)
+        )
+        state["inner_windows"] = _cap(
+            _run_inner_tmux(
+                [
+                    "list-windows",
+                    "-t",
+                    INNER_SESSION,
+                    "-F",
+                    "#{window_id}\t#{window_index}\t#{window_name}\t#{window_active}\t#{"
+                    + OPT_TERMINAL_ID
+                    + "}\t#{"
+                    + OPT_PROVIDER
+                    + "}\t#{"
+                    + OPT_SESSION_TYPE
+                    + "}\t#{"
+                    + OPT_SESSION_ID
+                    + "}\t#{"
+                    + OPT_CONTEXT_ID
+                    + "}\t#{"
+                    + OPT_ATTENTION
+                    + "}",
+                ],
+                capture=True,
+                timeout_s=0.5,
+            )
+        )
+    except Exception:
+        pass
+
+    return state