glaip-sdk 0.1.2__py3-none-any.whl → 0.7.17__py3-none-any.whl

glaip_sdk/cli/slash/session.py

@@ -6,10 +6,13 @@ Authors:
 
 from __future__ import annotations
 
+import asyncio
 import importlib
 import os
 import shlex
 import sys
+import threading
+import time
 from collections.abc import Callable, Iterable
 from dataclasses import dataclass
 from difflib import get_close_matches
@@ -18,6 +21,7 @@ from typing import Any
 
 import click
 from rich.console import Console, Group
+from rich.live import Live
 from rich.text import Text
 
 from glaip_sdk.branding import (
@@ -32,9 +36,19 @@ from glaip_sdk.branding import (
     SUCCESS_STYLE,
     WARNING_STYLE,
     AIPBranding,
+    LogoAnimator,
 )
-from glaip_sdk.cli.commands.configure import configure_command, load_config
+from glaip_sdk.cli.account_store import get_account_store
+from glaip_sdk.cli.auth import resolve_api_url_from_context
+from glaip_sdk.cli.commands import transcripts as transcripts_cmd
+from glaip_sdk.cli.commands.configure import _configure_interactive, load_config
 from glaip_sdk.cli.commands.update import update_command
+from glaip_sdk.cli.core.context import get_client, restore_slash_session_context
+from glaip_sdk.cli.core.output import format_size
+from glaip_sdk.cli.core.prompting import _fuzzy_pick_for_resources
+from glaip_sdk.cli.hints import command_hint, format_command_hint
+from glaip_sdk.cli.slash.accounts_controller import AccountsController
+from glaip_sdk.cli.slash.accounts_shared import env_credentials_present
 from glaip_sdk.cli.slash.agent_session import AgentRunSession
 from glaip_sdk.cli.slash.prompt import (
     FormattedText,
@@ -44,20 +58,14 @@ from glaip_sdk.cli.slash.prompt import (
     setup_prompt_toolkit,
     to_formatted_text,
 )
+from glaip_sdk.cli.slash.remote_runs_controller import RemoteRunsController
+from glaip_sdk.cli.slash.tui.context import TUIContext
 from glaip_sdk.cli.transcript import (
     export_cached_transcript,
-    normalise_export_destination,
-    resolve_manifest_for_export,
-    suggest_filename,
+    load_history_snapshot,
 )
 from glaip_sdk.cli.transcript.viewer import ViewerContext, run_viewer_session
 from glaip_sdk.cli.update_notifier import maybe_notify_update
-from glaip_sdk.cli.utils import (
-    _fuzzy_pick_for_resources,
-    command_hint,
-    format_command_hint,
-    get_client,
-)
 from glaip_sdk.rich_components import AIPGrid, AIPPanel, AIPTable
 
 SlashHandler = Callable[["SlashSession", list[str], bool], bool]
@@ -71,6 +79,88 @@ class SlashCommand:
     help: str
     handler: SlashHandler
     aliases: tuple[str, ...] = ()
+    agent_only: bool = False
+
+
+NEW_QUICK_ACTIONS: tuple[dict[str, Any], ...] = (
+    {
+        "cli": "transcripts",
+        "slash": "transcripts",
+        "description": "Review transcript cache",
+        "tag": "NEW",
+        "priority": 10,
+        "scope": "global",
+    },
+    {
+        "cli": None,
+        "slash": "runs",
+        "description": "View remote run history for the active agent",
+        "tag": "NEW",
+        "priority": 8,
+        "scope": "agent",
+    },
+)
+
+
+DEFAULT_QUICK_ACTIONS: tuple[dict[str, Any], ...] = (
+    {
+        "cli": None,
+        "slash": "accounts",
+        "description": "Switch account profile",
+        "priority": 5,
+    },
+    {
+        "cli": "status",
+        "slash": "status",
+        "description": "Connection check",
+        "priority": 0,
+    },
+    {
+        "cli": "agents list",
+        "slash": "agents",
+        "description": "Browse agents",
+        "priority": 0,
+    },
+    {
+        "cli": "help",
+        "slash": "help",
+        "description": "Show all commands",
+        "priority": 0,
+    },
+    {
+        "cli": "configure",
+        "slash": "login",
+        "description": f"Configure credentials (alias [{HINT_COMMAND_STYLE}]/configure[/])",
+        "priority": -1,
+    },
+)
+
+
+HELP_COMMAND = "/help"
+
+
+def _quick_action_scope(action: dict[str, Any]) -> str:
+    """Return the scope for a quick action definition."""
+    scope = action.get("scope") or "global"
+    if isinstance(scope, str):
+        return scope.lower()
+    return "global"
+
+
+@dataclass
+class AnimationState:
+    """State for logo animation shared between threads.
+
+    Uses mutable lists for integer values to allow thread-safe updates
+    without requiring locks or atomic operations.
+    """
+
+    pulse_step: list[int]  # Current animation step position
+    pulse_direction: list[int]  # Direction of pulse (1 or -1)
+    step_size: list[int]  # Step size for animation
+    current_status: list[str]  # Current status message
+    animation_running: threading.Event  # Event signaling animation is running
+    stop_requested: threading.Event  # Event signaling stop was requested
 
 
 class SlashSession:
@@ -84,7 +174,11 @@ class SlashSession:
             console: Optional console instance, creates default if None
         """
         self.ctx = ctx
-        self.console = console or Console()
+        self._interactive = bool(sys.stdin.isatty() and sys.stdout.isatty())
+        if console is None:
+            self.console = AIPBranding._make_console(force_terminal=self._interactive, soft_wrap=False)
+        else:
+            self.console = console
         self._commands: dict[str, SlashCommand] = {}
         self._unique_commands: dict[str, SlashCommand] = {}
         self._contextual_commands: dict[str, str] = {}
@@ -93,13 +187,13 @@ class SlashSession:
         self.recent_agents: list[dict[str, str]] = []
         self.last_run_input: str | None = None
         self._should_exit = False
-        self._interactive = bool(sys.stdin.isatty() and sys.stdout.isatty())
         self._config_cache: dict[str, Any] | None = None
         self._welcome_rendered = False
         self._active_renderer: Any | None = None
         self._current_agent: Any | None = None
+        self._runs_pagination_state: dict[str, dict[str, Any]] = {}  # agent_id -> {page, limit, cursor}
 
-        self._home_placeholder = "Start with / to browse commands"
+        self._home_placeholder = "Hint: type / to explore commands · Ctrl+D exits"
 
         # Command string constants to avoid duplication
         self.STATUS_COMMAND = "/status"
@@ -116,13 +210,29 @@ class SlashSession:
         self._update_notifier = maybe_notify_update
         self._home_hint_shown = False
         self._agent_transcript_ready: dict[str, str] = {}
+        self.tui_ctx: TUIContext | None = None
+
+    # Animation configuration constants
+    ANIMATION_FPS = 20
+    ANIMATION_FRAME_DURATION = 1.0 / ANIMATION_FPS  # 0.05 seconds
+    ANIMATION_STARTUP_DELAY = 0.1  # Delay to ensure animation starts
+
+    # Startup UI constants
+    INITIALIZING_STATUS = "Initializing..."
+    CLI_HEADING_MARKUP = "[bold]>_ GDP Labs AI Agents Package (AIP CLI)[/bold]"
 
     # ------------------------------------------------------------------
     # Session orchestration
     # ------------------------------------------------------------------
-    def refresh_branding(self, sdk_version: str | None = None) -> None:
+    def refresh_branding(
+        self,
+        sdk_version: str | None = None,
+        *,
+        branding_cls: type[AIPBranding] | None = None,
+    ) -> None:
         """Refresh branding assets after an in-session SDK upgrade."""
-        self._branding = AIPBranding.create_from_sdk(
+        branding_type = branding_cls or AIPBranding
+        self._branding = branding_type.create_from_sdk(
             sdk_version=sdk_version,
             package_name="glaip-sdk",
         )
@@ -132,6 +242,7 @@ class SlashSession:
         self._render_header(initial=True)
 
     def _setup_prompt_toolkit(self) -> None:
+        """Initialize prompt_toolkit session and style."""
         session, style = setup_prompt_toolkit(self, interactive=self._interactive)
         self._ptk_session = session
         self._ptk_style = style
@@ -149,20 +260,301 @@ class SlashSession:
                 self._run_non_interactive(initial_commands)
                 return
 
-            if not self._ensure_configuration():
+            # Use animated logo during initialization if supported
+            animator = LogoAnimator(console=self.console)
+            if animator.should_animate() and self._interactive:
+                config_available = self._run_with_animated_logo(animator)
+            else:
+                # Fallback to static logo for non-TTY or NO_COLOR
+                config_available = self._run_with_static_logo(animator)
+
+            if not config_available:
                 return
 
-            self._maybe_show_update_prompt()
-            self._render_header(initial=not self._welcome_rendered)
+            self._render_header(initial=not self._welcome_rendered, show_branding=False)
             if not self._default_actions_shown:
                 self._show_default_quick_actions()
             self._run_interactive_loop()
         finally:
             if ctx_obj is not None:
-                if previous_session is None:
-                    ctx_obj.pop("_slash_session", None)
+                restore_slash_session_context(ctx_obj, previous_session)
+
+    def _initialize_tui_context(self) -> None:
+        """Initialize TUI context with error handling.
+
+        Sets self.tui_ctx to None if initialization fails.
+        """
+        try:
+            self.tui_ctx = asyncio.run(TUIContext.create(detect_osc11=False))
+        except RuntimeError:
+            try:
+                loop = asyncio.get_event_loop()
+            except RuntimeError:
+                self.tui_ctx = None
+            else:
+                if loop.is_running():
+                    self.tui_ctx = None
                 else:
-                    ctx_obj["_slash_session"] = previous_session
+                    self.tui_ctx = loop.run_until_complete(TUIContext.create(detect_osc11=False))
+        except Exception:
+            self.tui_ctx = None
+
+    def _run_initialization_tasks(
+        self,
+        current_status: list[str],
+        animation_running: threading.Event,
+        status_callback: Callable[[str], None] | None = None,
+    ) -> bool:
+        """Run initialization tasks with status updates.
+
+        Args:
+            current_status: Mutable list with current status message.
+            animation_running: Event to signal animation state.
+            status_callback: Optional callback to invoke when status changes.
+
+        Returns:
+            True if configuration is available, False otherwise.
+        """
+        # Task 1: TUI Context.
+        current_status[0] = "Detecting terminal..."
+        if status_callback:
+            status_callback(current_status[0])
+        self._initialize_tui_context()
+
+        # Task 2: Configuration.
+        current_status[0] = "Connecting to API..."
+        if status_callback:
+            status_callback(current_status[0])
+        if not self._ensure_configuration():
+            animation_running.clear()
+            return False
+
+        # Task 3: Updates.
+        current_status[0] = "Checking for updates..."
+        if status_callback:
+            status_callback(current_status[0])
+        # Defer update prompt if we are in animated initialization to avoid blocking/cluttering
+        self._maybe_show_update_prompt(defer=bool(status_callback is None))
+        return True
+
+    def _update_pulse_step(
+        self,
+        state: AnimationState,
+        animator: LogoAnimator,
+    ) -> bool:
+        """Update pulse step and direction.
+
+        Args:
+            state: Animation state container.
+            animator: LogoAnimator instance for animation.
+
+        Returns:
+            True if animation should continue, False if should stop.
+        """
+        state.pulse_step[0] += state.pulse_direction[0] * state.step_size[0]
+        if state.pulse_step[0] >= animator.max_width + 5:
+            state.pulse_step[0] = animator.max_width + 5
+            state.pulse_direction[0] = -1
+            return not state.stop_requested.is_set()
+        if state.pulse_step[0] <= -5:
+            state.pulse_step[0] = -5
+            state.pulse_direction[0] = 1
+            return not state.stop_requested.is_set()
+        return True
+
+    def _create_animation_updater(
+        self,
+        animator: LogoAnimator,
+        state: AnimationState,
+        heading: Text,
+    ) -> Callable[[Live], None]:
+        """Create animation update function for background thread.
+
+        Args:
+            animator: LogoAnimator instance for animation.
+            state: Animation state container.
+            heading: Text heading for frames.
+
+        Returns:
+            Function to update animation in background thread.
+        """
+
+        def build_frame(step: int, status_text: str) -> Group:
+            return Group(heading, Text(""), animator.generate_frame(step, status_text))
+
+        def update_animation(live: Live) -> None:
+            """Update animation in background thread."""
+            while state.animation_running.is_set():
+                # Calculate next step
+                if not self._update_pulse_step(state, animator):
+                    break
+
+                # Update frame with current status
+                try:
+                    live.update(build_frame(state.pulse_step[0], state.current_status[0]))
+                except Exception:
+                    # Animation may be stopped, ignore errors
+                    break
+                time.sleep(self.ANIMATION_FRAME_DURATION)
+            state.animation_running.clear()
+
+        return update_animation
+
+    def _stop_animation_thread(
+        self,
+        animation_thread: threading.Thread,
+        state: AnimationState,
+    ) -> None:
+        """Stop animation thread gracefully.
+
+        Args:
+            animation_thread: Thread running animation.
+            state: Animation state container.
+        """
+        state.stop_requested.set()
+        state.step_size[0] = 3
+        animation_thread.join(timeout=1.5)
+        if animation_thread.is_alive():
+            state.animation_running.clear()
+            animation_thread.join(timeout=0.2)
+
+    def _run_animated_initialization(
+        self,
+        live: Live,
+        animator: LogoAnimator,
+        state: AnimationState,
+        heading: Text,
+        banner: Text,
+    ) -> bool:
+        """Run initialization tasks with animated logo.
+
+        Args:
+            live: Live context for animation updates.
+            animator: LogoAnimator instance for animation.
+            state: Animation state container.
+            heading: Text heading for frames.
+            banner: Text banner for final display.
+
+        Returns:
+            True if configuration is available, False otherwise.
+        """
+
+        def build_banner() -> Group:
+            return Group(heading, Text(""), banner)
+
+        update_animation = self._create_animation_updater(
+            animator,
+            state,
+            heading,
+        )
+
+        # Start animation thread.
+        animation_thread = threading.Thread(target=update_animation, args=(live,), daemon=True)
+        animation_thread.start()
+
+        # Small delay to ensure animation starts.
+        time.sleep(self.ANIMATION_STARTUP_DELAY)
+
+        # Run initialization tasks.
+        if not self._run_initialization_tasks(state.current_status, state.animation_running, status_callback=None):
+            return False
+
+        # Stop animation and show final banner.
+        self._stop_animation_thread(animation_thread, state)
+        live.update(build_banner())
+        return True
+
+    def _run_with_animated_logo(self, animator: LogoAnimator) -> bool:
+        """Run initialization with animated logo.
+
+        Args:
+            animator: LogoAnimator instance for animation.
+
+        Returns:
+            True if configuration is available, False otherwise.
+        """
+        state = AnimationState(
+            pulse_step=[0],  # Use list for mutable shared state.
+            pulse_direction=[1],  # Use list for mutable shared state.
+            step_size=[1],
+            current_status=[self.INITIALIZING_STATUS],
+            animation_running=threading.Event(),
+            stop_requested=threading.Event(),
+        )
+        state.animation_running.set()
+        heading = Text.from_markup(self.CLI_HEADING_MARKUP)
+        banner = Text.from_markup(self._branding.get_welcome_banner())
+
+        def build_frame(step: int, status_text: str) -> Group:
+            return Group(heading, Text(""), animator.generate_frame(step, status_text))
+
+        try:
+            with Live(
+                build_frame(0, state.current_status[0]),
+                console=self.console,
+                refresh_per_second=self.ANIMATION_FPS,
+                transient=False,
+            ) as live:
+                return self._run_animated_initialization(
+                    live,
+                    animator,
+                    state,
+                    heading,
+                    banner,
+                )
+        except KeyboardInterrupt:
+            # Graceful exit on Ctrl+C
+            state.animation_running.clear()
+            # Align with static path: show heading and cancellation message
+            heading = Text.from_markup(self.CLI_HEADING_MARKUP)
+            self.console.print(Group(heading, Text(""), animator.static_frame("Initialization cancelled.")))
+            return False
+
+    def _run_with_static_logo(self, animator: LogoAnimator) -> bool:
+        """Run initialization with static logo (non-TTY or NO_COLOR).
+
+        Args:
+            animator: LogoAnimator instance for static display.
+
+        Returns:
+            True if configuration is available, False otherwise.
+        """
+        heading = Text.from_markup(self.CLI_HEADING_MARKUP)
+        banner = Text.from_markup(self._branding.get_welcome_banner())
+
+        def build_frame(status_text: str) -> Group:
+            return Group(heading, Text(""), animator.static_frame(status_text))
+
+        def build_banner() -> Group:
+            return Group(heading, Text(""), banner)
+
+        try:
+            with Live(
+                build_frame(self.INITIALIZING_STATUS),
+                console=self.console,
+                refresh_per_second=4,
+                transient=False,
+            ) as live:
+                # Run initialization tasks with status updates, reusing shared logic.
+                current_status = [self.INITIALIZING_STATUS]
+                animation_running = threading.Event()
+                animation_running.set()
+
+                # Update Live display when status changes via callback.
+                def update_display(status: str) -> None:
+                    """Update Live display with current status."""
+                    live.update(build_frame(status))
+
+                if not self._run_initialization_tasks(
+                    current_status, animation_running, status_callback=update_display
+                ):
+                    return False
+
+                live.update(build_banner())
+                return True
+        except KeyboardInterrupt:
+            self.console.print(Group(heading, Text(""), animator.static_frame("Initialization cancelled.")))
+            return False
 
     def _run_interactive_loop(self) -> None:
         """Run the main interactive command loop."""
@@ -208,34 +600,124 @@ class SlashSession:
             if not self.handle_command(raw):
                 break
 
+    def _handle_account_selection(self) -> bool:
+        """Handle account selection when accounts exist but none are active.
+
+        Returns:
+            True if configuration is ready after selection, False if user aborted.
+        """
+        self.console.print(f"[{INFO_STYLE}]No active account selected. Please choose an account:[/]")
+        try:
+            self._cmd_accounts([], False)
+            self._config_cache = None
+            return self._check_configuration_after_selection()
+        except KeyboardInterrupt:
+            self.console.print(f"[{ERROR_STYLE}]Account selection aborted. Closing the command palette.[/]")
+            return False
+
+    def _check_configuration_after_selection(self) -> bool:
+        """Check if configuration is ready after account selection.
+
+        Returns:
+            True if configuration is ready, False otherwise.
+        """
+        return self._configuration_ready()
+
+    def _handle_new_account_creation(self) -> bool:
+        """Handle new account creation when no accounts exist.
+
+        Returns:
+            True if configuration succeeded, False if user aborted.
+        """
+        previous_tip_env = os.environ.get("AIP_SUPPRESS_CONFIGURE_TIP")
+        os.environ["AIP_SUPPRESS_CONFIGURE_TIP"] = "1"
+        self._suppress_login_layout = True
+        try:
+            self._cmd_login([], False)
+            return True
+        except KeyboardInterrupt:
+            self.console.print(f"[{ERROR_STYLE}]Configuration aborted. Closing the command palette.[/]")
+            return False
+        finally:
+            self._suppress_login_layout = False
+            if previous_tip_env is None:
+                os.environ.pop("AIP_SUPPRESS_CONFIGURE_TIP", None)
+            else:
+                os.environ["AIP_SUPPRESS_CONFIGURE_TIP"] = previous_tip_env
+
     def _ensure_configuration(self) -> bool:
         """Ensure the CLI has both API URL and credentials before continuing."""
         while not self._configuration_ready():
-            self.console.print(f"[{WARNING_STYLE}]Configuration required.[/] Launching `/login` wizard...")
-            self._suppress_login_layout = True
-            try:
-                self._cmd_login([], False)
-            except KeyboardInterrupt:
-                self.console.print(f"[{ERROR_STYLE}]Configuration aborted. Closing the command palette.[/]")
+            store = get_account_store()
+            accounts = store.list_accounts()
+            active_account = store.get_active_account()
+
+            # If accounts exist but none are active, show accounts list first
+            if accounts and (not active_account or active_account not in accounts):
+                if not self._handle_account_selection():
+                    return False
+                continue
+
+            # No accounts exist - prompt for configuration
+            if not self._handle_new_account_creation():
                 return False
-            finally:
-                self._suppress_login_layout = False
 
         return True
 
+    def _get_credentials_from_context_and_env(self) -> tuple[str, str]:
+        """Get credentials from context and environment variables.
+
+        Returns:
+            Tuple of (api_url, api_key) from context/env overrides.
+        """
+        api_url = ""
+        api_key = ""
+        if isinstance(self.ctx.obj, dict):
+            api_url = self.ctx.obj.get("api_url", "")
+            api_key = self.ctx.obj.get("api_key", "")
+        # Environment variables take precedence
+        env_url = os.getenv("AIP_API_URL", "")
+        env_key = os.getenv("AIP_API_KEY", "")
+        return (env_url or api_url, env_key or api_key)
+
+    def _get_credentials_from_account_store(self) -> tuple[str, str] | None:
+        """Get credentials from the active account in account store.
+
+        Returns:
+            Tuple of (api_url, api_key) if active account exists, None otherwise.
+        """
+        store = get_account_store()
+        active_account = store.get_active_account()
+        if not active_account:
+            return None
+
+        account = store.get_account(active_account)
+        if not account:
+            return None
+
+        api_url = account.get("api_url", "")
+        api_key = account.get("api_key", "")
+        return (api_url, api_key)
+
     def _configuration_ready(self) -> bool:
         """Check whether API URL and credentials are available."""
-        config = self._load_config()
-        api_url = self._get_api_url(config)
-        if not api_url:
+        # Check for explicit overrides in context/env first
+        override_url, override_key = self._get_credentials_from_context_and_env()
+        if override_url and override_key:
+            return True
+
+        # Read from account store directly to avoid stale cache
+        account_creds = self._get_credentials_from_account_store()
+        if account_creds is None:
             return False
 
-        api_key: str | None = None
-        if isinstance(self.ctx.obj, dict):
-            api_key = self.ctx.obj.get("api_key")
+        store_url, store_key = account_creds
+
+        # Use override values if available, otherwise use store values
+        api_url = override_url or store_url
+        api_key = override_key or store_key
 
-        api_key = api_key or config.get("api_key") or os.getenv("AIP_API_KEY")
-        return bool(api_key)
+        return bool(api_url and api_key)
 
     def handle_command(self, raw: str, *, invoked_from_agent: bool = False) -> bool:
         """Parse and execute a single slash command string."""
@@ -250,7 +732,7 @@ class SlashSession:
             if suggestion:
                 self.console.print(f"[{WARNING_STYLE}]Unknown command '{verb}'. Did you mean '/{suggestion}'?[/]")
             else:
-                help_command = "/help"
+                help_command = HELP_COMMAND
                 help_hint = format_command_hint(help_command) or help_command
                 self.console.print(
                     f"[{WARNING_STYLE}]Unknown command '{verb}'. Type {help_hint} for a list of options.[/]"
@@ -263,15 +745,28 @@ class SlashSession:
             return False
         return True
 
+    def _continue_session(self) -> bool:
+        """Signal that the slash session should remain active."""
+        return not self._should_exit
+
     # ------------------------------------------------------------------
     # Command handlers
     # ------------------------------------------------------------------
     def _cmd_help(self, _args: list[str], invoked_from_agent: bool) -> bool:
+        """Handle the /help command.
+
+        Args:
+            _args: Command arguments (unused).
+            invoked_from_agent: Whether invoked from agent context.
+
+        Returns:
+            True to continue session.
+        """
         try:
             if invoked_from_agent:
                 self._render_agent_help()
             else:
-                self._render_global_help()
+                self._render_global_help(include_agent_hint=True)
         except Exception as exc:  # pragma: no cover - UI/display errors
             self.console.print(f"[{ERROR_STYLE}]Error displaying help: {exc}[/]")
             return False
@@ -279,15 +774,17 @@ class SlashSession:
         return True
 
     def _render_agent_help(self) -> None:
+        """Render help text for agent context commands."""
         table = AIPTable()
         table.add_column("Input", style=HINT_COMMAND_STYLE, no_wrap=True)
         table.add_column("What happens", style=HINT_DESCRIPTION_COLOR)
         table.add_row("<message>", "Run the active agent once with that prompt.")
-        table.add_row("/details", "Show the full agent export and metadata.")
+        table.add_row("/details", "Show the agent export (prompts to expand instructions).")
         table.add_row(self.STATUS_COMMAND, "Display connection status without leaving.")
+        table.add_row("/runs", "✨ NEW · Open the remote run browser for this agent.")
         table.add_row("/export [path]", "Export the latest agent transcript as JSONL.")
         table.add_row("/exit (/back)", "Return to the slash home screen.")
-        table.add_row("/help (/?)", "Display this context-aware menu.")
+        table.add_row(f"{HELP_COMMAND} (/?)", "Display this context-aware menu.")
 
         panel_items = [table]
         if self.last_run_input:
@@ -305,13 +802,28 @@ class SlashSession:
                 border_style=PRIMARY,
             )
         )
+        new_commands_table = AIPTable()
+        new_commands_table.add_column("Command", style=HINT_COMMAND_STYLE, no_wrap=True)
+        new_commands_table.add_column("Description", style=HINT_DESCRIPTION_COLOR)
+        new_commands_table.add_row(
+            "/runs",
+            "✨ NEW · View remote run history with keyboard navigation and export options.",
+        )
+        self.console.print(
+            AIPPanel(
+                new_commands_table,
+                title="New commands",
+                border_style=SECONDARY_LIGHT,
+            )
+        )
 
-    def _render_global_help(self) -> None:
+    def _render_global_help(self, *, include_agent_hint: bool = False) -> None:
+        """Render help text for global slash commands."""
         table = AIPTable()
         table.add_column("Command", style=HINT_COMMAND_STYLE, no_wrap=True)
         table.add_column("Description", style=HINT_DESCRIPTION_COLOR)
 
-        for cmd in sorted(self._unique_commands.values(), key=lambda c: c.name):
+        for cmd in self._visible_commands(include_agent_only=False):
             aliases = ", ".join(f"/{alias}" for alias in cmd.aliases if alias)
             verb = f"/{cmd.name}"
             if aliases:
@@ -331,12 +843,27 @@ class SlashSession:
                 border_style=PRIMARY,
             )
         )
+        if include_agent_hint:
+            self.console.print(
+                "[dim]Additional commands (e.g. `/runs`) become available after you pick an agent with `/agents`. "
+                "Those agent-only commands stay hidden here to avoid confusion.[/]"
+            )
 
     def _cmd_login(self, _args: list[str], _invoked_from_agent: bool) -> bool:
+        """Handle the /login command.
+
+        Args:
+            _args: Command arguments (unused).
+            _invoked_from_agent: Whether invoked from agent context (unused).
+
+        Returns:
+            True to continue session.
+        """
         self.console.print(f"[{ACCENT_STYLE}]Launching configuration wizard...[/]")
         try:
-            self.ctx.invoke(configure_command)
-            self._config_cache = None
+            # Use the modern account-aware wizard directly (bypasses legacy config gating)
+            _configure_interactive(account_name=None)
+            self.on_account_switched()
             if self._suppress_login_layout:
                 self._welcome_rendered = False
                 self._default_actions_shown = False
@@ -345,9 +872,18 @@ class SlashSession:
                 self._show_default_quick_actions()
         except click.ClickException as exc:
             self.console.print(f"[{ERROR_STYLE}]{exc}[/]")
-        return True
+        return self._continue_session()
 
     def _cmd_status(self, _args: list[str], _invoked_from_agent: bool) -> bool:
+        """Handle the /status command.
+
+        Args:
+            _args: Command arguments (unused).
+            _invoked_from_agent: Whether invoked from agent context (unused).
+
+        Returns:
+            True to continue session.
+        """
         ctx_obj = self.ctx.obj if isinstance(self.ctx.obj, dict) else None
         previous_console = None
         try:
@@ -374,9 +910,176 @@ class SlashSession:
                     ctx_obj.pop("_slash_console", None)
                 else:
                     ctx_obj["_slash_console"] = previous_console
-        return True
+        return self._continue_session()
+
+    def _cmd_transcripts(self, args: list[str], _invoked_from_agent: bool) -> bool:
+        """Handle the /transcripts command.
+
+        Args:
+            args: Command arguments (limit or detail/show with run_id).
+            _invoked_from_agent: Whether invoked from agent context (unused).
+
+        Returns:
+            True to continue session.
+        """
+        if args and args[0].lower() in {"detail", "show"}:
+            if len(args) < 2:
+                self.console.print(f"[{WARNING_STYLE}]Usage: /transcripts detail <run_id>[/]")
+                return self._continue_session()
+            self._show_transcript_detail(args[1])
+            return self._continue_session()
+
+        limit, ok = self._parse_transcripts_limit(args)
+        if not ok:
+            return self._continue_session()
+
+        snapshot = load_history_snapshot(limit=limit, ctx=self.ctx)
+
+        if self._handle_transcripts_empty(snapshot, limit):
+            return self._continue_session()
+
+        self._render_transcripts_snapshot(snapshot)
+        return self._continue_session()
+
+    def _parse_transcripts_limit(self, args: list[str]) -> tuple[int | None, bool]:
+        """Parse limit argument from transcripts command.
+
+        Args:
+            args: Command arguments.
+
+        Returns:
+            Tuple of (limit value or None, success boolean).
+        """
+        if not args:
+            return None, True
+        try:
+            limit = int(args[0])
+        except ValueError:
+            self.console.print(f"[{WARNING_STYLE}]Usage: /transcripts [limit][/]")
+            return None, False
+        if limit < 0:
+            self.console.print(f"[{WARNING_STYLE}]Usage: /transcripts [limit][/]")
+            return None, False
+        return limit, True
+
+    def _handle_transcripts_empty(self, snapshot: Any, limit: int | None) -> bool:
+        """Handle empty transcript snapshot cases.
+
+        Args:
+            snapshot: Transcript snapshot object.
+            limit: Limit value or None.
+
+        Returns:
+            True if empty case was handled, False otherwise.
+        """
+        if snapshot.cached_entries == 0:
+            self.console.print(f"[{WARNING_STYLE}]No cached transcripts yet. Run an agent first.[/]")
+            for warning in snapshot.warnings:
+                self.console.print(f"[{WARNING_STYLE}]{warning}[/]")
+            return True
+        if limit == 0 and snapshot.cached_entries:
+            self.console.print(f"[{WARNING_STYLE}]Limit is 0; nothing to display.[/]")
+            return True
+        return False
+
+    def _render_transcripts_snapshot(self, snapshot: Any) -> None:
+        """Render transcript snapshot table and metadata.
+
+        Args:
+            snapshot: Transcript snapshot object to render.
+        """
+        size_text = format_size(snapshot.total_size_bytes)
+        header = f"[dim]Manifest: {snapshot.manifest_path} · {snapshot.total_entries} runs · {size_text} used[/]"
+        self.console.print(header)
+
+        if snapshot.limit_clamped:
+            self.console.print(
+                f"[{WARNING_STYLE}]Requested limit exceeded maximum; showing first {snapshot.limit_applied} runs.[/]"
+            )
+
+        if snapshot.total_entries > len(snapshot.entries):
+            subset_message = (
+                f"[dim]Showing {len(snapshot.entries)} of {snapshot.total_entries} "
+                f"runs (limit={snapshot.limit_applied}).[/]"
+            )
+            self.console.print(subset_message)
+            self.console.print("[dim]Hint: run `/transcripts <limit>` to change how many rows are displayed.[/]")
+
+        if snapshot.migration_summary:
+            self.console.print(f"[{INFO_STYLE}]{snapshot.migration_summary}[/]")
+
+        for warning in snapshot.warnings:
+            self.console.print(f"[{WARNING_STYLE}]{warning}[/]")
+
+        table = transcripts_cmd._build_table(snapshot.entries)
+        self.console.print(table)
+        self.console.print("[dim]! Missing transcript[/]")
+
+    def _show_transcript_detail(self, run_id: str) -> None:
+        """Render the cached transcript log for a single run."""
+        snapshot = load_history_snapshot(ctx=self.ctx)
+        entry = snapshot.index.get(run_id)
+        if entry is None:
+            self.console.print(f"[{WARNING_STYLE}]Run id {run_id} was not found in the cache manifest.[/]")
+            return
+
+        try:
+            transcript_path, transcript_text = transcripts_cmd._load_transcript_text(entry)
+        except click.ClickException as exc:
+            self.console.print(f"[{WARNING_STYLE}]{exc}[/]")
+            return
+
+        meta, events = transcripts_cmd._decode_transcript(transcript_text)
+        if transcripts_cmd._maybe_launch_transcript_viewer(
+            self.ctx,
+            entry,
+            meta,
+            events,
+            console_override=self.console,
+            force=True,
+            initial_view="transcript",
+        ):
+            if snapshot.migration_summary:
+                self.console.print(f"[{INFO_STYLE}]{snapshot.migration_summary}[/]")
+            for warning in snapshot.warnings:
+                self.console.print(f"[{WARNING_STYLE}]{warning}[/]")
+            return
+
+        if snapshot.migration_summary:
+            self.console.print(f"[{INFO_STYLE}]{snapshot.migration_summary}[/]")
+        for warning in snapshot.warnings:
+            self.console.print(f"[{WARNING_STYLE}]{warning}[/]")
+        view = transcripts_cmd._render_transcript_display(entry, snapshot.manifest_path, transcript_path, meta, events)
+        self.console.print(view, markup=False, highlight=False, soft_wrap=True, end="")
+
+    def _cmd_runs(self, args: list[str], _invoked_from_agent: bool) -> bool:
+        """Handle the /runs command for browsing remote agent run history.
+
+        Args:
+            args: Command arguments (optional run_id for detail view).
+            _invoked_from_agent: Whether invoked from agent context.
+
+        Returns:
+            True to continue session.
+        """
+        controller = RemoteRunsController(self)
+        return controller.handle_runs_command(args)
+
+    def _cmd_accounts(self, args: list[str], _invoked_from_agent: bool) -> bool:
+        """Handle the /accounts command for listing and switching accounts."""
+        controller = AccountsController(self)
+        return controller.handle_accounts_command(args)
 
     def _cmd_agents(self, args: list[str], _invoked_from_agent: bool) -> bool:
+        """Handle the /agents command.
+
+        Args:
+            args: Command arguments (optional agent reference).
+            _invoked_from_agent: Whether invoked from agent context (unused).
+
+        Returns:
+            True to continue session.
+        """
         client = self._get_client_or_fail()
         if not client:
             return True
@@ -442,7 +1145,7 @@ class SlashSession:
         self._render_header()
 
         self._show_agent_followup_actions(picked_agent)
-        return True
+        return self._continue_session()
 
     def _show_agent_followup_actions(self, picked_agent: Any) -> None:
         """Show follow-up action hints after agent session."""
@@ -454,6 +1157,7 @@ class SlashSession:
             hints.append((f"/agents {agent_id}", f"Reopen {agent_label}"))
         hints.extend(
             [
+                ("/accounts", "Switch account"),
                 (self.AGENTS_COMMAND, "Browse agents"),
                 (self.STATUS_COMMAND, "Check connection"),
             ]
@@ -462,6 +1166,15 @@ class SlashSession:
         self._show_quick_actions(hints, title="Next actions")
 
     def _cmd_exit(self, _args: list[str], invoked_from_agent: bool) -> bool:
+        """Handle the /exit command.
+
+        Args:
+            _args: Command arguments (unused).
+            invoked_from_agent: Whether invoked from agent context.
+
+        Returns:
+            False to exit session, True to continue.
+        """
         if invoked_from_agent:
             # Returning False would stop the full session; we only want to exit
             # the agent context. Raising a custom flag keeps the outer loop
@@ -475,6 +1188,7 @@ class SlashSession:
     # Utilities
     # ------------------------------------------------------------------
     def _register_defaults(self) -> None:
+        """Register default slash commands."""
         self._register(
             SlashCommand(
                 name="help",
@@ -486,7 +1200,7 @@ class SlashSession:
         self._register(
             SlashCommand(
                 name="login",
-                help="Run `/login` (alias `/configure`) to set credentials.",
+                help="Configure API credentials (alias `/configure`).",
                 handler=SlashSession._cmd_login,
                 aliases=("configure",),
             )
@@ -498,6 +1212,23 @@ class SlashSession:
                 handler=SlashSession._cmd_status,
             )
         )
+        self._register(
+            SlashCommand(
+                name="accounts",
+                help="✨ NEW · Browse and switch stored accounts (Textual with Rich fallback).",
+                handler=SlashSession._cmd_accounts,
+            )
+        )
+        self._register(
+            SlashCommand(
+                name="transcripts",
+                help=(
+                    "✨ NEW · Review cached transcript history. "
+                    "Add a number (e.g. `/transcripts 5`) to change the row limit."
+                ),
+                handler=SlashSession._cmd_transcripts,
+            )
+        )
         self._register(
             SlashCommand(
                 name="agents",
@@ -527,12 +1258,32 @@ class SlashSession:
                 handler=SlashSession._cmd_update,
             )
         )
+        self._register(
+            SlashCommand(
+                name="runs",
+                help="✨ NEW · Browse remote agent run history (requires active agent session).",
+                handler=SlashSession._cmd_runs,
+                agent_only=True,
+            )
+        )
 
     def _register(self, command: SlashCommand) -> None:
+        """Register a slash command.
+
+        Args:
+            command: SlashCommand to register.
+        """
         self._unique_commands[command.name] = command
         for key in (command.name, *command.aliases):
             self._commands[key] = command
 
+    def _visible_commands(self, *, include_agent_only: bool) -> list[SlashCommand]:
+        """Return the list of commands that should be shown in global listings."""
+        commands = sorted(self._unique_commands.values(), key=lambda c: c.name)
+        if include_agent_only:
+            return commands
+        return [cmd for cmd in commands if not cmd.agent_only]
+
     def open_transcript_viewer(self, *, announce: bool = True) -> None:
         """Launch the transcript viewer for the most recent run."""
         payload, manifest = self._get_last_transcript()
@@ -557,6 +1308,14 @@ class SlashSession:
         )
 
         def _export(destination: Path) -> Path:
+            """Export cached transcript to destination.
+
+            Args:
+                destination: Path to export transcript to.
+
+            Returns:
+                Path to exported transcript file.
+            """
             return export_cached_transcript(destination=destination, run_id=run_id)
 
         try:
@@ -574,55 +1333,13 @@ class SlashSession:
         manifest = ctx_obj.get("_last_transcript_manifest")
         return payload, manifest
 
-    def _cmd_export(self, args: list[str], _invoked_from_agent: bool) -> bool:
+    def _cmd_export(self, _args: list[str], _invoked_from_agent: bool) -> bool:
         """Slash handler for `/export` command."""
-        path_arg = args[0] if args else None
-        run_id = args[1] if len(args) > 1 else None
-
-        manifest_entry = resolve_manifest_for_export(self.ctx, run_id)
-        if manifest_entry is None:
-            if run_id:
-                self.console.print(
-                    f"[{WARNING_STYLE}]No cached transcript found with run id {run_id!r}. "
-                    "Omit the run id to export the most recent run.[/]"
-                )
-            else:
-                self.console.print(f"[{WARNING_STYLE}]No cached transcripts available yet. Run an agent first.[/]")
-            return False
-
-        destination = self._resolve_export_destination(path_arg, manifest_entry)
-        if destination is None:
-            return False
-
-        try:
-            exported = export_cached_transcript(
-                destination=destination,
-                run_id=manifest_entry.get("run_id"),
-            )
-        except FileNotFoundError as exc:
-            self.console.print(f"[{ERROR_STYLE}]{exc}[/]")
-            return False
-        except Exception as exc:  # pragma: no cover - unexpected IO failures
-            self.console.print(f"[{ERROR_STYLE}]Failed to export transcript: {exc}[/]")
-            return False
-        else:
-            self.console.print(f"[{SUCCESS_STYLE}]Transcript exported to[/] {exported}")
-            return True
-
-    def _resolve_export_destination(self, path_arg: str | None, manifest_entry: dict[str, Any]) -> Path | None:
-        if path_arg:
-            return normalise_export_destination(Path(path_arg))
-
-        default_name = suggest_filename(manifest_entry)
-        prompt = f"Save transcript to [{default_name}]: "
-        try:
-            response = self.console.input(prompt)
-        except EOFError:
-            self.console.print("[dim]Export cancelled.[/dim]")
-            return None
-
-        chosen = response.strip() or default_name
-        return normalise_export_destination(Path(chosen))
+        self.console.print(
+            f"[{WARNING_STYLE}]`/export` is deprecated. Use `/transcripts`, select a run, "
+            "and open the transcript viewer to export.[/]"
+        )
+        return True
 
     def _cmd_update(self, args: list[str], _invoked_from_agent: bool) -> bool:
         """Slash handler for `/update` command."""
@@ -695,6 +1412,14 @@ class SlashSession:
                 pass
 
     def _parse(self, raw: str) -> tuple[str, list[str]]:
+        """Parse a raw command string into verb and arguments.
+
+        Args:
+            raw: Raw command string.
+
+        Returns:
+            Tuple of (verb, args).
+        """
         try:
             tokens = shlex.split(raw)
         except ValueError:
@@ -710,6 +1435,14 @@ class SlashSession:
         return head, tokens[1:]
 
     def _suggest(self, verb: str) -> str | None:
+        """Suggest a similar command name for an unknown verb.
+
+        Args:
+            verb: Unknown command verb.
+
+        Returns:
+            Suggested command name or None.
+        """
         keys = [cmd.name for cmd in self._unique_commands.values()]
         match = get_close_matches(verb, keys, n=1)
         return match[0] if match else None
@@ -738,6 +1471,7 @@ class SlashSession:
             if callable(message):
 
                 def prompt_text() -> Any:
+                    """Get formatted prompt text from callable message."""
                     return self._convert_message(message())
             else:
                 prompt_text = self._convert_message(message)
@@ -783,10 +1517,42 @@ class SlashSession:
         return self._prompt_with_basic_input(message, placeholder)
 
     def _get_client(self) -> Any:  # type: ignore[no-any-return]
+        """Get or create the API client instance.
+
+        Returns:
+            API client instance.
+        """
         if self._client is None:
             self._client = get_client(self.ctx)
         return self._client
 
+    def on_account_switched(self, _account_name: str | None = None) -> None:
+        """Reset any state that depends on the active account.
+
+        The active account can change via `/accounts` (or other flows that call
+        AccountStore.set_active_account). The slash session caches a configured
+        client instance, so we must invalidate it to avoid leaking the previous
+        account's API URL/key into subsequent commands like `/agents` or `/runs`.
+
+        This method clears:
+        - Client and config cache (account-specific credentials)
+        - Current agent and recent agents (agent data is account-scoped)
+        - Runs pagination state (runs are account-scoped)
+        - Active renderer and transcript ready state (UI state tied to account context)
+        - Contextual commands (may be account-specific)
+
+        These broader resets ensure a clean slate when switching accounts, preventing
+        stale data from the previous account from appearing in the new account's context.
+        """
+        self._client = None
+        self._config_cache = None
+        self._current_agent = None
+        self.recent_agents = []
+        self._runs_pagination_state.clear()
+        self.clear_active_renderer()
+        self.clear_agent_transcript_ready()
+        self.set_contextual_commands(None)
+
     def set_contextual_commands(self, commands: dict[str, str] | None, *, include_global: bool = True) -> None:
         """Set context-specific commands that should appear in completions."""
         self._contextual_commands = dict(commands or {})
@@ -801,6 +1567,11 @@ class SlashSession:
         return self._contextual_include_global
 
     def _remember_agent(self, agent: Any) -> None:  # type: ignore[no-any-return]
+        """Remember an agent in recent agents list.
+
+        Args:
+            agent: Agent object to remember.
+        """
         agent_data = {
             "id": str(getattr(agent, "id", "")),
             "name": getattr(agent, "name", "") or "",
@@ -817,14 +1588,24 @@ class SlashSession:
         *,
         focus_agent: bool = False,
         initial: bool = False,
+        show_branding: bool = True,
     ) -> None:
+        """Render the session header with branding and status.
+
+        Args:
+            active_agent: Optional active agent to display.
+            focus_agent: Whether to focus on agent display.
+            initial: Whether this is the initial render.
+            show_branding: Whether to render the branding banner.
+        """
         if focus_agent and active_agent is not None:
             self._render_focused_agent_header(active_agent)
             return
 
         full_header = initial or not self._welcome_rendered
-        if full_header:
+        if full_header and show_branding:
             self._render_branding_banner()
+        if full_header:
             self.console.rule(style=PRIMARY)
         self._render_main_header(active_agent, full=full_header)
         if full_header:
@@ -834,14 +1615,17 @@ class SlashSession:
     def _render_branding_banner(self) -> None:
         """Render the GL AIP branding banner."""
         banner = self._branding.get_welcome_banner()
-        heading = "[bold]>_ GDP Labs AI Agents Package (AIP CLI)[/bold]"
+        heading = self.CLI_HEADING_MARKUP
         self.console.print(heading)
         self.console.print()
         self.console.print(banner)
 
-    def _maybe_show_update_prompt(self) -> None:
+    def _maybe_show_update_prompt(self, *, defer: bool = False) -> None:
         """Display update prompt once per session when applicable."""
-        if self._update_prompt_shown:
+        if self._update_prompt_shown or (defer and not self._update_prompt_shown):
+            if defer:
+                # Just mark as ready to show, but don't show yet
+                return
             return
 
         self._update_notifier(
@@ -860,8 +1644,9 @@ class SlashSession:
 
         header_grid = self._build_header_grid(agent_info, transcript_status)
         keybar = self._build_keybar()
-
         header_grid.add_row(keybar, "")
+
+        # Agent-scoped commands like /runs will appear in /help, no need to duplicate here
         self.console.print(AIPPanel(header_grid, title="Agent Session", border_style=PRIMARY))
 
     def _get_agent_info(self, active_agent: Any) -> dict[str, str]:
@@ -903,14 +1688,16 @@ class SlashSession:
             f"[{ACCENT_STYLE}]{agent_info['id']}[/]"
         )
         status_line = f"[{SUCCESS_STYLE}]ready[/]"
-        status_line += " · transcript ready" if transcript_status["transcript_ready"] else " · transcript pending"
+        if not transcript_status["has_transcript"]:
+            status_line += " · no transcript"
+        elif transcript_status["transcript_ready"]:
+            status_line += " · transcript ready"
+        else:
+            status_line += " · transcript pending"
         header_grid.add_row(primary_line, status_line)
 
         if agent_info["description"]:
-            description = agent_info["description"]
-            if not transcript_status["transcript_ready"]:
-                description = f"{description}  (transcript pending)"
-            header_grid.add_row(f"[dim]{description}[/dim]", "")
+            header_grid.add_row(f"[dim]{agent_info['description']}[/dim]", "")
 
         return header_grid
 
@@ -919,10 +1706,11 @@ class SlashSession:
         keybar = AIPGrid(expand=True)
         keybar.add_column(justify="left", ratio=1)
         keybar.add_column(justify="left", ratio=1)
+        keybar.add_column(justify="left", ratio=1)
 
         keybar.add_row(
-            format_command_hint("/help", "Show commands") or "",
-            format_command_hint("/details", "Agent config") or "",
+            format_command_hint(HELP_COMMAND, "Show commands") or "",
+            format_command_hint("/details", "Agent config (expand prompt)") or "",
             format_command_hint("/exit", "Back") or "",
         )
 
@@ -932,13 +1720,26 @@ class SlashSession:
         """Render the main AIP environment header."""
         config = self._load_config()
 
+        account_name, account_host, env_lock = self._get_account_context()
         api_url = self._get_api_url(config)
-        status = "Configured" if config.get("api_key") else "Not configured"
 
-        segments = [
-            f"[dim]Base URL[/dim] • {api_url or 'Not configured'}",
-            f"[dim]Credentials[/dim] • {status}",
-        ]
+        host_display = account_host or "Not configured"
+        account_segment = f"[dim]Account[/dim] • {account_name} ({host_display})"
+        if env_lock:
+            account_segment += " 🔒"
+
+        segments = [account_segment]
+
+        if api_url:
+            base_label = "[dim]Base URL[/dim]"
+            if env_lock:
+                base_label = "[dim]Base URL (env)[/dim]"
+            # Always show Base URL when env-lock is active to reveal overrides
+            if env_lock or api_url != account_host:
+                segments.append(f"{base_label} • {api_url}")
+        elif not api_url:
+            segments.append("[dim]Base URL[/dim] • Not configured")
+
         agent_info = self._build_agent_status_line(active_agent)
         if agent_info:
             segments.append(agent_info)
@@ -961,12 +1762,23 @@ class SlashSession:
             )
         )
 
-    def _get_api_url(self, config: dict[str, Any]) -> str | None:
-        """Get the API URL from various sources."""
-        api_url = None
-        if isinstance(self.ctx.obj, dict):
-            api_url = self.ctx.obj.get("api_url")
-        return api_url or config.get("api_url") or os.getenv("AIP_API_URL")
+    def _get_api_url(self, _config: dict[str, Any] | None = None) -> str | None:
+        """Get the API URL from context or account store (CLI/palette ignores env credentials)."""
+        return resolve_api_url_from_context(self.ctx)
+
+    def _get_account_context(self) -> tuple[str, str, bool]:
+        """Return active account name, host, and env-lock flag."""
+        try:
+            store = get_account_store()
+            active = store.get_active_account() or "default"
+            account = store.get_account(active) if hasattr(store, "get_account") else None
+            host = ""
+            if account:
+                host = account.get("api_url", "")
+            env_lock = env_credentials_present()
+            return active, host, env_lock
+        except Exception:
+            return "default", "", env_credentials_present()
 
     def _build_agent_status_line(self, active_agent: Any | None) -> str | None:
         """Return a short status line about the active or recent agent."""
@@ -981,35 +1793,96 @@ class SlashSession:
         return None
 
     def _show_default_quick_actions(self) -> None:
-        hints: list[tuple[str | None, str]] = [
-            (
-                command_hint("status", slash_command="status", ctx=self.ctx),
-                "Connection check",
-            ),
-            (
-                command_hint("agents list", slash_command="agents", ctx=self.ctx),
-                "Browse agents",
-            ),
-            (
-                command_hint("help", slash_command="help", ctx=self.ctx),
-                "Show all commands",
-            ),
-        ]
-        filtered = [(cmd, desc) for cmd, desc in hints if cmd]
-        if filtered:
-            self._show_quick_actions(filtered, title="Quick actions")
+        """Show simplified help hint to discover commands."""
+        self.console.print(f"[dim]{'─' * 40}[/]")
+        help_hint = format_command_hint(HELP_COMMAND, "Show all commands") or HELP_COMMAND
+        self.console.print(f"• {help_hint}")
         self._default_actions_shown = True
 
+    def _collect_scoped_new_action_hints(self, scope: str) -> list[tuple[str, str]]:
+        """Return new quick action hints filtered by scope."""
+        scoped_actions = [action for action in NEW_QUICK_ACTIONS if _quick_action_scope(action) == scope]
+        # Don't highlight with sparkle emoji in quick actions display - it will show in command palette instead
+        return self._collect_quick_action_hints(scoped_actions)
+
+    def _collect_quick_action_hints(
+        self,
+        actions: Iterable[dict[str, Any]],
+    ) -> list[tuple[str, str]]:
+        """Collect quick action hints from action definitions.
+
+        Args:
+            actions: Iterable of action dictionaries.
+
+        Returns:
+            List of (command, description) tuples.
+        """
+        collected: list[tuple[str, str]] = []
+
+        def sort_key(payload: dict[str, Any]) -> tuple[int, str]:
+            priority = int(payload.get("priority", 0))
+            label = str(payload.get("slash") or payload.get("cli") or "")
+            return (-priority, label.lower())
+
+        for action in sorted(actions, key=sort_key):
+            hint = self._build_quick_action_hint(action)
+            if hint:
+                collected.append(hint)
+        return collected
+
+    def _build_quick_action_hint(
+        self,
+        action: dict[str, Any],
+    ) -> tuple[str, str] | None:
+        """Build a quick action hint from an action definition.
+
+        Args:
+            action: Action dictionary.
+
+        Returns:
+            Tuple of (command, description) or None.
+        """
+        command = command_hint(action.get("cli"), slash_command=action.get("slash"), ctx=self.ctx)
+        if not command:
+            return None
+        description = action.get("description", "")
+        # Don't include tag or sparkle emoji in quick actions display
+        # The NEW tag will only show in the command dropdown (help text)
+        return command, description
+
+    def _render_quick_action_group(self, hints: list[tuple[str, str]], title: str) -> None:
+        """Render a group of quick action hints.
+
+        Args:
+            hints: List of (command, description) tuples.
+            title: Group title.
+        """
+        for line in self._format_quick_action_lines(hints, title):
+            self.console.print(line)
+
+    def _chunk_tokens(self, tokens: list[str], *, size: int) -> Iterable[list[str]]:
+        """Chunk tokens into groups of specified size.
+
+        Args:
+            tokens: List of tokens to chunk.
+            size: Size of each chunk.
+
+        Yields:
+            Lists of tokens.
+        """
+        for index in range(0, len(tokens), size):
+            yield tokens[index : index + size]
+
     def _render_home_hint(self) -> None:
+        """Render hint text for home screen."""
         if self._home_hint_shown:
             return
-        hint_lines = [
-            f"[{HINT_PREFIX_STYLE}]Hint:[/]",
-            f"  Type {format_command_hint('/') or '/'} to explore commands",
-            "  Press [dim]Ctrl+C[/] to cancel the current entry",
-            "  Press [dim]Ctrl+D[/] to quit",
-        ]
-        self.console.print("\n".join(hint_lines))
+        hint_text = (
+            f"[{HINT_PREFIX_STYLE}]Hint:[/] "
+            f"Type {format_command_hint('/') or '/'} to explore commands · "
+            "Press [dim]Ctrl+D[/] to quit"
+        )
+        self.console.print(hint_text)
         self._home_hint_shown = True
 
     def _show_quick_actions(
@@ -1019,30 +1892,99 @@ class SlashSession:
         title: str = "Quick actions",
         inline: bool = False,
     ) -> None:
-        hint_list = [(command, description) for command, description in hints if command]
+        """Show quick action hints.
+
+        Args:
+            hints: Iterable of (command, description) tuples.
+            title: Title for the hints.
+            inline: Whether to render inline or in a panel.
+        """
+        hint_list = self._normalize_quick_action_hints(hints)
         if not hint_list:
             return
 
         if inline:
-            lines: list[str] = []
-            for command, description in hint_list:
-                formatted = format_command_hint(command, description)
-                if formatted:
-                    lines.append(formatted)
-            if lines:
-                self.console.print("\n".join(lines))
+            self._render_inline_quick_actions(hint_list, title)
             return
 
+        self._render_panel_quick_actions(hint_list, title)
+
+    def _normalize_quick_action_hints(self, hints: Iterable[tuple[str, str]]) -> list[tuple[str, str]]:
+        """Normalize quick action hints by filtering out empty commands.
+
+        Args:
+            hints: Iterable of (command, description) tuples.
+
+        Returns:
+            List of normalized hints.
+        """
+        return [(command, description) for command, description in hints if command]
+
+    def _render_inline_quick_actions(self, hint_list: list[tuple[str, str]], title: str) -> None:
+        """Render quick actions inline.
+
+        Args:
+            hint_list: List of (command, description) tuples.
+            title: Title for the hints.
+        """
+        tokens: list[str] = []
+        for command, description in hint_list:
+            formatted = format_command_hint(command, description)
+            if formatted:
+                tokens.append(formatted)
+        if not tokens:
+            return
+        prefix = f"[dim]{title}:[/]" if title else ""
+        body = "    ".join(tokens)
+        text = f"{prefix} {body}" if prefix else body
+        self.console.print(text.strip())
+
+    def _render_panel_quick_actions(self, hint_list: list[tuple[str, str]], title: str) -> None:
+        """Render quick actions in a panel.
+
+        Args:
+            hint_list: List of (command, description) tuples.
+            title: Panel title.
+        """
         body_lines: list[Text] = []
         for command, description in hint_list:
             formatted = format_command_hint(command, description)
             if formatted:
                 body_lines.append(Text.from_markup(formatted))
-
+        if not body_lines:
+            return
         panel_content = Group(*body_lines)
         self.console.print(AIPPanel(panel_content, title=title, border_style=SECONDARY_LIGHT, expand=False))
 
+    def _format_quick_action_lines(self, hints: list[tuple[str, str]], title: str) -> list[str]:
+        """Return formatted lines for quick action hints."""
+        if not hints:
+            return []
+        formatted_tokens: list[str] = []
+        for command, description in hints:
+            formatted = format_command_hint(command, description)
+            if formatted:
+                formatted_tokens.append(f"• {formatted}")
+        if not formatted_tokens:
+            return []
+        lines: list[str] = []
+        # Use vertical layout (1 per line) for better readability
+        chunks = list(self._chunk_tokens(formatted_tokens, size=1))
+        prefix = f"[dim]{title}[/dim]\n  " if title else ""
+        for idx, chunk in enumerate(chunks):
+            row = "    ".join(chunk)
+            if idx == 0:
+                lines.append(f"{prefix}{row}" if prefix else row)
+            else:
+                lines.append(f"  {row}")
+        return lines
+
     def _load_config(self) -> dict[str, Any]:
+        """Load configuration with caching.
+
+        Returns:
+            Configuration dictionary.
+        """
         if self._config_cache is None:
             try:
                 self._config_cache = load_config() or {}
@@ -1051,6 +1993,16 @@ class SlashSession:
         return self._config_cache
 
     def _resolve_agent_from_ref(self, client: Any, available_agents: list[Any], ref: str) -> Any | None:
+        """Resolve an agent from a reference string.
+
+        Args:
+            client: API client instance.
+            available_agents: List of available agents.
+            ref: Reference string (ID or name).
+
+        Returns:
+            Resolved agent or None.
+        """
         ref = ref.strip()
         if not ref:
             return None