glaip-sdk 0.0.19__py3-none-any.whl → 0.1.0__py3-none-any.whl

glaip_sdk/cli/slash/session.py

@@ -6,24 +6,37 @@ Authors:
 
 from __future__ import annotations
 
+import importlib
 import os
 import shlex
 import sys
 from collections.abc import Callable, Iterable
 from dataclasses import dataclass
+from difflib import get_close_matches
+from pathlib import Path
 from typing import Any
 
 import click
-from rich.console import Console
-from rich.table import Table
-
-from glaip_sdk.branding import AIPBranding
+from rich.console import Console, Group
+from rich.text import Text
+
+from glaip_sdk.branding import (
+    ACCENT_STYLE,
+    ERROR_STYLE,
+    HINT_COMMAND_STYLE,
+    HINT_DESCRIPTION_COLOR,
+    HINT_PREFIX_STYLE,
+    INFO_STYLE,
+    PRIMARY,
+    SECONDARY_LIGHT,
+    SUCCESS_STYLE,
+    WARNING_STYLE,
+    AIPBranding,
+)
 from glaip_sdk.cli.commands.configure import configure_command, load_config
-from glaip_sdk.cli.utils import _fuzzy_pick_for_resources, command_hint, get_client
-from glaip_sdk.rich_components import AIPPanel
-
-from .agent_session import AgentRunSession
-from .prompt import (
+from glaip_sdk.cli.commands.update import update_command
+from glaip_sdk.cli.slash.agent_session import AgentRunSession
+from glaip_sdk.cli.slash.prompt import (
     FormattedText,
     PromptSession,
     Style,
@@ -31,6 +44,21 @@ from .prompt import (
     setup_prompt_toolkit,
     to_formatted_text,
 )
+from glaip_sdk.cli.transcript import (
+    export_cached_transcript,
+    normalise_export_destination,
+    resolve_manifest_for_export,
+    suggest_filename,
+)
+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]
 
@@ -68,8 +96,8 @@ class SlashSession:
         self._interactive = bool(sys.stdin.isatty() and sys.stdout.isatty())
         self._config_cache: dict[str, Any] | None = None
         self._welcome_rendered = False
-        self._verbose_enabled = False
         self._active_renderer: Any | None = None
+        self._current_agent: Any | None = None
 
         self._home_placeholder = "Start with / to browse commands"
 
@@ -84,6 +112,10 @@ class SlashSession:
         self._branding = AIPBranding.create_from_sdk()
         self._suppress_login_layout = False
         self._default_actions_shown = False
+        self._update_prompt_shown = False
+        self._update_notifier = maybe_notify_update
+        self._home_hint_shown = False
+        self._agent_transcript_ready: dict[str, str] = {}
 
     # ------------------------------------------------------------------
     # Session orchestration
@@ -96,18 +128,31 @@ class SlashSession:
 
     def run(self, initial_commands: Iterable[str] | None = None) -> None:
         """Start the command palette session loop."""
-        if not self._interactive:
-            self._run_non_interactive(initial_commands)
-            return
+        ctx_obj = self.ctx.obj if isinstance(self.ctx.obj, dict) else None
+        previous_session = None
+        if ctx_obj is not None:
+            previous_session = ctx_obj.get("_slash_session")
+            ctx_obj["_slash_session"] = self
 
-        if not self._ensure_configuration():
-            return
+        try:
+            if not self._interactive:
+                self._run_non_interactive(initial_commands)
+                return
+
+            if not self._ensure_configuration():
+                return
 
-        self._render_header(initial=not self._welcome_rendered)
-        if not self._default_actions_shown:
-            self._show_default_quick_actions()
-        self._render_home_hint()
-        self._run_interactive_loop()
+            self._maybe_show_update_prompt()
+            self._render_header(initial=not self._welcome_rendered)
+            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)
+                else:
+                    ctx_obj["_slash_session"] = previous_session
 
     def _run_interactive_loop(self) -> None:
         """Run the main interactive command loop."""
@@ -131,12 +176,13 @@ class SlashSession:
             return True
 
         if raw == "/":
+            self._render_home_hint()
             self._cmd_help([], invoked_from_agent=False)
             return True
 
         if not raw.startswith("/"):
             self.console.print(
-                "[yellow]Hint:[/] start commands with `/`. Try `/agents` to select an agent."
+                f"[{INFO_STYLE}]Hint:[/] start commands with `/`. Try `/agents` to select an agent."
             )
             return True
 
@@ -160,14 +206,14 @@ class SlashSession:
         """Ensure the CLI has both API URL and credentials before continuing."""
         while not self._configuration_ready():
             self.console.print(
-                "[yellow]Configuration required.[/] Launching `/login` wizard..."
+                f"[{WARNING_STYLE}]Configuration required.[/] Launching `/login` wizard..."
             )
             self._suppress_login_layout = True
             try:
                 self._cmd_login([], False)
             except KeyboardInterrupt:
                 self.console.print(
-                    "[red]Configuration aborted. Closing the command palette.[/red]"
+                    f"[{ERROR_STYLE}]Configuration aborted. Closing the command palette.[/]"
                 )
                 return False
             finally:
@@ -193,7 +239,7 @@ class SlashSession:
         """Parse and execute a single slash command string."""
         verb, args = self._parse(raw)
         if not verb:
-            self.console.print("[red]Unrecognised command[/red]")
+            self.console.print(f"[{ERROR_STYLE}]Unrecognised command[/]")
             return True
 
         command = self._commands.get(verb)
@@ -201,11 +247,13 @@ class SlashSession:
             suggestion = self._suggest(verb)
             if suggestion:
                 self.console.print(
-                    f"[yellow]Unknown command '{verb}'. Did you mean '/{suggestion}'?[/yellow]"
+                    f"[{WARNING_STYLE}]Unknown command '{verb}'. Did you mean '/{suggestion}'?[/]"
                 )
             else:
+                help_command = "/help"
+                help_hint = format_command_hint(help_command) or help_command
                 self.console.print(
-                    "[yellow]Unknown command '{verb}'. Type `/help` for a list of options.[/yellow]"
+                    f"[{WARNING_STYLE}]Unknown command '{verb}'. Type {help_hint} for a list of options.[/]"
                 )
             return True
 
@@ -225,32 +273,45 @@ class SlashSession:
             else:
                 self._render_global_help()
         except Exception as exc:  # pragma: no cover - UI/display errors
-            self.console.print(f"[red]Error displaying help: {exc}[/red]")
+            self.console.print(f"[{ERROR_STYLE}]Error displaying help: {exc}[/]")
             return False
 
         return True
 
     def _render_agent_help(self) -> None:
-        table = Table(title="Agent Context")
-        table.add_column("Input", style="cyan", no_wrap=True)
-        table.add_column("What happens", style="green")
+        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(self.STATUS_COMMAND, "Display connection status without leaving.")
-        table.add_row("/verbose", "Toggle verbose streaming output (Ctrl+T works too).")
+        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.")
-        self.console.print(table)
+
+        panel_items = [table]
         if self.last_run_input:
-            self.console.print(f"[dim]Last run input:[/] {self.last_run_input}")
+            panel_items.append(
+                Text.from_markup(f"[dim]Last run input:[/] {self.last_run_input}")
+            )
+        panel_items.append(
+            Text.from_markup(
+                "[dim]Global commands (e.g. `/login`, `/status`) remain available inside the agent prompt.[/dim]"
+            )
+        )
+
         self.console.print(
-            "[dim]Global commands (e.g. `/login`, `/status`) remain available inside the agent prompt.[/dim]"
+            AIPPanel(
+                Group(*panel_items),
+                title="Agent Context",
+                border_style=PRIMARY,
+            )
         )
 
     def _render_global_help(self) -> None:
-        table = Table(title="Slash Commands")
-        table.add_column("Command", style="cyan", no_wrap=True)
-        table.add_column("Description", style="green")
+        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):
             aliases = ", ".join(f"/{alias}" for alias in cmd.aliases if alias)
@@ -259,13 +320,20 @@ class SlashSession:
                 verb = f"{verb} ({aliases})"
             table.add_row(verb, cmd.help)
 
-        self.console.print(table)
+        tip = Text.from_markup(
+            f"[{HINT_PREFIX_STYLE}]Tip:[/] {format_command_hint(self.AGENTS_COMMAND) or self.AGENTS_COMMAND} lets you jump into an agent run prompt quickly."
+        )
+
         self.console.print(
-            "[dim]Tip: `{self.AGENTS_COMMAND}` lets you jump into an agent run prompt quickly.[/dim]"
+            AIPPanel(
+                Group(table, tip),
+                title="Slash Commands",
+                border_style=PRIMARY,
+            )
         )
 
     def _cmd_login(self, _args: list[str], _invoked_from_agent: bool) -> bool:
-        self.console.print("[cyan]Launching configuration wizard...[/cyan]")
+        self.console.print(f"[{ACCENT_STYLE}]Launching configuration wizard...[/]")
         try:
             self.ctx.invoke(configure_command)
             self._config_cache = None
@@ -276,14 +344,22 @@ class SlashSession:
                 self._render_header(initial=True)
                 self._show_default_quick_actions()
         except click.ClickException as exc:
-            self.console.print(f"[red]{exc}[/red]")
+            self.console.print(f"[{ERROR_STYLE}]{exc}[/]")
         return True
 
     def _cmd_status(self, _args: list[str], _invoked_from_agent: bool) -> bool:
+        ctx_obj = self.ctx.obj if isinstance(self.ctx.obj, dict) else None
+        previous_console = None
         try:
-            from glaip_sdk.cli.main import status as status_command
+            status_module = importlib.import_module("glaip_sdk.cli.main")
+            status_command = getattr(status_module, "status")
+
+            if ctx_obj is not None:
+                previous_console = ctx_obj.get("_slash_console")
+                ctx_obj["_slash_console"] = self.console
 
             self.ctx.invoke(status_command)
+
             hints: list[tuple[str, str]] = [
                 (self.AGENTS_COMMAND, "Browse agents and run them")
             ]
@@ -293,7 +369,13 @@ class SlashSession:
                 hints.append((f"/agents {top.get('id')}", f"Reopen {label}"))
             self._show_quick_actions(hints, title="Next actions")
         except click.ClickException as exc:
-            self.console.print(f"[red]{exc}[/red]")
+            self.console.print(f"[{ERROR_STYLE}]{exc}[/]")
+        finally:
+            if ctx_obj is not None:
+                if previous_console is None:
+                    ctx_obj.pop("_slash_console", None)
+                else:
+                    ctx_obj["_slash_console"] = previous_console
         return True
 
     def _cmd_agents(self, args: list[str], _invoked_from_agent: bool) -> bool:
@@ -317,7 +399,7 @@ class SlashSession:
         try:
             return self._get_client()
         except click.ClickException as exc:
-            self.console.print(f"[red]{exc}[/red]")
+            self.console.print(f"[{ERROR_STYLE}]{exc}[/]")
             return None
 
     def _get_agents_or_fail(self, client: Any) -> list:
@@ -328,7 +410,7 @@ class SlashSession:
                 self._handle_no_agents()
             return agents
         except Exception as exc:  # pragma: no cover - API failures
-            self.console.print(f"[red]Failed to load agents: {exc}[/red]")
+            self.console.print(f"[{ERROR_STYLE}]Failed to load agents: {exc}[/]")
             return []
 
     def _handle_no_agents(self) -> None:
@@ -336,10 +418,10 @@ class SlashSession:
         hint = command_hint("agents create", slash_command=None, ctx=self.ctx)
         if hint:
             self.console.print(
-                f"[yellow]No agents available. Use `{hint}` to add one.[/yellow]"
+                f"[{WARNING_STYLE}]No agents available. Use `{hint}` to add one.[/]"
             )
         else:
-            self.console.print("[yellow]No agents available.[/yellow]")
+            self.console.print(f"[{WARNING_STYLE}]No agents available.[/]")
 
     def _resolve_or_pick_agent(self, client: Any, agents: list, args: list[str]) -> Any:
         """Resolve agent from args or pick interactively."""
@@ -347,7 +429,7 @@ class SlashSession:
             picked_agent = self._resolve_agent_from_ref(client, agents, args[0])
             if picked_agent is None:
                 self.console.print(
-                    f"[yellow]Could not resolve agent '{args[0]}'. Try `/agents` to browse interactively.[/yellow]"
+                    f"[{WARNING_STYLE}]Could not resolve agent '{args[0]}'. Try `/agents` to browse interactively.[/]"
                 )
                 return None
         else:
@@ -390,7 +472,7 @@ class SlashSession:
             # running.
             return True
 
-        self.console.print("[cyan]Closing the command palette.[/cyan]")
+        self.console.print(f"[{ACCENT_STYLE}]Closing the command palette.[/]")
         return False
 
     # ------------------------------------------------------------------
@@ -437,9 +519,16 @@ class SlashSession:
         )
         self._register(
             SlashCommand(
-                name="verbose",
-                help="Toggle verbose streaming output.",
-                handler=SlashSession._cmd_verbose,
+                name="export",
+                help="Export the most recent agent transcript.",
+                handler=SlashSession._cmd_export,
+            )
+        )
+        self._register(
+            SlashCommand(
+                name="update",
+                help="Upgrade the glaip-sdk package to the latest version.",
+                handler=SlashSession._cmd_update,
             )
         )
 
@@ -448,53 +537,121 @@ class SlashSession:
         for key in (command.name, *command.aliases):
             self._commands[key] = command
 
-    # ------------------------------------------------------------------
-    # Verbose mode helpers
-    # ------------------------------------------------------------------
-    @property
-    def verbose_enabled(self) -> bool:
-        """Return whether verbose agent runs are enabled."""
-        return self._verbose_enabled
-
-    def set_verbose(self, enabled: bool, *, announce: bool = True) -> None:
-        """Enable or disable verbose mode with optional announcement."""
-        if self._verbose_enabled == enabled:
+    def open_transcript_viewer(self, *, announce: bool = True) -> None:
+        """Launch the transcript viewer for the most recent run."""
+        payload, manifest = self._get_last_transcript()
+        if payload is None or manifest is None:
             if announce:
-                self._print_verbose_status(context="already")
+                self.console.print(
+                    f"[{WARNING_STYLE}]No transcript is available yet. Run an agent first.[/]"
+                )
             return
 
-        self._verbose_enabled = enabled
-        self._sync_active_renderer()
-        if announce:
-            self._print_verbose_status(context="changed")
+        run_id = manifest.get("run_id")
+        if not run_id:
+            if announce:
+                self.console.print(
+                    f"[{WARNING_STYLE}]Latest transcript is missing run metadata.[/]"
+                )
+            return
 
-    def toggle_verbose(self, *, announce: bool = True) -> None:
-        """Flip verbose mode state."""
-        self.set_verbose(not self._verbose_enabled, announce=announce)
+        viewer_ctx = ViewerContext(
+            manifest_entry=manifest,
+            events=list(getattr(payload, "events", []) or []),
+            default_output=getattr(payload, "default_output", ""),
+            final_output=getattr(payload, "final_output", ""),
+            stream_started_at=getattr(payload, "started_at", None),
+            meta=getattr(payload, "meta", {}) or {},
+        )
 
-    def _cmd_verbose(self, args: list[str], _invoked_from_agent: bool) -> bool:
-        """Slash handler for `/verbose` command."""
-        if args:
-            self.console.print(
-                "Usage: `/verbose` toggles verbose streaming output. Press Ctrl+T as a shortcut."
+        def _export(destination: Path) -> Path:
+            return export_cached_transcript(destination=destination, run_id=run_id)
+
+        try:
+            run_viewer_session(self.console, viewer_ctx, _export)
+        except Exception as exc:  # pragma: no cover - interactive failures
+            if announce:
+                self.console.print(
+                    f"[{ERROR_STYLE}]Failed to launch transcript viewer: {exc}[/]"
+                )
+
+    def _get_last_transcript(self) -> tuple[Any | None, dict[str, Any] | None]:
+        """Fetch the most recently stored transcript payload and manifest."""
+        ctx_obj = getattr(self.ctx, "obj", None)
+        if not isinstance(ctx_obj, dict):
+            return None, None
+        payload = ctx_obj.get("_last_transcript_payload")
+        manifest = ctx_obj.get("_last_transcript_manifest")
+        return payload, manifest
+
+    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.toggle_verbose()
+            self.console.print(f"[{SUCCESS_STYLE}]Transcript exported to[/] {exported}")
+            return True
 
-        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
 
-    def _print_verbose_status(self, *, context: str) -> None:
-        state_word = "on" if self._verbose_enabled else "off"
-        if context == "already":
+        chosen = response.strip() or default_name
+        return normalise_export_destination(Path(chosen))
+
+    def _cmd_update(self, args: list[str], _invoked_from_agent: bool) -> bool:
+        """Slash handler for `/update` command."""
+        if args:
             self.console.print(
-                f"Verbose mode already {state_word}. Use Ctrl+T or `/verbose` to toggle."
+                "Usage: `/update` upgrades glaip-sdk to the latest published version."
             )
-            return
+            return True
 
-        change_word = "enabled" if self._verbose_enabled else "disabled"
-        self.console.print(
-            f"Verbose mode {change_word}. Use Ctrl+T or `/verbose` to toggle."
-        )
+        try:
+            self.ctx.invoke(update_command)
+            return True
+        except click.ClickException as exc:
+            self.console.print(f"[{ERROR_STYLE}]{exc}[/]")
+            # Return False for update command failures to indicate the command didn't complete successfully
+            return False
 
     # ------------------------------------------------------------------
     # Agent run coordination helpers
@@ -510,6 +667,19 @@ class SlashSession:
             return
         self._active_renderer = None
 
+    def mark_agent_transcript_ready(self, agent_id: str, run_id: str | None) -> None:
+        """Record that an agent has a transcript ready for the current session."""
+        if not agent_id or not run_id:
+            return
+        self._agent_transcript_ready[agent_id] = run_id
+
+    def clear_agent_transcript_ready(self, agent_id: str | None = None) -> None:
+        """Reset transcript-ready state for an agent or for all agents."""
+        if agent_id:
+            self._agent_transcript_ready.pop(agent_id, None)
+            return
+        self._agent_transcript_ready.clear()
+
     def notify_agent_run_started(self) -> None:
         """Mark that an agent run is in progress."""
         self.clear_active_renderer()
@@ -519,7 +689,7 @@ class SlashSession:
         self.clear_active_renderer()
 
     def _sync_active_renderer(self) -> None:
-        """Ensure the active renderer reflects the current verbose state."""
+        """Ensure the active renderer stays in standard (non-verbose) mode."""
         renderer = self._active_renderer
         if renderer is None:
             return
@@ -528,14 +698,14 @@ class SlashSession:
         apply_verbose = getattr(renderer, "apply_verbosity", None)
         if callable(apply_verbose):
             try:
-                apply_verbose(self._verbose_enabled)
+                apply_verbose(False)
                 applied = True
             except Exception:
                 pass
 
         if not applied and hasattr(renderer, "verbose"):
             try:
-                renderer.verbose = self._verbose_enabled
+                renderer.verbose = False
             except Exception:
                 pass
 
@@ -555,8 +725,6 @@ class SlashSession:
         return head, tokens[1:]
 
     def _suggest(self, verb: str) -> str | None:
-        from difflib import get_close_matches
-
         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
@@ -684,50 +852,121 @@ class SlashSession:
             return
 
         full_header = initial or not self._welcome_rendered
+        if full_header:
+            self._render_branding_banner()
+            self.console.rule(style=PRIMARY)
         self._render_main_header(active_agent, full=full_header)
         if full_header:
             self._welcome_rendered = True
+            self.console.print()
+
+    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]"
+        self.console.print(heading)
+        self.console.print()
+        self.console.print(banner)
+
+    def _maybe_show_update_prompt(self) -> None:
+        """Display update prompt once per session when applicable."""
+        if self._update_prompt_shown:
+            return
+
+        self._update_notifier(
+            self._branding.version,
+            console=self.console,
+            ctx=self.ctx,
+            slash_command="update",
+            style="panel",
+        )
+        self._update_prompt_shown = True
 
     def _render_focused_agent_header(self, active_agent: Any) -> None:
         """Render header when focusing on a specific agent."""
+        agent_info = self._get_agent_info(active_agent)
+        transcript_status = self._get_transcript_status(active_agent)
+
+        header_grid = self._build_header_grid(agent_info, transcript_status)
+        keybar = self._build_keybar()
+
+        header_grid.add_row(keybar, "")
+        self.console.print(
+            AIPPanel(header_grid, title="Agent Session", border_style=PRIMARY)
+        )
+
+    def _get_agent_info(self, active_agent: Any) -> dict[str, str]:
+        """Extract agent information for display."""
         agent_id = str(getattr(active_agent, "id", ""))
-        agent_name = getattr(active_agent, "name", "") or agent_id
-        agent_type = getattr(active_agent, "type", "") or "-"
-        description = getattr(active_agent, "description", "") or ""
+        return {
+            "id": agent_id,
+            "name": getattr(active_agent, "name", "") or agent_id,
+            "type": getattr(active_agent, "type", "") or "-",
+            "description": getattr(active_agent, "description", "") or "",
+        }
 
-        verbose_label = "verbose on" if self._verbose_enabled else "verbose off"
+    def _get_transcript_status(self, active_agent: Any) -> dict[str, Any]:
+        """Get transcript status for the active agent."""
+        agent_id = str(getattr(active_agent, "id", ""))
+        payload, manifest = self._get_last_transcript()
+
+        latest_agent_id = (manifest or {}).get("agent_id")
+        has_transcript = bool(payload and manifest and manifest.get("run_id"))
+        run_id = (manifest or {}).get("run_id")
+        transcript_ready = (
+            has_transcript
+            and latest_agent_id == agent_id
+            and self._agent_transcript_ready.get(agent_id) == run_id
+        )
+
+        return {
+            "has_transcript": has_transcript,
+            "transcript_ready": transcript_ready,
+            "run_id": run_id,
+        }
 
-        header_grid = Table.grid(expand=True)
+    def _build_header_grid(
+        self, agent_info: dict[str, str], transcript_status: dict[str, Any]
+    ) -> AIPGrid:
+        """Build the main header grid with agent information."""
+        header_grid = AIPGrid(expand=True)
         header_grid.add_column(ratio=3)
         header_grid.add_column(ratio=1, justify="right")
 
-        primary_line = f"[bold]{agent_name}[/bold] · [dim]{agent_type}[/dim] · [cyan]{agent_id}[/cyan]"
-        header_grid.add_row(
-            primary_line,
-            f"[green]ready[/green] · {verbose_label}",
+        primary_line = (
+            f"[bold]{agent_info['name']}[/bold] · [dim]{agent_info['type']}[/dim] · "
+            f"[{ACCENT_STYLE}]{agent_info['id']}[/]"
         )
+        status_line = f"[{SUCCESS_STYLE}]ready[/]"
+        status_line += (
+            " · transcript ready"
+            if transcript_status["transcript_ready"]
+            else " · transcript pending"
+        )
+        header_grid.add_row(primary_line, status_line)
 
-        if description:
+        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]", "")
 
-        keybar = Table.grid(expand=True)
-        keybar.add_column(justify="left")
-        keybar.add_column(justify="left")
-        keybar.add_column(justify="left")
-        keybar.add_column(justify="left")
-        keybar.add_row(
-            "[bold]/help[/bold] [dim]Show commands[/dim]",
-            "[bold]/details[/bold] [dim]Agent config[/dim]",
-            "[bold]/exit[/bold] [dim]Back[/dim]",
-            "[bold]Ctrl+T[/bold] [dim]Toggle verbose[/dim]",
-        )
+        return header_grid
 
-        header_grid.add_row(keybar, "")
+    def _build_keybar(self) -> AIPGrid:
+        """Build the keybar with command hints."""
+        keybar = AIPGrid(expand=True)
+        keybar.add_column(justify="left", ratio=1)
+        keybar.add_column(justify="left", ratio=1)
 
-        self.console.print(
-            AIPPanel(header_grid, title="Agent Session", border_style="blue")
+        keybar.add_row(
+            format_command_hint("/help", "Show commands") or "",
+            format_command_hint("/details", "Agent config") or "",
+            format_command_hint("/exit", "Back") or "",
         )
 
+        return keybar
+
     def _render_main_header(
         self, active_agent: Any | None = None, *, full: bool = False
     ) -> None:
@@ -737,49 +976,31 @@ class SlashSession:
         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}",
+        ]
+        agent_info = self._build_agent_status_line(active_agent)
+        if agent_info:
+            segments.append(agent_info)
+
+        rendered_line = "    ".join(segments)
+
         if full:
-            lines = [
-                f"GL AIP v{self._branding.version} · GDP Labs AI Agents Package",
-                f"API: {api_url or 'Not configured'} · Credentials: {status}",
-                (
-                    f"Verbose: {'on' if self._verbose_enabled else 'off'} "
-                    "(Ctrl+T toggles verbose streaming)"
-                ),
-            ]
-            extra: list[str] = []
-            self._add_agent_info_to_header(extra, active_agent)
-            lines.extend(extra)
-            self.console.print(
-                AIPPanel("\n".join(lines), title="GL AIP Session", border_style="cyan")
-            )
+            self.console.print(rendered_line)
             return
 
-        status_bar = Table.grid(expand=True)
-        status_bar.add_column(ratio=2)
-        status_bar.add_column(ratio=2)
-        status_bar.add_column(ratio=1, justify="right")
-        status_bar.add_row(
-            "[bold cyan]AIP Palette[/bold cyan]",
-            f"[dim]API[/dim]: {api_url or 'Not configured'}",
-            f"[dim]Verbose[/dim]: {'on' if self._verbose_enabled else 'off'}",
-        )
-        status_bar.add_row("[dim]Ctrl+T toggles verbose[/dim]", "", "")
-        status_bar.add_row("[dim]Type /help for shortcuts[/dim]", "", "")
-
-        if active_agent is not None:
-            agent_id = str(getattr(active_agent, "id", ""))
-            agent_name = getattr(active_agent, "name", "") or agent_id
-            status_bar.add_row(f"[dim]Active[/dim]: {agent_name} [{agent_id}]", "", "")
-        elif self.recent_agents:
-            recent = self.recent_agents[0]
-            label = recent.get("name") or recent.get("id") or "-"
-            status_bar.add_row(
-                f"[dim]Recent[/dim]: {label} [{recent.get('id', '-')}]",
-                "",
-                "",
+        status_bar = AIPGrid(expand=True)
+        status_bar.add_column(ratio=1)
+        status_bar.add_row(rendered_line)
+        self.console.print(
+            AIPPanel(
+                status_bar,
+                border_style=PRIMARY,
+                padding=(0, 1),
+                expand=False,
             )
-
-        self.console.print(AIPPanel(status_bar, border_style="cyan"))
+        )
 
     def _get_api_url(self, config: dict[str, Any]) -> str | None:
         """Get the API URL from various sources."""
@@ -788,58 +1009,85 @@ class SlashSession:
             api_url = self.ctx.obj.get("api_url")
         return api_url or config.get("api_url") or os.getenv("AIP_API_URL")
 
-    def _add_agent_info_to_header(
-        self, lines: list[str], active_agent: Any | None
-    ) -> None:
-        """Add agent information to header lines."""
+    def _build_agent_status_line(self, active_agent: Any | None) -> str | None:
+        """Return a short status line about the active or recent agent."""
         if active_agent is not None:
             agent_id = str(getattr(active_agent, "id", ""))
             agent_name = getattr(active_agent, "name", "") or agent_id
-            lines.append(f"[dim]Active agent[/dim]: {agent_name} [{agent_id}]")
-        elif self.recent_agents:
+            return f"[dim]Active[/dim]: {agent_name} ({agent_id})"
+        if self.recent_agents:
             recent = self.recent_agents[0]
             label = recent.get("name") or recent.get("id") or "-"
-            lines.append(f"[dim]Recent agent[/dim]: {label} [{recent.get('id', '-')}]")
+            return f"[dim]Recent[/dim]: {label} ({recent.get('id', '-')})"
+        return None
 
     def _show_default_quick_actions(self) -> None:
-        self._show_quick_actions(
-            [
-                (self.STATUS_COMMAND, "Verify the connection"),
-                (self.AGENTS_COMMAND, "Pick an agent to inspect or run"),
-            ]
-        )
+        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")
         self._default_actions_shown = True
 
     def _render_home_hint(self) -> None:
-        self.console.print(
-            AIPPanel(
-                "Type `/help` for command palette commands, `/agents` to browse agents, or `/exit` (`/q`) to leave the palette.\n"
-                "Press Ctrl+T to toggle verbose output.\n"
-                "Press Ctrl+C to cancel the current entry, Ctrl+D to quit immediately.",
-                title="✨ Getting Started",
-                border_style="cyan",
-            )
-        )
+        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))
+        self._home_hint_shown = True
 
     def _show_quick_actions(
-        self, hints: Iterable[tuple[str, str]], *, title: str = "Quick actions"
+        self,
+        hints: Iterable[tuple[str, str]],
+        *,
+        title: str = "Quick actions",
+        inline: bool = False,
     ) -> None:
-        hint_list = list(hints)
+        hint_list = [
+            (command, description) for command, description in hints if command
+        ]
         if not hint_list:
             return
 
-        grid = Table.grid(expand=True)
-        for _ in hint_list:
-            grid.add_column(ratio=1, no_wrap=False)
+        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))
+            return
 
-        grid.add_row(
-            *[
-                f"[bold]{command}[/bold]\n[dim]{description}[/dim]"
-                for command, description in hint_list
-            ]
-        )
+        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))
 
-        self.console.print(AIPPanel(grid, title=title, border_style="magenta"))
+        panel_content = Group(*body_lines)
+        self.console.print(
+            AIPPanel(
+                panel_content, title=title, border_style=SECONDARY_LIGHT, expand=False
+            )
+        )
 
     def _load_config(self) -> dict[str, Any]:
         if self._config_cache is None: