From a2d3cb7726bb1e861cbef56c6a18b72a9f49c06d Mon Sep 17 00:00:00 2001
From: fanqiNO1 <1848839264@qq.com>
Date: Thu, 6 Aug 2026 20:50:23 +0800
Subject: [PATCH 1/4] fix leapd launch on windows

---
 src/leapflow/daemon/_transport.py      | 10 ++++++++++
 src/leapflow/daemon/lifecycle.py       | 11 ++++++-----
 src/leapflow/storage/duckdb_connect.py | 13 ++++++++++++-
 tests/test_daemon_rpc.py               | 16 ++++++++++------
 tests/test_process_group.py            |  1 +
 5 files changed, 39 insertions(+), 12 deletions(-)

diff --git a/src/leapflow/daemon/_transport.py b/src/leapflow/daemon/_transport.py
index c4aa7dd..3dca2bd 100644
--- a/src/leapflow/daemon/_transport.py
+++ b/src/leapflow/daemon/_transport.py
@@ -33,6 +33,10 @@ async def connect(self, runtime_dir: Path) -> Tuple[asyncio.StreamReader, asynci
     def probe_healthy(self, runtime_dir: Path) -> bool:
         """Synchronous quick health check — returns True if the daemon is reachable."""
 
+    @abc.abstractmethod
+    def readiness_path(self, runtime_dir: Path) -> Path:
+        """Artifact file the daemon publishes when it is ready to serve."""
+
     @abc.abstractmethod
     def cleanup(self, runtime_dir: Path) -> None:
         """Remove transport artifacts (socket file, port file, etc.)."""
@@ -70,6 +74,9 @@ def probe_healthy(self, runtime_dir: Path) -> bool:
         except (OSError, socket.timeout):
             return False
 
+    def readiness_path(self, runtime_dir: Path) -> Path:
+        return self._sock_path(runtime_dir)
+
     def cleanup(self, runtime_dir: Path) -> None:
         self._sock_path(runtime_dir).unlink(missing_ok=True)
 
@@ -119,6 +126,9 @@ def probe_healthy(self, runtime_dir: Path) -> bool:
         except (OSError, socket.timeout):
             return False
 
+    def readiness_path(self, runtime_dir: Path) -> Path:
+        return self._port_path(runtime_dir)
+
     def cleanup(self, runtime_dir: Path) -> None:
         self._port_path(runtime_dir).unlink(missing_ok=True)
 
diff --git a/src/leapflow/daemon/lifecycle.py b/src/leapflow/daemon/lifecycle.py
index ca3d04d..f94794f 100644
--- a/src/leapflow/daemon/lifecycle.py
+++ b/src/leapflow/daemon/lifecycle.py
@@ -48,12 +48,14 @@ class DaemonInfo:
     def discover(cls, runtime_dir: Path) -> DaemonInfo:
         """Probe the runtime directory to determine daemon state."""
         pid = _read_pid(runtime_dir / "leapd.pid")
-        sock_path = runtime_dir / "leapd.sock"
+        from leapflow.daemon._transport import get_transport
+
+        sock_path = get_transport().readiness_path(runtime_dir)
         meta = _read_meta(runtime_dir / "leapd.json")
         start_time = meta.get("start_time") if meta else None
 
         is_running = pid is not None and _process_alive(pid)
-        is_healthy = is_running and sock_path.exists() and _sock_healthy(sock_path)
+        is_healthy = is_running and _sock_healthy(runtime_dir)
 
         return cls(
             pid=pid,
@@ -439,12 +441,11 @@ def _process_alive(pid: int) -> bool:
             kernel32.CloseHandle(handle)
 
 
-def _sock_healthy(sock_path: Path) -> bool:
+def _sock_healthy(runtime_dir: Path) -> bool:
     """Quick health check by connecting to the daemon transport."""
     from leapflow.daemon._transport import get_transport
 
-    transport = get_transport()
-    return transport.probe_healthy(sock_path.parent)
+    return get_transport().probe_healthy(runtime_dir)
 
 
 def _format_duration(seconds: Optional[float]) -> str:
diff --git a/src/leapflow/storage/duckdb_connect.py b/src/leapflow/storage/duckdb_connect.py
index 3d34a46..c61cd57 100644
--- a/src/leapflow/storage/duckdb_connect.py
+++ b/src/leapflow/storage/duckdb_connect.py
@@ -24,7 +24,18 @@
 
 logger = logging.getLogger(__name__)
 
-LOCK_KEYWORDS = frozenset({"lock", "locked", "exclusive", "cannot set lock"})
+LOCK_KEYWORDS = frozenset({
+    "lock",
+    "locked",
+    "exclusive",
+    "cannot set lock",
+    # Windows "file held by another process" forms — DuckDB raises these
+    # instead of a lock error when the DB file is open elsewhere (English
+    # and Chinese system locales). Must classify as locked, not corrupted.
+    "cannot open file",
+    "being used by another process",
+    "另一个程序正在使用",
+})
 
 _CONNECT_RETRIES = int(os.getenv("LEAPFLOW_DB_CONNECT_RETRIES", "5" if sys.platform == "win32" else "3"))
 _CONNECT_BACKOFF_S = float(os.getenv("LEAPFLOW_DB_CONNECT_BACKOFF_S", "1.0" if sys.platform == "win32" else "0.5"))
diff --git a/tests/test_daemon_rpc.py b/tests/test_daemon_rpc.py
index 2e4cda6..67793bd 100644
--- a/tests/test_daemon_rpc.py
+++ b/tests/test_daemon_rpc.py
@@ -11,6 +11,8 @@
 
 import pytest
 
+import leapflow
+from leapflow.daemon._transport import get_transport
 from leapflow.daemon.client import DaemonClient, DaemonUnavailableError, ensure_daemon_client
 from leapflow.daemon.lifecycle import DaemonInfo
 from leapflow.daemon.protocol import StreamChunk
@@ -75,7 +77,7 @@ async def engine_chat(self, message: str, **kwargs: Any) -> AsyncIterator[Stream
 
 class _SlowFirstChunkService(_FakeService):
     async def engine_chat(self, message: str, **kwargs: Any) -> AsyncIterator[StreamChunk]:
-        await asyncio.sleep(0.08)
+        await asyncio.sleep(0.16)
         yield StreamChunk(request_id="", content=f"slow {message}", event_type="chunk")
         yield StreamChunk(request_id="", content="done", event_type="final")
 
@@ -128,8 +130,9 @@ async def _start_server(runtime_dir: Path, service=None, *, stream_heartbeat_s:
         stream_heartbeat_s=stream_heartbeat_s,
     )
     task = asyncio.create_task(server.serve_forever())
+    readiness = get_transport().readiness_path(runtime_dir)
     for _ in range(50):
-        if (runtime_dir / "leapd.sock").exists():
+        if readiness.exists():
             return server, task, runtime_dir
         await asyncio.sleep(0.02)
     task.cancel()
@@ -612,9 +615,9 @@ async def test_daemon_client_stream_heartbeat_prevents_idle_timeout() -> None:
         server, task, runtime_dir = await _start_server(
             Path(root) / "runtime",
             service=_SlowFirstChunkService(),
-            stream_heartbeat_s=0.01,
+            stream_heartbeat_s=0.03,
         )
-        client = DaemonClient(runtime_dir / "leapd.sock", timeout_s=0.03)
+        client = DaemonClient(runtime_dir / "leapd.sock", timeout_s=0.1)
 
         try:
             events = [event async for event in client.engine_chat("world")]
@@ -1237,8 +1240,9 @@ async def shutdown(self) -> None:
             on_shutdown=shutdown_event.set,
         )
         task = asyncio.create_task(server.serve_forever())
+        readiness = get_transport().readiness_path(runtime_dir)
         for _ in range(50):
-            if (runtime_dir / "leapd.sock").exists():
+            if readiness.exists():
                 break
             await asyncio.sleep(0.02)
         else:
@@ -1665,7 +1669,7 @@ async def test_runtime_service_hot_reloads_config_before_daemon_chat(
         assert status["runtime_dir"] == str(settings.runtime_dir)
         assert status["llm_context_length"] == 700_000
         assert status["context_used"] == 0
-        assert status["runtime_source"].endswith("leapflow/__init__.py")
+        assert status["runtime_source"] == str(leapflow.__file__)
         assert status["runtime_executable"]
         assert status["runtime_version"]
     finally:
diff --git a/tests/test_process_group.py b/tests/test_process_group.py
index 0def35c..fb8611e 100644
--- a/tests/test_process_group.py
+++ b/tests/test_process_group.py
@@ -70,6 +70,7 @@ def test_second_terminate_is_false() -> None:
     group = ProcessGroup()
     group.attach(proc.pid)
     assert group.terminate() is True
+    proc.wait(timeout=5)  # reap on POSIX: a zombie keeps the group alive
     assert group.terminate() is False  # job handle released / pgid already dead
 
 

From fa6bfbb12c48cc34c9d503368ecb41727b29c814 Mon Sep 17 00:00:00 2001
From: fanqiNO1 <1848839264@qq.com>
Date: Fri, 7 Aug 2026 13:15:21 +0800
Subject: [PATCH 2/4] fix unit tests

---
 src/leapflow/cli/commands/slash_handlers.py   | 4268 +++++++++--------
 src/leapflow/daemon/client.py                 |    7 +-
 src/leapflow/daemon/server.py                 |    2 +-
 src/leapflow/daemon/session_registry.py       |   17 +-
 src/leapflow/dashboard/intent.py              |   85 +-
 src/leapflow/tools/shell_tools.py             |   18 +-
 src/leapflow/utils/shell_lex.py               |   18 +
 tests/_harness/cassette.py                    |    3 +
 tests/_harness/leapd.py                       |    5 +-
 tests/conftest.py                             |   25 +
 tests/journeys/test_r6_lifecycle.py           |    4 +-
 tests/regression/test_test_layer_contracts.py |    2 +-
 tests/test_cli_entrypoint.py                  |    3 +-
 tests/test_code_tools.py                      |  973 ++--
 tests/test_daemon_event_loop_blocking.py      |  710 +--
 tests/test_daemon_rpc.py                      |   57 +-
 tests/test_dev_terminal_tools.py              |   20 +-
 tests/test_tool_call_hardening.py             |  728 +--
 tools/impact.py                               |    6 +-
 19 files changed, 3536 insertions(+), 3415 deletions(-)
 create mode 100644 src/leapflow/utils/shell_lex.py

diff --git a/src/leapflow/cli/commands/slash_handlers.py b/src/leapflow/cli/commands/slash_handlers.py
index cca129e..e2724b0 100644
--- a/src/leapflow/cli/commands/slash_handlers.py
+++ b/src/leapflow/cli/commands/slash_handlers.py
@@ -1,2131 +1,2137 @@
-"""Slash-command handler implementations.
-
-Each handler follows the signature ``(ctx, console, args) -> None``.
-All display logic uses ``LeapConsole`` for consistent theming.
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-import shlex
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from leapflow.cli.context import Context
-    from leapflow.cli.tui_app.console import LeapConsole
-
-
-logger = logging.getLogger(__name__)
-
-
-def build_tool_payload(ctx: "Context") -> dict[str, Any]:
-    """Build a serializable tool summary for local or daemon rendering."""
-    from leapflow.cli.banner import _categorize_tools
-    from leapflow.tools.registry_bootstrap import TOOL_DEFINITIONS
-
-    tool_groups = _categorize_tools(TOOL_DEFINITIONS)
-    groups = {category: sorted(names) for category, names in tool_groups.items()}
-    mcp_count = 0
-    if hasattr(ctx.rpc, "connected") and ctx.rpc.connected:
-        mcp_count = len(getattr(ctx, "platform_tools", []))
-    return {
-        "ok": True,
-        "groups": groups,
-        "total": sum(len(names) for names in groups.values()),
-        "mcp_count": mcp_count,
-    }
-
-
-def render_tool_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    """Render a serializable tool summary."""
-    from rich.table import Table
-
-    if not payload.get("ok", True):
-        console.warning(str(payload.get("error") or "Tools are not available."))
-        return
-
-    groups = dict(payload.get("groups") or {})
-    table = Table(
-        title="Available Tools",
-        show_header=True,
-        header_style="bold",
-        border_style="bright_black",
-        title_style="bold cyan",
-        padding=(0, 1),
-    )
-    table.add_column("Category", style="cyan", no_wrap=True)
-    table.add_column("Tools")
-
-    for category, names in groups.items():
-        table.add_row(str(category), ", ".join(sorted(str(name) for name in names)))
-
-    mcp_count = int(payload.get("mcp_count") or 0)
-    if mcp_count > 0:
-        table.add_row("mcp", f"{mcp_count} platform tools")
-
-    console.print(table)
-    console.system(f"{int(payload.get('total') or 0)} tools available")
-
-
-def build_usage_payload(ctx: "Context") -> dict[str, Any]:
-    """Build a serializable token usage summary."""
-    engine = ctx.engine
-    if engine is None:
-        return {"ok": False, "error": "No active engine — send a message first."}
-
-    tracker = getattr(engine, "usage_tracker", None)
-    if tracker is None:
-        return {"ok": False, "error": "Usage tracking not available."}
-
-    summary = tracker.summary()
-    cap_registry = getattr(engine, "model_capabilities", None)
-    context_length = 0
-    if cap_registry is not None:
-        caps = cap_registry.resolve(ctx.settings.llm_model)
-        context_length = int(caps.context_length)
-
-    return {
-        "ok": True,
-        "model": ctx.settings.llm_model,
-        "prompt_tokens": int(summary.prompt_tokens),
-        "completion_tokens": int(summary.completion_tokens),
-        "total_tokens": int(summary.total_tokens),
-        "turn_count": int(getattr(engine, "turn_count", 0)),
-        "context_used": int(getattr(engine, "context_token_count", 0)),
-        "context_length": context_length,
-    }
-
-
-def render_usage_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    """Render a serializable token usage summary."""
-    from leapflow.cli.tui_app.status import _compact_tokens
-
-    if not payload.get("ok", True):
-        console.warning(str(payload.get("error") or "Usage tracking not available."))
-        return
-
-    console.print()
-    prompt_tokens = int(payload.get("prompt_tokens") or 0)
-    completion_tokens = int(payload.get("completion_tokens") or 0)
-    total_tokens = int(payload.get("total_tokens") or 0)
-    turn_count = int(payload.get("turn_count") or 0)
-    context_used = int(payload.get("context_used") or 0)
-    context_length = int(payload.get("context_length") or 0)
-    lines = [
-        f"  Model:           {payload.get('model') or ''}",
-        f"  Input tokens:    {_compact_tokens(prompt_tokens):>8}  ({prompt_tokens:,})",
-        f"  Output tokens:   {_compact_tokens(completion_tokens):>8}  ({completion_tokens:,})",
-        f"  Total tokens:    {_compact_tokens(total_tokens):>8}  ({total_tokens:,})",
-        f"  Turns:           {turn_count}",
-    ]
-    if context_length > 0:
-        pct = int(context_used * 100 / context_length)
-        lines.append(
-            f"  Context:         {_compact_tokens(context_used)}/{_compact_tokens(context_length)} ({pct}%)"
-        )
-    for line in lines:
-        console.system(line)
-    console.print()
-
-
-def build_model_payload(ctx: "Context", args: str = "") -> dict[str, Any]:
-    """Build a serializable model summary or update the active model."""
-    model_arg = args.strip()
-    if model_arg:
-        payload = build_config_payload(ctx, f"llm set --model {shlex.quote(model_arg)}")
-        payload["view"] = "model"
-        payload["requested_model"] = model_arg
-        return payload
-
-    engine = ctx.engine
-    context_length = 0
-    if engine is not None:
-        cap_registry = getattr(engine, "model_capabilities", None)
-        if cap_registry is not None:
-            caps = cap_registry.resolve(ctx.settings.llm_model)
-            context_length = int(caps.context_length)
-    return {
-        "ok": True,
-        "view": "model",
-        "model": ctx.settings.llm_model,
-        "context_length": context_length,
-        "requested_model": "",
-    }
-
-
-def render_model_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    """Render a serializable model summary."""
-    if not payload.get("ok", True):
-        console.warning(str(payload.get("error") or payload.get("message") or "Model information is not available."))
-        return
-    requested = str(payload.get("requested_model") or "")
-    model = str(payload.get("model") or "")
-    if requested:
-        console.success(f"Model updated: {model}")
-        if payload.get("reloaded"):
-            console.system("Configuration reloaded for this session.")
-        return
-
-    console.system(f"Current model: {model}")
-    context_length = int(payload.get("context_length") or 0)
-    if context_length > 0:
-        console.system(f"Context length: {context_length:,}")
-
-
-def build_config_payload(ctx: "Context", args: str = "") -> dict[str, Any]:
-    """Execute a config command and return a serializable payload."""
-    from leapflow.config_service import ConfigService
-
-    service = ConfigService(ctx.settings)
-    try:
-        tokens = shlex.split(args)
-    except ValueError as exc:
-        return {"ok": False, "message": f"Invalid /config syntax: {exc}"}
-    if not tokens:
-        tokens = ["show"]
-    action = tokens[0]
-    try:
-        if action == "show":
-            if len(tokens) > 1:
-                return {
-                    "ok": True,
-                    "view": "config",
-                    "mode": "show_detail",
-                    "field": _config_field_to_dict(service.describe(tokens[1])),
-                }
-            return _config_snapshot_payload(service)
-        if action == "keys":
-            return {"ok": True, "view": "config", "mode": "keys", "sources": list(service.writable_keys())}
-        if action == "list":
-            category = tokens[1] if len(tokens) > 1 and not tokens[1].startswith("--") else None
-            return {"ok": True, "view": "config", "mode": "list", "fields": [_config_field_to_dict(item) for item in service.list_fields(category)]}
-        if action == "sources":
-            return {"ok": True, "view": "config", "mode": "sources", "sources": list(service.sources())}
-        if action == "get" and len(tokens) == 2:
-            value = service.get(tokens[1])
-            return {"ok": True, "view": "config", "mode": "get", "values": [_config_value_to_dict(value)]}
-        if action == "set" and len(tokens) >= 3:
-            scope = _option_value(tokens[3:], "--scope", "profile")
-            result = service.set(tokens[1], tokens[2], scope=scope)  # type: ignore[arg-type]
-            return _config_mutation_payload(ctx, service, result)
-        if action == "unset" and len(tokens) >= 2:
-            scope = _option_value(tokens[2:], "--scope", "profile")
-            result = service.unset(tokens[1], scope=scope)  # type: ignore[arg-type]
-            return _config_mutation_payload(ctx, service, result)
-        if action == "llm":
-            return _build_llm_config_payload(ctx, service, tokens[1:])
-        if action == "secret":
-            return _build_secret_config_payload(ctx, service, tokens[1:])
-    except (KeyError, ValueError, RuntimeError) as exc:
-        return {"ok": False, "message": f"Config error: {exc}"}
-    return {"ok": False, "message": "Usage: /config [show|list|keys|sources|get|set|unset|llm|secret] ..."}
-
-
-_CONFIG_LIST_COMPACT_WIDTH = 92
-_CONFIG_LIST_FULL_WIDTH = 118
-
-
-def _display_width(console: object, default: int = 100) -> int:
-    """Return the active Rich console width with a safe fallback for tests."""
-    width = getattr(console, "width", None)
-    if isinstance(width, int) and width > 0:
-        return width
-    raw = getattr(console, "raw", None)
-    raw_width = getattr(raw, "width", None)
-    if isinstance(raw_width, int) and raw_width > 0:
-        return raw_width
-    return default
-
-
-def _shorten(text: object, limit: int) -> str:
-    """Shorten a cell value before Rich allocates table columns."""
-    value = str(text) if text is not None else ""
-    if limit <= 0:
-        return ""
-    if len(value) <= limit:
-        return value
-    return value[: max(1, limit - 1)] + "…"
-
-
-def _config_scope_text(item: dict[str, Any], *, limit: int) -> str:
-    scopes = ",".join(str(scope) for scope in item.get("scopes") or [])
-    return _shorten(scopes, limit)
-
-
-def _config_reload_text(item: dict[str, Any]) -> str:
-    value = item.get("hot_reload")
-    if isinstance(value, bool):
-        return "yes" if value else "no"
-    return str(value) if value is not None and str(value) else "no"
-
-
-def _config_meta_text(item: dict[str, Any], *, scope_limit: int) -> str:
-    parts = [str(item.get("type") or "?")]
-    scope = _config_scope_text(item, limit=scope_limit)
-    if scope:
-        parts.append(scope)
-    parts.append(f"reload:{_config_reload_text(item)}")
-    return " · ".join(parts)
-
-
-def _build_config_list_table(console: object, fields: list[dict[str, Any]]) -> object:
-    """Build a width-aware config list table for TUI rendering."""
-    from rich.table import Table
-
-    width = _display_width(console)
-    table = Table(title="Writable config fields", show_lines=False, expand=True)
-    if width < _CONFIG_LIST_COMPACT_WIDTH:
-        table.add_column("Key", no_wrap=True, overflow="ellipsis", max_width=32, ratio=2)
-        table.add_column("Value", overflow="fold", max_width=24, ratio=1)
-        table.add_column("Meta", overflow="fold", max_width=24, ratio=1)
-        for item in fields:
-            table.add_row(
-                _shorten(item.get("key"), 36),
-                _shorten(item.get("value"), 32),
-                _config_meta_text(item, scope_limit=14),
-            )
-        return table
-
-    if width < _CONFIG_LIST_FULL_WIDTH:
-        table.add_column("Key", no_wrap=True, overflow="ellipsis", max_width=34, ratio=2)
-        table.add_column("Value", overflow="fold", max_width=30, ratio=1)
-        table.add_column("Type", no_wrap=True, max_width=8)
-        table.add_column("Scope", no_wrap=True, overflow="ellipsis", max_width=18)
-        table.add_column("Reload", no_wrap=True, max_width=6)
-        for item in fields:
-            table.add_row(
-                _shorten(item.get("key"), 38),
-                _shorten(item.get("value"), 40),
-                str(item.get("type") or ""),
-                _config_scope_text(item, limit=18),
-                _config_reload_text(item),
-            )
-        return table
-
-    table.add_column("Key", no_wrap=True, overflow="ellipsis", max_width=36, ratio=2)
-    table.add_column("Value", overflow="fold", max_width=36, ratio=1)
-    table.add_column("Type", no_wrap=True, max_width=10)
-    table.add_column("Scope", no_wrap=True, overflow="ellipsis", max_width=22)
-    table.add_column("Reload", no_wrap=True, max_width=6)
-    table.add_column("Description", overflow="fold", ratio=2)
-    for item in fields:
-        table.add_row(
-            _shorten(item.get("key"), 42),
-            _shorten(item.get("value"), 48),
-            str(item.get("type") or ""),
-            _config_scope_text(item, limit=22),
-            _config_reload_text(item),
-            str(item.get("description") or ""),
-        )
-    return table
-
-
-def render_config_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    """Render config command output."""
-    if not payload.get("ok", True):
-        console.warning(str(payload.get("message") or "Config command failed."))
-        return
-    mode = str(payload.get("mode") or "show")
-    if mode in {"sources", "keys"}:
-        label = "Writable config keys" if mode == "keys" else "Config sources"
-        sources = [str(source) for source in payload.get("sources") or []]
-        if not sources:
-            console.system(f"No {label.lower()} found.")
-            return
-        console.system(f"{label}:")
-        for source in sources:
-            console.system(f"  {source}")
-        return
-    if mode == "list":
-        fields = [dict(item) for item in payload.get("fields") or []]
-        if not fields:
-            console.system("No writable config fields found.")
-            return
-        console.print(_build_config_list_table(console, fields))
-        console.system("Use /config show <key>, /config get <key>, /config set <key> <value>, or /config keys for compact output.")
-        return
-    if mode == "show_detail":
-        field = dict(payload.get("field") or {})
-        if not field:
-            console.warning("No config field details found.")
-            return
-        from rich.panel import Panel
-        from rich.text import Text
-
-        details = Text()
-        details.append(f"value: {field.get('value') or ''}\n")
-        details.append(f"type: {field.get('type') or ''}\n")
-        details.append(f"category: {field.get('category') or ''}\n")
-        details.append(f"scope: {','.join(str(scope) for scope in field.get('scopes') or [])}\n")
-        details.append(f"reload: {field.get('hot_reload') or ''}\n")
-        details.append(f"secret: {'true' if field.get('secret') else 'false'}\n")
-        value_hint = str(field.get("value_hint") or "")
-        if value_hint:
-            details.append(f"value hint: {value_hint}\n")
-        details.append(f"description: {field.get('description') or ''}")
-        examples = [str(example) for example in field.get("examples") or []]
-        if examples:
-            details.append(f"\nexample: {examples[0]}")
-        console.print(Panel(details, title=str(field.get("key") or "Config field"), border_style="cyan"))
-        return
-    if mode == "mutation":
-        console.success(str(payload.get("message") or "Config updated."))
-        for key in payload.get("changed_keys") or []:
-            console.system(f"  {key}")
-        warnings = payload.get("warnings") or []
-        for warning in warnings:
-            console.warning(str(warning))
-        if payload.get("reloaded"):
-            console.system("Configuration reloaded for this session.")
-        return
-    values = payload.get("values") or []
-    if values:
-        for item in values:
-            console.system(f"{item.get('key')}={item.get('value')}")
-    warnings = payload.get("warnings") or []
-    for warning in warnings:
-        console.warning(str(warning))
-
-
-def _config_snapshot_payload(service: Any) -> dict[str, Any]:
-    snapshot = service.snapshot()
-    return {
-        "ok": True,
-        "view": "config",
-        "mode": "show",
-        "values": [_config_value_to_dict(value) for value in snapshot.values],
-        "sources": list(snapshot.sources),
-        "warnings": list(snapshot.warnings),
-    }
-
-
-def _config_value_to_dict(value: Any) -> dict[str, Any]:
-    return {"key": value.key, "value": value.value, "source": value.source, "secret": value.secret}
-
-
-def _config_field_to_dict(value: Any) -> dict[str, Any]:
-    return {
-        "key": value.key,
-        "value": value.value,
-        "type": value.value_type,
-        "category": value.category,
-        "scopes": list(value.scopes),
-        "hot_reload": value.hot_reload,
-        "secret": value.secret,
-        "description": value.description,
-        "value_hint": value.value_hint,
-        "examples": list(value.examples),
-    }
-
-
-def _build_llm_config_payload(ctx: "Context", service: Any, tokens: list[str]) -> dict[str, Any]:
-    action = tokens[0] if tokens else "show"
-    if action == "show":
-        payload = _config_snapshot_payload(service)
-        payload["values"] = [item for item in payload["values"] if str(item.get("key") or "").startswith("llm.")]
-        return payload
-    if action != "set":
-        return {"ok": False, "message": "Usage: /config llm [show|set --model NAME --base-url URL --api-key KEY]"}
-    options = tokens[1:]
-    if "--ask-api-key" in options:
-        return {"ok": False, "message": "Use `leap config llm key` in a terminal for secure API key prompts."}
-    result = service.configure_llm(
-        api_key=_option_value(options, "--api-key"),
-        base_url=_option_value(options, "--base-url"),
-        model=_option_value(options, "--model"),
-        context_length=_option_int(options, "--context-length"),
-        max_retries=_option_int(options, "--max-retries"),
-        scope=_option_value(options, "--scope", "profile"),
-    )
-    return _config_mutation_payload(ctx, service, result)
-
-
-def _build_secret_config_payload(ctx: "Context", service: Any, tokens: list[str]) -> dict[str, Any]:
-    action = tokens[0] if tokens else "list"
-    if action == "list":
-        return {"ok": True, "view": "config", "mode": "sources", "sources": list(service.list_secrets())}
-    if action == "set" and len(tokens) >= 3:
-        scope = _option_value(tokens[3:], "--scope", "profile")
-        result = service.set_secret(tokens[1], tokens[2], scope=scope)  # type: ignore[arg-type]
-        return _config_mutation_payload(ctx, service, result)
-    if action == "get" and len(tokens) >= 2:
-        scope = _option_value(tokens[2:], "--scope", "profile")
-        reveal = "--reveal" in tokens[2:]
-        value = service.get_secret(tokens[1], scope=scope, reveal=reveal)  # type: ignore[arg-type]
-        return {"ok": True, "view": "config", "mode": "get", "values": [{"key": tokens[1], "value": value, "secret": not reveal}]}
-    if action == "delete" and len(tokens) >= 2:
-        scope = _option_value(tokens[2:], "--scope", "profile")
-        result = service.delete_secret(tokens[1], scope=scope)  # type: ignore[arg-type]
-        return _config_mutation_payload(ctx, service, result)
-    return {"ok": False, "message": "Usage: /config secret [list|set|get|delete] ..."}
-
-
-def _config_mutation_payload(ctx: "Context", service: Any, result: Any) -> dict[str, Any]:
-    reloaded = False
-    if result.changed_keys:
-        reloaded = bool(ctx.reload_runtime_config_if_changed(force=True))
-    return {
-        "ok": bool(result.ok),
-        "view": "config",
-        "mode": "mutation",
-        "message": result.message,
-        "changed_keys": list(result.changed_keys),
-        "warnings": list(getattr(result, "warnings", ()) or ()),
-        "reloaded": reloaded,
-        # Runtime values the status bar renders. A daemon-mode TUI is a separate
-        # process and cannot see the reload, so it needs them echoed back here;
-        # context length travels with the model because switching models usually
-        # changes it too.
-        "model": ctx.settings.llm_model,
-        "llm_context_length": int(getattr(ctx.settings, "llm_context_length", 0) or 0),
-    }
-
-
-def _option_value(tokens: list[str], option: str, default: str | None = None) -> str | None:
-    if option not in tokens:
-        return default
-    index = tokens.index(option)
-    if index + 1 >= len(tokens):
-        raise ValueError(f"Missing value for {option}")
-    return tokens[index + 1]
-
-
-def _option_int(tokens: list[str], option: str) -> int | None:
-    value = _option_value(tokens, option)
-    return int(value) if value is not None else None
-
-
-def handle_status(ctx: "Context", console: "LeapConsole", args: str) -> None:
-    """Display session status: model, context, platform, session info."""
-    from rich.panel import Panel
-    from rich.text import Text
-
-    info = Text()
-
-    info.append("Model:     ", style="dim")
-    info.append(f"{ctx.settings.llm_model}\n", style="bold")
-
-    engine = ctx.engine
-    if engine is not None:
-        cap_registry = getattr(engine, "model_capabilities", None)
-        ctx_len = 0
-        if cap_registry is not None:
-            caps = cap_registry.resolve(ctx.settings.llm_model)
-            ctx_len = caps.context_length
-        ctx_used = getattr(engine, "context_token_count", 0)
-        turn_count = getattr(engine, "turn_count", 0)
-
-        if ctx_len:
-            pct = int(ctx_used * 100 / ctx_len) if ctx_len else 0
-            info.append("Context:   ", style="dim")
-            pct_style = "bold red" if pct >= 90 else ("yellow" if pct >= 75 else "")
-            info.append(f"{ctx_used:,} / {ctx_len:,} ({pct}%)\n", style=pct_style)
-
-        info.append("Turns:     ", style="dim")
-        info.append(f"{turn_count}\n")
-
-    platform_status = "connected" if (hasattr(ctx.rpc, "connected") and ctx.rpc.connected) else "mock"
-    info.append("Platform:  ", style="dim")
-    p_style = "green" if platform_status == "connected" else "dim"
-    info.append(f"{platform_status}\n", style=p_style)
-
-    cwd = os.getcwd().replace(os.path.expanduser("~"), "~")
-    info.append("CWD:       ", style="dim")
-    info.append(f"{cwd}\n")
-
-    info.append("Profile:   ", style="dim")
-    info.append(f"{ctx.settings.profile}\n")
-
-    info.append("Config:    ", style="dim")
-    info.append(f"{str(ctx.settings.profile_layout.config_dir).replace(os.path.expanduser('~'), '~')}\n")
-
-    user_config = str(ctx.settings.layout.user_config_path).replace(os.path.expanduser("~"), "~")
-    info.append("User cfg:  ", style="dim")
-    info.append(f"{user_config}\n")
-
-    workspace_config = str(ctx.settings.workspace_root / ".leapflow" / "config.yaml")
-    info.append("Workspace: ", style="dim")
-    info.append(f"{workspace_config.replace(os.path.expanduser('~'), '~')}\n")
-
-    session_id = getattr(ctx.session, "session_id", "")
-    if session_id:
-        info.append("Session:   ", style="dim")
-        info.append(f"{session_id}\n")
-
-    from leapflow.engine.session import SessionMode
-    mode = "idle"
-    if ctx.session:
-        if ctx.session.mode == SessionMode.LEARNING:
-            mode = "learning"
-        elif ctx.session.mode == SessionMode.EXECUTING:
-            mode = "executing"
-    info.append("Mode:      ", style="dim")
-    info.append(f"{mode}\n")
-
-    gw = getattr(ctx, "gateway_server", None)
-    if gw is not None:
-        statuses = gw.platform_status()
-        connected = [s for s in statuses if s.connected]
-        info.append("Gateway:   ", style="dim")
-        if connected:
-            names = []
-            for s in connected:
-                m = gw.manifests.get(s.platform_id)
-                names.append(m.display_name if m else s.platform_id)
-            info.append(f"{', '.join(names)}\n", style="green")
-        else:
-            info.append("no connections\n", style="dim")
-
-    console.print(Panel(
-        info,
-        title="[bold cyan]LeapFlow Status[/]",
-        border_style="bright_black",
-        padding=(0, 2),
-    ))
-
-
-def handle_tool(ctx: "Context", console: "LeapConsole", args: str) -> None:
-    """Display available tools grouped by category."""
-    render_tool_payload(console, build_tool_payload(ctx))
-
-
-def handle_usage(ctx: "Context", console: "LeapConsole", args: str) -> None:
-    """Display token usage for the current session."""
-    render_usage_payload(console, build_usage_payload(ctx))
-
-
-def handle_model(ctx: "Context", console: "LeapConsole", args: str) -> None:
-    """Show or switch the active model."""
-    render_model_payload(console, build_model_payload(ctx, args))
-
-
-def handle_config(ctx: "Context", console: "LeapConsole", args: str) -> None:
-    """View or update runtime configuration."""
-    render_config_payload(console, build_config_payload(ctx, args))
-
-
-def handle_gateway(ctx: "Context", console: "LeapConsole", args: str) -> None:
-    """Display gateway status: connected platforms, available integrations."""
-    from rich.panel import Panel
-    from rich.text import Text
-
-    gw = getattr(ctx, "gateway_server", None)
-    if gw is None:
-        console.warning("Gateway not initialised.")
-        return
-
-    statuses = gw.platform_status()
-    if not statuses:
-        console.system("No platform manifests discovered.")
-        return
-
-    info = Text()
-    connected = [s for s in statuses if s.connected]
-    configured = [s for s in statuses if not s.connected and s.error == "configured but not connected"]
-    available = [s for s in statuses if not s.connected and not s.error]
-
-    import time
-
-    if connected:
-        info.append("Connected\n", style="bold green")
-        for s in connected:
-            m = gw.manifests.get(s.platform_id)
-            name = m.display_name if m else s.platform_id
-            uptime = ""
-            if s.connected_since > 0:
-                secs = int(time.time() - s.connected_since)
-                if secs < 60:
-                    uptime = f" ({secs}s)"
-                elif secs < 3600:
-                    uptime = f" ({secs // 60}m)"
-                else:
-                    uptime = f" ({secs // 3600}h {(secs % 3600) // 60}m)"
-            info.append(f"  ● {name}{uptime}\n", style="green")
-
-    if configured:
-        info.append("Configured (not connected)\n", style="bold yellow")
-        for s in configured:
-            m = gw.manifests.get(s.platform_id)
-            name = m.display_name if m else s.platform_id
-            info.append(f"  ○ {name}\n", style="yellow")
-
-    if available:
-        info.append("Available\n", style="bold dim")
-        names = [gw.manifests[s.platform_id].display_name for s in available if s.platform_id in gw.manifests]
-        info.append(f"  {', '.join(names)}\n", style="dim")
-
-    info.append("\n", style="dim")
-    info.append('Say "connect to <platform>" to set up a new integration.', style="dim italic")
-
-    console.print(Panel(
-        info,
-        title="[bold cyan]Gateway[/]",
-        border_style="bright_black",
-        padding=(0, 2),
-    ))
-
-
-def _app_usage() -> dict[str, Any]:
-    return {
-        "ok": False,
-        "error": "Usage: /app [platform] | /app status [platform] | /app connect <platform> [--option value] | /app disconnect <platform> | /app remove <platform> | /app events [status|start|stop] <platform> | /app actions <platform>",
-        "next_actions": ("/app", "/app <platform>", "/app status <platform>"),
-    }
-
-
-def _parse_app_options(tokens: list[str]) -> tuple[dict[str, str], str]:
-    options: dict[str, str] = {}
-    index = 0
-    while index < len(tokens):
-        token = tokens[index]
-        if not token.startswith("--") or token == "--":
-            return {}, f"Unexpected argument: {token}"
-        key_value = token[2:]
-        if "=" in key_value:
-            key, value = key_value.split("=", 1)
-            if not key:
-                return {}, f"Invalid option: {token}"
-            options[key] = value
-            index += 1
-            continue
-        if index + 1 >= len(tokens):
-            return {}, f"Missing value for option: {token}"
-        key = key_value
-        if not key:
-            return {}, f"Invalid option: {token}"
-        options[key] = tokens[index + 1]
-        index += 2
-    return options, ""
-
-
-def _parse_app_params(args: str) -> dict[str, Any]:
-    try:
-        tokens = shlex.split(args)
-    except ValueError as exc:
-        return {"ok": False, "error": f"Invalid /app arguments: {exc}"}
-
-    if not tokens or tokens[0].lower() == "list":
-        if len(tokens) > 1:
-            return _app_usage()
-        return {"ok": True, "params": {"action": "list"}, "view": "list"}
-
-    head = tokens[0].lower()
-    if head == "status":
-        if len(tokens) > 2:
-            return _app_usage()
-        params: dict[str, Any] = {"action": "status"}
-        if len(tokens) == 2:
-            params["platform"] = tokens[1].lower()
-        return {"ok": True, "params": params, "view": "status"}
-
-    if head == "connect":
-        if len(tokens) < 2:
-            return _app_usage()
-        options, error = _parse_app_options(tokens[2:])
-        if error:
-            return {
-                "ok": False,
-                "error": error,
-                "next_actions": ("/app connect <platform> --<option> <value>",),
-            }
-        params = {"action": "connect", "platform": tokens[1].lower()}
-        if options:
-            params["options"] = options
-        return {"ok": True, "params": params, "view": "connect"}
-
-    if head in {"disconnect", "remove"}:
-        if len(tokens) != 2:
-            return _app_usage()
-        return {
-            "ok": True,
-            "params": {"action": head, "platform": tokens[1].lower()},
-            "view": head,
-        }
-
-    if head == "events":
-        if len(tokens) == 2:
-            return {
-                "ok": True,
-                "params": {"action": "events_status", "platform": tokens[1].lower()},
-                "view": "events",
-            }
-        if len(tokens) == 3 and tokens[1].lower() in {"status", "start", "stop"}:
-            event_action = tokens[1].lower()
-            action = "events_status" if event_action == "status" else f"events_{event_action}"
-            return {
-                "ok": True,
-                "params": {"action": action, "platform": tokens[2].lower()},
-                "view": "events",
-            }
-        return _app_usage()
-
-    if head == "actions":
-        if len(tokens) != 2:
-            return _app_usage()
-        return {"ok": True, "platform": tokens[1].lower(), "view": "actions"}
-
-    if len(tokens) == 1:
-        return {
-            "ok": True,
-            "params": {"action": "guide", "platform": tokens[0].lower()},
-            "view": "guide",
-        }
-
-    return _app_usage()
-
-
-def _resolve_app_platform(gw: Any, platform: str) -> tuple[str, str]:
-    if not platform:
-        return "", ""
-    manifests = getattr(gw, "manifests", {}) or {}
-    if platform in manifests:
-        return platform, ""
-    folded = platform.casefold()
-    matches = [pid for pid in manifests if str(pid).casefold() == folded]
-    if len(matches) == 1:
-        return matches[0], ""
-    return "", f"Unknown platform: {platform}"
-
-
-def _available_app_ids(gw: Any) -> list[str]:
-    manifests = getattr(gw, "manifests", {}) or {}
-    return sorted(str(platform_id) for platform_id in manifests)
-
-
-def _coerce_app_option(field: Any, value: str) -> tuple[Any, str]:
-    choices = tuple(getattr(field, "choices", ()) or ())
-    if choices and value not in choices:
-        return None, f"Invalid value for --{field.key}: {value}. Choices: {', '.join(map(str, choices))}"
-
-    field_type = str(getattr(field, "field_type", "string") or "string").lower()
-    if field_type in {"string", "choice"}:
-        return value, ""
-    if field_type in {"integer", "int"}:
-        try:
-            return int(value), ""
-        except ValueError:
-            return None, f"Invalid integer for --{field.key}: {value}"
-    if field_type in {"number", "float"}:
-        try:
-            return float(value), ""
-        except ValueError:
-            return None, f"Invalid number for --{field.key}: {value}"
-    if field_type in {"boolean", "bool"}:
-        lowered = value.casefold()
-        if lowered in {"1", "true", "yes", "on"}:
-            return True, ""
-        if lowered in {"0", "false", "no", "off"}:
-            return False, ""
-        return None, f"Invalid boolean for --{field.key}: {value}"
-    return value, ""
-
-
-def _validate_app_options(manifest: Any, options: dict[str, str]) -> tuple[dict[str, Any], str]:
-    if not options:
-        return {}, ""
-    fields = {str(field.key): field for field in getattr(manifest, "options", ())}
-    unknown = sorted(key for key in options if key not in fields)
-    if unknown:
-        available = ", ".join(sorted(fields)) or "no options"
-        return {}, f"Unknown option(s): {', '.join(unknown)}. Available options: {available}"
-
-    coerced: dict[str, Any] = {}
-    for key, value in options.items():
-        converted, error = _coerce_app_option(fields[key], value)
-        if error:
-            return {}, error
-        coerced[key] = converted
-    return coerced, ""
-
-
-async def build_app_payload(ctx: "Context", args: str = "") -> dict[str, Any]:
-    """Build a serializable App Connector slash-command payload."""
-    gw = getattr(ctx, "gateway_server", None)
-    if gw is None:
-        return {
-            "ok": False,
-            "error": "Gateway is not initialised in this session.",
-            "next_actions": ("Start an in-process LeapFlow session", "Use /help to inspect runtime support"),
-        }
-
-    parsed = _parse_app_params(args)
-    if not parsed.get("ok"):
-        parsed.setdefault("available", _available_app_ids(gw))
-        return parsed
-
-    from leapflow.tools.gateway_tool import platform_action_capability_summary, platform_connect_handler, set_gateway_server
-
-    set_gateway_server(gw)
-    if parsed.get("view") == "actions":
-        platform, error = _resolve_app_platform(gw, str(parsed.get("platform") or ""))
-        if error:
-            return {"ok": False, "error": error, "available": _available_app_ids(gw)}
-        manifest = gw.manifests.get(platform)
-        if manifest is None:
-            return {"ok": False, "error": f"Unknown platform: {platform}", "available": _available_app_ids(gw)}
-        actions = dict(getattr(manifest, "actions", {}) or {})
-        action_summaries = platform_action_capability_summary(platform)
-        return {
-            "ok": True,
-            "view": "actions",
-            "platform": platform,
-            "name": getattr(manifest, "display_name", platform),
-            "action_pack": str(actions.get("pack") or ""),
-            "actions": [item["name"] for item in action_summaries if item.get("name")],
-            "action_details": action_summaries,
-        }
-
-    params = dict(parsed.get("params") or {})
-    platform = str(params.get("platform") or "")
-    if platform:
-        resolved, error = _resolve_app_platform(gw, platform)
-        if error:
-            return {"ok": False, "error": error, "available": _available_app_ids(gw)}
-        params["platform"] = resolved
-        manifest = gw.manifests.get(resolved)
-        if manifest is not None and params.get("action") == "connect":
-            options, option_error = _validate_app_options(
-                manifest,
-                dict(params.get("options") or {}),
-            )
-            if option_error:
-                return {
-                    "ok": False,
-                    "error": option_error,
-                    "available": _available_app_ids(gw),
-                    "next_actions": (f"/app {resolved}", f"/app connect {resolved}"),
-                }
-            if options:
-                params["options"] = options
-
-    result = await platform_connect_handler(params)
-    view = str(parsed.get("view") or "")
-    if params.get("action") == "connect" and result.get("setup_guide"):
-        view = "guide"
-    return {
-        "ok": bool(result.get("ok")),
-        "view": view,
-        "params": params,
-        "result": result,
-    }
-
-
-def _append_result_metadata(lines: list[str], result: dict[str, Any]) -> None:
-    diagnostics = result.get("diagnostics") or result.get("metadata")
-    if isinstance(diagnostics, dict) and diagnostics:
-        for key in ("backend_kind", "profile", "identity", "auth_status", "configured", "current_mode"):
-            if diagnostics.get(key) is not None:
-                lines.append(f"  {key}: {diagnostics[key]}")
-    recovery_hint = result.get("recovery_hint")
-    if recovery_hint:
-        lines.append(f"  recovery: {recovery_hint}")
-    next_steps = result.get("next_steps")
-    if isinstance(next_steps, list) and next_steps:
-        lines.append("  next steps:")
-        lines.extend(f"    - {step}" for step in next_steps)
-
-
-def render_app_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    """Render a serializable App Connector slash-command payload."""
-    from rich.panel import Panel
-    from rich.table import Table
-    from rich.text import Text
-
-    if not payload.get("ok"):
-        result = dict(payload.get("result") or {})
-        message = (
-            payload.get("error")
-            or result.get("error")
-            or result.get("detail")
-            or "App command failed."
-        )
-        console.warning(str(message))
-        lines: list[str] = []
-        _append_result_metadata(lines, result)
-        for line in lines:
-            console.system(line)
-        available = payload.get("available")
-        if isinstance(available, list) and available:
-            console.system("Available: " + ", ".join(str(item) for item in available))
-        for action in payload.get("next_actions") or ():
-            console.system(f"  → {action}")
-        return
-
-    result = dict(payload.get("result") or {})
-    view = str(payload.get("view") or "")
-    if view == "list":
-        platforms = list(result.get("platforms") or [])
-        table = Table(title="App Connector", show_header=True, header_style="bold", border_style="bright_black")
-        table.add_column("App", style="cyan")
-        table.add_column("ID", style="bold")
-        table.add_column("State")
-        table.add_column("Category")
-        table.add_column("Next")
-        for entry in platforms:
-            platform_id = str(entry.get("id") or "")
-            state = str(entry.get("state") or "available")
-            style = "green" if state == "connected" else ("yellow" if state == "configured" else "dim")
-            table.add_row(
-                str(entry.get("name") or platform_id),
-                platform_id,
-                f"[{style}]{state}[/]",
-                str(entry.get("category") or ""),
-                f"/app {platform_id}",
-            )
-        console.print(table)
-        console.system("Next: /app <platform> · /app status <platform> · /app connect <platform>")
-        return
-
-    if view == "guide":
-        info = Text()
-        info.append(str(result.get("setup_guide") or "No setup guide available.") + "\n")
-        steps = result.get("setup_steps") or []
-        if steps:
-            info.append("\nSteps\n", style="bold")
-            for index, step in enumerate(steps, start=1):
-                info.append(f"  {index}. {step}\n")
-        preflight = result.get("preflight_checks") or []
-        if preflight:
-            info.append("\nPreflight\n", style="bold")
-            for check in preflight:
-                command = check.get("command") or ""
-                label = check.get("label") or check.get("key") or "check"
-                info.append(f"  - {label}: {command}\n")
-        fields = result.get("required_fields") or []
-        if fields:
-            info.append("\nRequired fields\n", style="bold")
-            for field in fields:
-                required = "required" if field.get("required") else "optional"
-                info.append(f"  - {field.get('key')}: {field.get('label')} ({required})\n")
-        console_url = result.get("console_url")
-        if console_url:
-            info.append(f"\nConsole: {console_url}\n", style="dim")
-        platform = str(result.get("platform") or payload.get("params", {}).get("platform") or "App")
-        console.print(Panel(info, title=f"[bold cyan]{platform} setup[/]", border_style="bright_black", padding=(0, 2)))
-        platform_id = str(payload.get("params", {}).get("platform") or "<platform>")
-        if fields:
-            console.system(
-                "Next: provide required credentials through the guided chat flow, "
-                f"then run /app connect {platform_id}"
-            )
-        else:
-            console.system(f"Next: /app connect {platform_id}")
-        return
-
-    if view == "status":
-        platforms = result.get("platforms")
-        if isinstance(platforms, list):
-            table = Table(title="App Status", show_header=True, header_style="bold", border_style="bright_black")
-            table.add_column("ID", style="bold")
-            table.add_column("Connected")
-            table.add_column("Detail")
-            for entry in platforms:
-                detail = str(entry.get("error") or entry.get("uptime") or "available")
-                table.add_row(str(entry.get("id") or ""), "yes" if entry.get("connected") else "no", detail)
-            console.print(table)
-            return
-        lines = [f"platform: {result.get('platform')}", f"connected: {bool(result.get('connected'))}"]
-        if result.get("error"):
-            lines.append(f"detail: {result['error']}")
-        if result.get("uptime"):
-            lines.append(f"uptime: {result['uptime']}")
-        _append_result_metadata(lines, result)
-        console.print(Panel("\n".join(lines), title="[bold cyan]App Status[/]", border_style="bright_black", padding=(0, 2)))
-        return
-
-    if view == "actions":
-        action_names = list(payload.get("actions") or [])
-        action_details = list(payload.get("action_details") or [])
-        lines = [f"platform: {payload.get('name')}"]
-        if payload.get("action_pack"):
-            lines.append(f"action pack: {payload['action_pack']}")
-        if action_names:
-            lines.append("registered actions:")
-            details_by_name = {str(item.get("name")): item for item in action_details}
-            for name in action_names:
-                detail = details_by_name.get(name, {})
-                description = str(detail.get("description") or "").strip()
-                suffix = f" — {description}" if description else ""
-                lines.append(f"  - {name}{suffix}")
-        else:
-            lines.append("registered actions: none")
-        console.print(Panel("\n".join(lines), title="[bold cyan]App Actions[/]", border_style="bright_black", padding=(0, 2)))
-        return
-
-    if result.get("ok"):
-        platform = result.get("platform") or payload.get("params", {}).get("platform") or "App"
-        status = result.get("status") or result.get("detail") or "ok"
-        lines = [f"{platform}: {status}"]
-        _append_result_metadata(lines, result)
-        console.success("App command completed")
-        console.system("\n".join(lines))
-        return
-
-    message = result.get("error") or result.get("detail") or "App command failed."
-    console.warning(str(message))
-    lines: list[str] = []
-    _append_result_metadata(lines, result)
-    for line in lines:
-        console.system(line)
-
-
-async def handle_app(ctx: "Context", console: "LeapConsole", args: str) -> None:
-    """Manage external App Connector integrations from slash commands."""
-    render_app_payload(console, await build_app_payload(ctx, args))
-
-
-# NOTE: screen clearing is owned by ``LeapApp.clear_screen()``. It must go
-# through the prompt_toolkit renderer that owns the TTY — a shell ``clear``
-# leaves the renderer's cursor cache stale and misplaces the next redraw — so
-# there is deliberately no clear handler here.
-
-
-# ══════════════════════════════════════════════════════════════════════
-# Unified command_execute: dispatches any engine-routed slash command
-# ══════════════════════════════════════════════════════════════════════
-
-
-def build_orient_payload(ctx: "Context") -> dict[str, Any]:
-    """Read-only unified orientation view (S4-D1) + pending re-entry status.
-
-    Surfaces what the agent is currently oriented on (immediate / working /
-    long-term layers, weight-ranked) plus any armed/due re-entry triggers.
-    Observe-only; changes no state.
-    """
-    engine = ctx.engine
-    if engine is None:
-        return {"ok": False, "error": "No active engine — send a message first."}
-    view_fn = getattr(engine, "orientation_view", None)
-    if view_fn is None:
-        return {"ok": False, "error": "Orientation view not available."}
-    orientation = view_fn()
-    lines = ["Orientation (immediate / working / long-term):"]
-    items = orientation.top(12)
-    if not items:
-        lines.append("  (empty — no active findings or open questions yet)")
-    else:
-        lines.extend(f"  - ({it.layer}) {it.text}" for it in items)
-    store = getattr(ctx, "_reentry_store", None)
-    if store is not None:
-        try:
-            import time as _time
-            armed = store.list_armed_events()
-            due = store.list_due(_time.time())
-            lines.append(f"Re-entry: {len(armed)} armed event trigger(s), {len(due)} due now.")
-        except Exception:
-            pass
-    return {
-        "ok": True,
-        "message": "\n".join(lines),
-        "orientation": orientation.summary(),
-    }
-
-
-async def command_execute(
-    ctx: "Context", name: str, args: str = "", session_id: str = "",
-) -> dict[str, Any]:
-    """Execute a slash command and return a serializable result payload.
-
-    This is the unified entry point for daemon-mode command execution.
-    Returns a dict with at minimum ``ok`` and ``message`` keys, plus
-    optional structured data for rich TUI rendering. ``session_id`` identifies
-    the calling client's session for commands that observe it (e.g. ``/board``).
-    """
-    if name == "status":
-        return build_status_payload(ctx)
-    if name == "orient":
-        return build_orient_payload(ctx)
-    if name == "tool":
-        return build_tool_payload(ctx)
-    if name == "usage":
-        return build_usage_payload(ctx)
-    if name == "model":
-        return build_model_payload(ctx, args)
-    if name == "config":
-        return build_config_payload(ctx, args)
-    if name == "gateway":
-        return build_gateway_payload(ctx)
-    if name == "host":
-        return await _execute_host(ctx, args)
-    if _is_app_command_name(name):
-        app_args = name[len("app"):].strip()
-        if app_args:
-            app_args = app_args + (" " + args if args else "")
-        else:
-            app_args = args
-        return await build_app_payload(ctx, app_args)
-    if name.startswith("teach") or name == "annotate":
-        return await _execute_teach(ctx, name, args)
-    if name == "skill" or name.startswith("skill "):
-        return _execute_skill(ctx, name, args)
-    if name.startswith("hub"):
-        return await _execute_hub(ctx, name, args)
-    if name == "run":
-        return {"ok": True, "stream": True, "prompt": args}
-    if name == "arm":
-        return await _execute_scheduler_arm(ctx, args)
-    if name == "task":
-        return _execute_scheduler_task(ctx)
-    if name == "board" or name.startswith("board "):
-        return await _execute_dashboard(ctx, name, args, session_id=session_id)
-    return {"ok": False, "message": f"Unknown command: /{name}"}
-
-
-async def _ensure_session_watch_refresh(
-    ctx: "Context", monitors: Any, session_id: str = "",
-) -> str:
-    """Ensure an active session watch exists and trigger one analysis cycle.
-
-    The analysis producer is LLM-backed and can take tens of seconds, so it is
-    scheduled in the background: arming the watch and opening the board must be
-    instant and must never block the command RPC past its timeout. The board
-    receives the resulting finding over WebSocket when the cycle completes.
-    ``session_id`` binds the watch to the caller's session so the analysis reads
-    that conversation rather than whichever session was last active.
-    Returns the session watch id.
-    """
-    from leapflow.monitor.session_producer import ensure_session_watch, session_watch_params
-
-    params = session_watch_params(getattr(ctx, "settings", None))
-    if session_id:
-        params["session_id"] = session_id
-    watch_id = await ensure_session_watch(monitors, params=params)
-    monitors.schedule_watch_once(watch_id, force=True)
-    return watch_id
-
-
-_BOARD_VERBS = frozenset({"templates", "refresh", "pause", "resume", "stop", "status"})
-
-# States in which a watch can still be paused/resumed/stopped (i.e. not terminal).
-_BOARD_CONTROLLABLE_STATES = frozenset(
-    {"armed", "watching", "due", "confirming", "executing", "suspended"}
-)
-
-
-async def _execute_dashboard(
-    ctx: "Context", name: str, args: str = "", session_id: str = "",
-) -> dict[str, Any]:
-    """Analyze the current session and render it through a template.
-
-    LeapBoard has a single analysis target — the current session. ``/board``
-    opens the default (``generic``) lens; ``/board <template>`` opens a known
-    lens. Reserved verbs manage templates and the session observation. Any other
-    token is an unknown command and is rejected (never silently coerced).
-    """
-    monitors = getattr(ctx, "monitors", None)
-    sub = name.split(" ", 1)[1].strip() if " " in name else ""
-    rest = (sub + ((" " + args) if args else "")).strip() if sub else args.strip()
-    try:
-        tokens = shlex.split(rest) if rest else []
-    except ValueError:
-        tokens = rest.split()
-    verb = tokens[0].lower() if tokens else ""
-    rest_tokens = tokens[1:]
-
-    if verb == "templates":
-        return _execute_board_templates(ctx, rest_tokens)
-    if verb == "status":
-        return _execute_board_status(ctx, monitors)
-    if verb in ("refresh", "pause", "resume", "stop"):
-        return await _execute_board_control(
-            ctx, monitors, verb, target=rest_tokens[0] if rest_tokens else "",
-        )
-    if not verb:
-        return await _execute_board_open(ctx, monitors, template="", session_id=session_id)
-    # A non-empty, non-verb token must name a known template lens; otherwise it
-    # is an unknown command and is rejected rather than coerced to generic.
-    if verb in set(_template_library(ctx).names()):
-        return await _execute_board_open(ctx, monitors, template=verb, session_id=session_id)
-    return {
-        "ok": False,
-        "message": (
-            f"Unknown board command: '{verb}'. Use /board for the session board, "
-            "/board <template> for a lens (see /board templates), or "
-            "/board templates|refresh|pause|resume|stop|status."
-        ),
-    }
-
-
-async def _execute_board_open(
-    ctx: "Context", monitors: Any, *, template: str, session_id: str = "",
-) -> dict[str, Any]:
-    """Open the current-session board rendered with the requested template.
-
-    ``template`` is guaranteed to be empty (default) or a known lens by the
-    dispatcher, so there is no silent fallback here.
-    """
-    session_watch_id = ""
-    if monitors is not None:
-        try:
-            session_watch_id = await _ensure_session_watch_refresh(ctx, monitors, session_id)
-        except Exception:
-            logger.debug("dashboard: session watch refresh failed", exc_info=True)
-    # The client owns the dashboard server lifecycle (it spawns/validates it off
-    # the event loop), so the daemon only conveys the chosen lens here.
-    payload: dict[str, Any] = {
-        "ok": True, "view": "dashboard", "mode": "open", "template": template or "generic",
-    }
-    if session_watch_id:
-        payload["watch_id"] = session_watch_id
-    return payload
-
-
-async def _execute_board_control(
-    ctx: "Context", monitors: Any, verb: str, *, target: str = "",
-) -> dict[str, Any]:
-    """Control a board observation: refresh / pause / resume / stop.
-
-    Without ``target`` the verb applies to the current session watch (``refresh``
-    starts it if absent; the others require an existing one). With ``target`` it
-    applies to the watch whose id — a full id or a unique prefix, as shown by
-    ``/board status`` — matches, so ``/board stop <id>`` stops that watch.
-    """
-    if monitors is None:
-        return {"ok": False, "message": "Monitor runtime is unavailable (scheduler disabled)."}
-
-    if target:
-        watch_id = _resolve_watch_id(monitors, target)
-        if not watch_id:
-            return {"ok": False,
-                    "message": f"No board watch matches '{target}'. Run /board status to see ids."}
-    elif verb == "refresh":
-        from leapflow.monitor.session_producer import ensure_session_watch, session_watch_params
-        watch_id = await ensure_session_watch(
-            monitors, params=session_watch_params(getattr(ctx, "settings", None))
-        )
-    else:
-        watch_id = _find_session_watch_id(monitors)
-        if not watch_id:
-            return {"ok": False,
-                    "message": f"No active session board to {verb}. Run /board to start one."}
-
-    if verb == "refresh":
-        monitors.schedule_watch_once(watch_id, force=True)
-        return {"ok": True, "view": "dashboard", "mode": "control", "action": "refresh",
-                "watch_id": watch_id,
-                "message": "Re-analyzing the current session; the board updates when it completes."}
-
-    method = {"pause": monitors.pause_watch, "resume": monitors.resume_watch,
-              "stop": monitors.stop_watch}[verb]
-    view = method(watch_id)
-    if view is None:
-        return {"ok": False, "message": f"Watch not found: {watch_id[:8]}."}
-    label = view.name or watch_id[:8]
-    messages = {
-        "pause": f"Paused {label}; use /board resume to continue.",
-        "resume": f"Resumed {label}.",
-        "stop": f"Stopped {label}; run /board to start again.",
-    }
-    return {"ok": True, "view": "dashboard", "mode": "control", "action": verb,
-            "watch": view.to_dict(), "message": messages[verb]}
-
-
-def _resolve_watch_id(monitors: Any, target: str) -> str:
-    """Resolve a watch id from an exact id or a unique prefix (as /board status shows)."""
-    target = target.strip()
-    if not target:
-        return ""
-    try:
-        views = list(monitors.list_watches())
-    except Exception:
-        return ""
-    for view in views:
-        if view.watch_id == target:
-            return view.watch_id
-    prefix_matches = [view.watch_id for view in views if view.watch_id.startswith(target)]
-    return prefix_matches[0] if len(prefix_matches) == 1 else ""
-
-
-def _find_session_watch_id(monitors: Any) -> str:
-    """Return the current controllable session watch id, or empty when none is active."""
-    try:
-        views = list(monitors.list_watches())
-    except Exception:
-        return ""
-    for view in views:
-        if view.domain == "session" and view.state in _BOARD_CONTROLLABLE_STATES:
-            return view.watch_id
-    return ""
-
-
-def _execute_board_status(ctx: "Context", monitors: Any) -> dict[str, Any]:
-    """Return session-observation status: watch detail + recent findings + lenses.
-
-    Fields:
-      - ``templates`` / ``default``: available lenses and the default.
-      - ``watches``: every watch with state, run/finding counts, and last-run age.
-      - ``findings``: recent findings (severity, title, summary, age) across watches.
-    """
-    library = _template_library(ctx)
-    data: dict[str, Any] = {
-        "ok": True, "view": "dashboard", "mode": "status",
-        "templates": library.names(), "default": "generic",
-        "watches": [], "findings": [],
-    }
-    if monitors is None:
-        return data
-    try:
-        data["watches"] = [v.to_dict() for v in monitors.list_watches()]
-    except Exception:
-        logger.debug("dashboard: watch list unavailable", exc_info=True)
-    try:
-        data["findings"] = [f.to_dict() for f in monitors.list_findings(limit=20)]
-    except Exception:
-        logger.debug("dashboard: finding list unavailable", exc_info=True)
-    return data
-
-
-def _execute_board_templates(ctx: "Context", rest_tokens: list[str]) -> dict[str, Any]:
-    """Template hub: list / add / remove / show board templates."""
-    from leapflow.dashboard.templates import sanitize_template_id
-
-    library = _template_library(ctx)
-    op = rest_tokens[0].lower() if rest_tokens else "list"
-    args = rest_tokens[1:]
-
-    if op == "list":
-        items = [library.describe(name) or {"name": name} for name in library.names()]
-        return {"ok": True, "view": "dashboard", "mode": "templates",
-                "templates": items, "default": "generic"}
-
-    if op == "add":
-        positional = [t for t in args if not t.startswith("--")]
-        if not positional:
-            return {"ok": False, "message": "Usage: /board templates add <path.yaml> [--name id] [--force]"}
-        requested = _flag_value(args, "--name")
-        candidate = sanitize_template_id(requested or Path(positional[0]).stem)
-        if candidate in _BOARD_VERBS:
-            return {"ok": False, "message": f"'{candidate}' is a reserved board command; choose another --name."}
-        try:
-            installed = library.install(Path(positional[0]), name=requested, force="--force" in args)
-        except ValueError as exc:
-            return {"ok": False, "message": f"Could not add template: {exc}"}
-        return {"ok": True, "view": "dashboard", "mode": "templates", "action": "add",
-                "template": installed,
-                "message": f"Registered template '{installed}'. Open it with /board {installed}."}
-
-    if op == "remove":
-        if not args:
-            return {"ok": False, "message": "Usage: /board templates remove <id>"}
-        if library.source_of(args[0]) == "builtin":
-            return {"ok": False, "message": f"'{args[0]}' is a builtin template and cannot be removed."}
-        removed = library.uninstall(args[0])
-        return {"ok": bool(removed), "view": "dashboard", "mode": "templates", "action": "remove",
-                "message": f"Removed template '{args[0]}'." if removed else f"No custom template '{args[0]}'."}
-
-    if op == "show":
-        if not args:
-            return {"ok": False, "message": "Usage: /board templates show <id>"}
-        info = library.describe(args[0])
-        if info is None:
-            return {"ok": False, "message": f"Template not found: {args[0]}"}
-        return {"ok": True, "view": "dashboard", "mode": "templates", "action": "show", "detail": info}
-
-    return {"ok": False, "message": "Usage: /board templates [list|add|remove|show] ..."}
-
-
-def _template_library(ctx: "Context") -> Any:
-    """Build a TemplateLibrary bound to the profile's custom-template override dir."""
-    from leapflow.dashboard.templates import TemplateLibrary
-
-    override_dir = None
-    settings = getattr(ctx, "settings", None)
-    profile_layout = getattr(settings, "profile_layout", None) if settings is not None else None
-    if profile_layout is not None:
-        try:
-            override_dir = profile_layout.dashboard.templates_dir
-        except Exception:
-            override_dir = None
-    return TemplateLibrary(override_dir=override_dir)
-
-
-def _flag_value(tokens: list[str], flag: str) -> str:
-    """Return the value following ``flag`` in tokens, or '' when absent."""
-    if flag in tokens:
-        idx = tokens.index(flag)
-        if idx + 1 < len(tokens) and not tokens[idx + 1].startswith("--"):
-            return tokens[idx + 1]
-    return ""
-
-
-def _is_app_command_name(name: str) -> bool:
-    return name == "app" or name.startswith("app ")
-
-
-def build_status_payload(ctx: "Context") -> dict[str, Any]:
-    """Build a serializable status summary."""
-    engine = ctx.engine
-    context_length = 0
-    context_used = 0
-    turn_count = 0
-    if engine is not None:
-        cap_registry = getattr(engine, "model_capabilities", None)
-        if cap_registry is not None:
-            caps = cap_registry.resolve(ctx.settings.llm_model)
-            context_length = int(caps.context_length)
-        context_used = int(getattr(engine, "context_token_count", 0))
-        turn_count = int(getattr(engine, "turn_count", 0))
-
-    platform_status = "connected" if (hasattr(ctx.rpc, "connected") and ctx.rpc.connected) else "mock"
-    cwd = os.getcwd().replace(os.path.expanduser("~"), "~")
-
-    from leapflow.engine.session import SessionMode
-    mode = "idle"
-    if ctx.session:
-        if ctx.session.mode == SessionMode.LEARNING:
-            mode = "learning"
-        elif ctx.session.mode == SessionMode.EXECUTING:
-            mode = "executing"
-
-    gateway_connected: list[str] = []
-    gw = getattr(ctx, "gateway_server", None)
-    if gw is not None:
-        statuses = gw.platform_status()
-        for s in statuses:
-            if s.connected:
-                m = gw.manifests.get(s.platform_id)
-                gateway_connected.append(m.display_name if m else s.platform_id)
-
-    return {
-        "ok": True,
-        "view": "status",
-        "model": ctx.settings.llm_model,
-        "context_length": context_length,
-        "context_used": context_used,
-        "turn_count": turn_count,
-        "platform": platform_status,
-        "cwd": cwd,
-        "config_path": str(ctx.settings.profile_layout.config_dir).replace(os.path.expanduser("~"), "~"),
-        "user_config_path": str(ctx.settings.layout.user_config_path).replace(os.path.expanduser("~"), "~"),
-        "workspace_config_path": str(ctx.settings.workspace_root / ".leapflow" / "config.yaml").replace(os.path.expanduser("~"), "~"),
-        "session_id": getattr(ctx.session, "session_id", "") if ctx.session else "",
-        "mode": mode,
-        "gateway_connected": gateway_connected,
-    }
-
-
-def build_gateway_payload(ctx: "Context") -> dict[str, Any]:
-    """Build a serializable gateway status payload."""
-    import time as _time
-
-    gw = getattr(ctx, "gateway_server", None)
-    if gw is None:
-        return {"ok": False, "message": "Gateway not initialised."}
-
-    statuses = gw.platform_status()
-    if not statuses:
-        return {"ok": True, "view": "gateway", "connected": [], "configured": [], "available": []}
-
-    connected = []
-    configured = []
-    available = []
-    for s in statuses:
-        m = gw.manifests.get(s.platform_id)
-        name = m.display_name if m else s.platform_id
-        if s.connected:
-            uptime = ""
-            if s.connected_since > 0:
-                secs = int(_time.time() - s.connected_since)
-                if secs < 60:
-                    uptime = f"{secs}s"
-                elif secs < 3600:
-                    uptime = f"{secs // 60}m"
-                else:
-                    uptime = f"{secs // 3600}h {(secs % 3600) // 60}m"
-            connected.append({"name": name, "id": s.platform_id, "uptime": uptime})
-        elif s.error:
-            configured.append({"name": name, "id": s.platform_id})
-        else:
-            available.append({"name": name, "id": s.platform_id})
-    return {"ok": True, "view": "gateway", "connected": connected, "configured": configured, "available": available}
-
-
-async def _execute_host(ctx: "Context", args: str) -> dict[str, Any]:
-    """Execute /host command."""
-    action = args.strip().lower() if args.strip() else "status"
-    if action not in {"status", "start", "stop", "restart"}:
-        return {"ok": False, "message": "Usage: /host [status|start|stop|restart]"}
-    if action == "status":
-        result = await ctx.host_backend_status()
-    elif action == "start":
-        result = await ctx.host_backend_start()
-    elif action == "stop":
-        result = await ctx.host_backend_stop()
-    else:
-        result = await ctx.host_backend_restart()
-    return {"ok": True, "view": "host", "action": action, "result": result}
-
-
-async def _distill_background(session) -> None:
-    """Run distillation in background without blocking the RPC response."""
-    import logging
-    _log = logging.getLogger(__name__)
-    try:
-        final = await session.await_learning()
-        if final and final.candidates:
-            _log.info(
-                "background_distill: %d candidates, activated=%s",
-                len(final.candidates),
-                final.activated_skill_names or [],
-            )
-        else:
-            _log.info("background_distill: no candidates produced")
-    except Exception:
-        _log.warning("background_distill failed", exc_info=True)
-
-
-async def _execute_teach(ctx: "Context", name: str, args: str) -> dict[str, Any]:
-    """Execute teach commands.
-
-    Returns ``session_mode`` in the payload so the TUI client can track
-    whether it should route subsequent inputs as annotations.
-    """
-    from leapflow.engine.session import SessionMode
-
-    full_cmd = name + (" " + args if args else "")
-    if full_cmd in ("teach start", "teach") or full_cmd.startswith("teach start "):
-        if ctx.session is None:
-            return {"ok": False, "message": "No active session.", "session_mode": "idle"}
-        if ctx.session.mode == SessionMode.LEARNING:
-            return {"ok": False, "message": "Already in teaching mode. Say '/teach stop' to end.", "session_mode": "learning"}
-        goal = args if name == "teach start" else ""
-        try:
-            session = await ctx.session.enter_learning(goal=goal)
-            msg = f"Teaching started — session {session.session_id}"
-            if goal:
-                msg += f"\nGoal: {goal}"
-            msg += "\nCommands: /teach stop │ /teach discard │ /teach pause │ /teach resume │ /teach skip [n] │ /annotate <text>"
-            return {"ok": True, "message": msg, "session_mode": "learning"}
-        except Exception as e:
-            return {"ok": False, "message": str(e)}
-
-    if name == "teach stop":
-        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
-            return {"ok": False, "message": "Not in teaching mode.", "session_mode": "idle"}
-        try:
-            result = await ctx.session.exit_learning()
-            msg = f"Recording stopped — {result.step_count} steps, {result.duration:.1f}s"
-            if result.step_count == 0:
-                msg += "\nNo steps recorded — nothing to distill."
-            elif not getattr(ctx.settings, "has_llm_credentials", False):
-                msg += "\nNo LLM credentials — distillation skipped."
-            elif ctx.session.has_pending_distillation:
-                import asyncio
-                asyncio.create_task(_distill_background(ctx.session))
-                msg += "\nDistillation started in background."
-            else:
-                report = getattr(result, "learnability_report", None)
-                reason = getattr(report, "reason", "assessment decided to skip") if report else "auto-learn disabled"
-                msg += f"\nDistillation skipped: {reason}"
-            return {
-                "ok": True,
-                "message": msg,
-                "step_count": result.step_count,
-                "duration": result.duration,
-                "session_mode": "idle",
-            }
-        except Exception as e:
-            return {"ok": False, "message": str(e), "session_mode": "idle"}
-
-    if name == "teach pause":
-        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
-            return {"ok": False, "message": "Not in teaching mode."}
-        ctx.session.pause_learning()
-        return {"ok": True, "message": "Teaching paused.", "session_mode": "paused"}
-
-    if name == "teach resume":
-        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
-            return {"ok": False, "message": "Not in teaching mode."}
-        ctx.session.resume_learning()
-        return {"ok": True, "message": "Teaching resumed.", "session_mode": "learning"}
-
-    if name == "teach discard":
-        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
-            return {"ok": False, "message": "Not in teaching mode."}
-        ctx.session.discard_learning()
-        return {"ok": True, "message": "Recording discarded.", "session_mode": "idle"}
-
-    if name == "teach skip":
-        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
-            return {"ok": False, "message": "Not in teaching mode."}
-        n = 1
-        if args.strip().isdigit():
-            n = int(args.strip())
-        ctx.session.skip_steps(n)
-        return {"ok": True, "message": f"Marked last {n} step(s) as noise.", "session_mode": "learning"}
-
-    if name == "annotate":
-        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
-            return {"ok": False, "message": "Not in teaching mode."}
-        if not args.strip():
-            return {"ok": False, "message": "Usage: /annotate <text>"}
-        ctx.session.annotate(args.strip())
-        return {"ok": True, "message": f"Annotation recorded: {args.strip()}", "session_mode": "learning"}
-
-    if name == "teach status":
-        if not ctx.session:
-            return {"ok": True, "message": "No active session.", "session_mode": "idle"}
-        mode = ctx.session.mode.value
-        result_payload: dict[str, Any] = {"ok": True, "session_mode": mode}
-        if mode == "evolving" or ctx.session.is_distilling:
-            result_payload["message"] = "Distillation in progress…"
-            result_payload["distilling"] = True
-        elif mode == "learning":
-            step_count = ctx.session.recording_step_count
-            result_payload["message"] = f"Recording — {step_count} steps captured."
-            result_payload["step_count"] = step_count
-        else:
-            last = ctx.session.last_result
-            if last:
-                candidates = getattr(last, "candidates", None) or []
-                new_skills = getattr(last, "new_skills", None) or []
-                result_payload["message"] = (
-                    f"Idle. Last result: {last.step_count} steps, "
-                    f"{len(candidates)} candidates, "
-                    f"{len(new_skills)} activated."
-                )
-            else:
-                result_payload["message"] = "Idle. No previous distillation results."
-        return result_payload
-
-    return {"ok": False, "message": f"Unknown teach command: /{full_cmd}"}
-
-
-def _execute_skill(ctx: "Context", name: str, args: str) -> dict[str, Any]:
-    """Execute skill commands."""
-    full_cmd = name + (" " + args if args else "")
-    if full_cmd in ("skill", "skill list"):
-        skills = ctx.registry.list_all() if ctx.registry else []
-        if not skills:
-            return {"ok": True, "view": "skill_list", "skills": []}
-        entries = []
-        for s in skills:
-            m = s.metadata
-            entries.append({
-                "name": s.name,
-                "version": m.version,
-                "confidence": m.confidence,
-                "description": s.description[:80],
-            })
-        return {"ok": True, "view": "skill_list", "skills": entries}
-
-    if name == "skill show":
-        skill_name = args.strip()
-        if not skill_name:
-            return {"ok": False, "message": "Usage: /skill show <name>"}
-        skill = ctx.registry.get(skill_name) if ctx.registry else None
-        if skill is None:
-            return {"ok": False, "message": f"Skill '{skill_name}' not found."}
-        m = skill.metadata
-        return {
-            "ok": True,
-            "view": "skill_show",
-            "name": skill.name,
-            "description": skill.description,
-            "version": m.version,
-            "confidence": m.confidence,
-            "triggers": list(skill.triggers) if skill.triggers else [],
-        }
-
-    if name == "skill disable":
-        skill_name = args.strip()
-        if not skill_name:
-            return {"ok": False, "message": "Usage: /skill disable <name>"}
-        found = False
-        if ctx.skill_lib and ctx.skill_lib.deactivate_parameterized(skill_name):
-            found = True
-        if ctx.registry and ctx.registry.unregister(skill_name):
-            found = True
-        if found:
-            return {"ok": True, "message": f"Skill '{skill_name}' disabled."}
-        return {"ok": False, "message": f"Skill '{skill_name}' not found."}
-
-    if name == "skill delete":
-        skill_name = args.strip()
-        if not skill_name:
-            return {"ok": False, "message": "Usage: /skill delete <name>"}
-        found = False
-        if ctx.skill_lib:
-            stored = ctx.skill_lib.load_skill_by_title(skill_name)
-            if stored:
-                stored.status = "deleted"
-                ctx.skill_lib.update_skill(stored)
-                found = True
-        if ctx.registry and ctx.registry.unregister(skill_name):
-            found = True
-        if found:
-            return {"ok": True, "message": f"Skill '{skill_name}' deleted."}
-        return {"ok": False, "message": f"Skill '{skill_name}' not found."}
-
-    return {"ok": False, "message": f"Unknown skill command: /{full_cmd}"}
-
-
-async def _execute_hub(ctx: "Context", name: str, args: str) -> dict[str, Any]:
-    """Execute hub commands."""
-    try:
-        from leapflow.cli.commands.hub import cmd_hub_payload
-        return await cmd_hub_payload(ctx, name, args)
-    except ImportError:
-        pass
-    # Fallback: basic hub dispatch
-    sub = name[len("hub"):].strip() if name.startswith("hub") else ""
-    if not sub:
-        sub = args.split()[0] if args.split() else ""
-        args = " ".join(args.split()[1:])
-    command_parts = ["/hub"]
-    if sub:
-        command_parts.append(sub)
-    if args:
-        command_parts.append(args)
-    command = " ".join(command_parts)
-    return {"ok": False, "message": f"Hub command '{command}' is not yet implemented in this runtime."}
-
-
-def _execute_scheduler_task(ctx: "Context") -> dict[str, Any]:
-    """Execute /task command."""
-    scheduler = getattr(ctx, "scheduler", None)
-    if scheduler is None:
-        return {"ok": True, "view": "task", "tasks": [], "message": "No scheduler active."}
-    tasks = scheduler.list_tasks() if hasattr(scheduler, "list_tasks") else []
-    entries = [
-        {"name": t.name, "schedule": t.schedule, "next_run": str(getattr(t, "next_run", ""))}
-        for t in tasks
-    ]
-    return {"ok": True, "view": "task", "tasks": entries}
-
-
-async def _execute_scheduler_arm(ctx: "Context", args: str) -> dict[str, Any]:
-    """Execute /arm command."""
-    scheduler = getattr(ctx, "scheduler", None)
-    if scheduler is None:
-        return {"ok": False, "message": "Scheduler not active in this session."}
-    tokens = args.strip().split(None, 1)
-    if len(tokens) < 2:
-        return {"ok": False, "message": "Usage: /arm <skill> <cron>"}
-    skill_name, cron_expr = tokens
-    try:
-        task_id = await scheduler.arm(skill_name, cron_expr)
-        return {"ok": True, "message": f"Armed: {skill_name} → {cron_expr} (id={task_id})"}
-    except Exception as e:
-        return {"ok": False, "message": str(e)}
-
-
-def render_command_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    """Render a generic command_execute result payload in the TUI."""
-    if not payload.get("ok"):
-        console.warning(str(payload.get("message") or payload.get("error") or "Command failed."))
-        return
-
-    view = str(payload.get("view") or "")
-
-    if view == "status":
-        _render_status_view(console, payload)
-        return
-    if view == "model":
-        render_model_payload(console, payload)
-        return
-    if view == "config":
-        render_config_payload(console, payload)
-        return
-    if view == "gateway":
-        _render_gateway_view(console, payload)
-        return
-    if view == "host":
-        _render_host_view(console, payload)
-        return
-    if view == "skill_list":
-        _render_skill_list_view(console, payload)
-        return
-    if view == "skill_show":
-        _render_skill_show_view(console, payload)
-        return
-    if view == "task":
-        _render_task_view(console, payload)
-        return
-    if view == "dashboard":
-        _render_dashboard_view(console, payload)
-        return
-
-    msg = payload.get("message")
-    if msg:
-        console.success(str(msg))
-
-
-def _ago(ts: Any) -> str:
-    """Format an epoch timestamp as a compact relative age (e.g. '2m ago')."""
-    import time
-
-    try:
-        value = float(ts or 0)
-    except (TypeError, ValueError):
-        return ""
-    if value <= 0:
-        return "never"
-    delta = max(0, int(time.time() - value))
-    if delta < 60:
-        return f"{delta}s ago"
-    if delta < 3600:
-        return f"{delta // 60}m ago"
-    if delta < 86400:
-        return f"{delta // 3600}h ago"
-    return f"{delta // 86400}d ago"
-
-
-def _board_page_url() -> str:
-    """Best-effort token-scoped URL of the running board page, or '' when none.
-
-    The client owns the dashboard server, so the status renderer resolves the
-    live URL here (from discovery state) for users to copy; any failure or a
-    not-running server yields an empty string rather than raising.
-    """
-    try:
-        from leapflow.config import get_settings
-        from leapflow.dashboard import launcher
-
-        state = launcher.server_running(get_settings())
-        if not state:
-            return ""
-        return launcher.build_view_url(state["bind"], state["port"], state["token"])
-    except Exception:
-        logger.debug("dashboard: board page url lookup failed", exc_info=True)
-        return ""
-
-
-def _render_dashboard_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    from rich.table import Table
-
-    mode = str(payload.get("mode") or "")
-
-    if mode == "open":
-        # In the REPLs the browser is launched separately; this is a defensive
-        # text fallback for non-interactive callers.
-        url = payload.get("url")
-        if url:
-            console.system(f"Opening board: {url}")
-        elif payload.get("running"):
-            console.system("Dashboard is running.")
-        else:
-            console.system(str(payload.get("hint") or "Run `leap board` to open the web view."))
-        return
-
-    if mode == "control":
-        console.success(str(payload.get("message") or payload.get("action") or "done"))
-        return
-
-    if mode == "status":
-        templates = payload.get("templates") or []
-        console.system(
-            f"Templates: {', '.join(templates) or '-'} (default: {payload.get('default', 'generic')})"
-        )
-        watches = payload.get("watches") or []
-        if watches:
-            board_url = _board_page_url()
-            table = Table(title="Watches", title_style="bold cyan", border_style="bright_black")
-            for col in ("id", "name", "domain", "state", "runs", "findings", "last run"):
-                table.add_column(col)
-            # Full token URL of the board page, kept whole (folded, never cropped)
-            # so users can copy it straight from the table.
-            table.add_column("url", overflow="fold")
-            for w in watches:
-                table.add_row(
-                    str(w.get("watch_id", ""))[:8],
-                    str(w.get("name", "")),
-                    str(w.get("domain", "")),
-                    str(w.get("state", "")),
-                    str(w.get("run_count", 0)),
-                    str(w.get("finding_count", 0)),
-                    _ago(w.get("last_run_at", 0)),
-                    board_url,
-                )
-            console.print(table)
-        else:
-            console.system("Watches: none active — run /board to start session analysis.")
-        findings = payload.get("findings") or []
-        if findings:
-            console.system(f"Recent findings ({len(findings)}):")
-            markers = {"alert": "!!", "notable": " *", "info": " -"}
-            for f in findings[:20]:
-                sev = str(f.get("severity", "info"))
-                line = f"  {markers.get(sev, ' -')} [{sev}] {str(f.get('title', ''))}"
-                summary = str(f.get("summary", ""))
-                if summary:
-                    line += f" \u2014 {summary}"
-                age = _ago(f.get("ts", 0))
-                if age:
-                    line += f"  ({age})"
-                console.system(line)
-        else:
-            console.system("Findings: none yet.")
-        return
-
-    if mode == "templates":
-        action = str(payload.get("action") or "list")
-        if action == "list":
-            items = payload.get("templates") or []
-            if not items:
-                console.system("No templates available.")
-                return
-            table = Table(title="Templates", title_style="bold cyan", border_style="bright_black")
-            for col in ("name", "source", "title"):
-                table.add_column(col)
-            for item in items:
-                table.add_row(
-                    str(item.get("name", "")),
-                    str(item.get("source", "")),
-                    str(item.get("title", "")),
-                )
-            console.print(table)
-            return
-        if action == "show":
-            detail = payload.get("detail") or {}
-            console.system(
-                f"{detail.get('name')} [{detail.get('source')}] — {detail.get('title')}"
-            )
-            if detail.get("description"):
-                console.system(str(detail["description"]))
-            return
-        # add / remove success
-        console.success(str(payload.get("message") or "done"))
-        return
-
-    message = payload.get("message")
-    if message:
-        console.system(str(message))
-
-
-def _render_status_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    from rich.panel import Panel
-    from rich.text import Text
-
-    info = Text()
-    info.append("Model:     ", style="dim")
-    info.append(f"{payload.get('model')}\n", style="bold")
-
-    ctx_len = int(payload.get("context_length") or 0)
-    ctx_used = int(payload.get("context_used") or 0)
-    turn_count = int(payload.get("turn_count") or 0)
-    if ctx_len:
-        pct = int(ctx_used * 100 / ctx_len) if ctx_len else 0
-        info.append("Context:   ", style="dim")
-        pct_style = "bold red" if pct >= 90 else ("yellow" if pct >= 75 else "")
-        info.append(f"{ctx_used:,} / {ctx_len:,} ({pct}%)\n", style=pct_style)
-    info.append("Turns:     ", style="dim")
-    info.append(f"{turn_count}\n")
-    info.append("Platform:  ", style="dim")
-    p_status = str(payload.get("platform") or "")
-    p_style = "green" if p_status == "connected" else "dim"
-    info.append(f"{p_status}\n", style=p_style)
-    info.append("CWD:       ", style="dim")
-    info.append(f"{payload.get('cwd')}\n")
-    info.append("Config:    ", style="dim")
-    info.append(f"{payload.get('config_path')}\n")
-    session_id = payload.get("session_id")
-    if session_id:
-        info.append("Session:   ", style="dim")
-        info.append(f"{session_id}\n")
-    info.append("Mode:      ", style="dim")
-    info.append(f"{payload.get('mode')}\n")
-    gw = payload.get("gateway_connected") or []
-    if gw:
-        info.append("Gateway:   ", style="dim")
-        info.append(f"{', '.join(gw)}\n", style="green")
-
-    console.print(Panel(info, title="[bold cyan]LeapFlow Status[/]", border_style="bright_black", padding=(0, 2)))
-
-
-def _render_gateway_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    from rich.panel import Panel
-    from rich.text import Text
-
-    info = Text()
-    connected = payload.get("connected") or []
-    configured = payload.get("configured") or []
-    available = payload.get("available") or []
-
-    if connected:
-        info.append("Connected\n", style="bold green")
-        for entry in connected:
-            uptime = f" ({entry['uptime']})" if entry.get("uptime") else ""
-            info.append(f"  ● {entry['name']}{uptime}\n", style="green")
-    if configured:
-        info.append("Configured (not connected)\n", style="bold yellow")
-        for entry in configured:
-            info.append(f"  ○ {entry['name']}\n", style="yellow")
-    if available:
-        info.append("Available\n", style="bold dim")
-        names = [entry["name"] for entry in available]
-        info.append(f"  {', '.join(names)}\n", style="dim")
-    info.append("\n", style="dim")
-    info.append('Say "connect to <platform>" to set up a new integration.', style="dim italic")
-    console.print(Panel(info, title="[bold cyan]Gateway[/]", border_style="bright_black", padding=(0, 2)))
-
-
-def _render_host_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    result = payload.get("result") or {}
-    action = payload.get("action") or "status"
-    if action != "status":
-        console.success(f"Host {action} completed.")
-    lines = []
-    for key in ("status", "backend", "pid", "session_id"):
-        if key in result:
-            lines.append(f"  {key}: {result[key]}")
-    if lines:
-        console.system("\n".join(lines))
-
-
-def _render_skill_list_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    from rich.table import Table
-
-    skills = payload.get("skills") or []
-    if not skills:
-        console.system("No skills registered.")
-        return
-    table = Table(show_header=True, header_style="bold", border_style="dim")
-    table.add_column("Name", style="cyan", max_width=30)
-    table.add_column("Version", justify="center")
-    table.add_column("Confidence", justify="center")
-    table.add_column("Description", max_width=40)
-    for s in skills:
-        table.add_row(
-            str(s.get("name") or ""),
-            f"v{s.get('version', 0)}",
-            f"{float(s.get('confidence') or 0):.0%}",
-            str(s.get("description") or "")[:40],
-        )
-    console.print(table)
-
-
-def _render_skill_show_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    from rich.panel import Panel
-    from rich.text import Text
-
-    info = Text()
-    info.append(f"Name:        {payload.get('name')}\n")
-    info.append(f"Description: {payload.get('description')}\n")
-    info.append(f"Version:     v{payload.get('version', 0)}\n")
-    info.append(f"Confidence:  {float(payload.get('confidence') or 0):.0%}\n")
-    triggers = payload.get("triggers") or []
-    if triggers:
-        info.append(f"Triggers:    {', '.join(triggers)}")
-    console.print(Panel(info, title=str(payload.get("name") or "Skill"), border_style="cyan"))
-
-
-def _render_task_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    tasks = payload.get("tasks") or []
-    msg = payload.get("message")
-    if msg:
-        console.system(str(msg))
-        return
-    if not tasks:
-        console.system("No scheduled tasks.")
-        return
-    from rich.table import Table
-    table = Table(show_header=True, header_style="bold", border_style="dim")
-    table.add_column("Name", style="cyan")
-    table.add_column("Schedule")
-    table.add_column("Next Run")
-    for t in tasks:
-        table.add_row(str(t.get("name") or ""), str(t.get("schedule") or ""), str(t.get("next_run") or ""))
-    console.print(table)
+"""Slash-command handler implementations.
+
+Each handler follows the signature ``(ctx, console, args) -> None``.
+All display logic uses ``LeapConsole`` for consistent theming.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import shlex
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from leapflow.cli.context import Context
+    from leapflow.cli.tui_app.console import LeapConsole
+
+
+logger = logging.getLogger(__name__)
+
+
+def build_tool_payload(ctx: "Context") -> dict[str, Any]:
+    """Build a serializable tool summary for local or daemon rendering."""
+    from leapflow.cli.banner import _categorize_tools
+    from leapflow.tools.registry_bootstrap import TOOL_DEFINITIONS
+
+    tool_groups = _categorize_tools(TOOL_DEFINITIONS)
+    groups = {category: sorted(names) for category, names in tool_groups.items()}
+    mcp_count = 0
+    if hasattr(ctx.rpc, "connected") and ctx.rpc.connected:
+        mcp_count = len(getattr(ctx, "platform_tools", []))
+    return {
+        "ok": True,
+        "groups": groups,
+        "total": sum(len(names) for names in groups.values()),
+        "mcp_count": mcp_count,
+    }
+
+
+def render_tool_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    """Render a serializable tool summary."""
+    from rich.table import Table
+
+    if not payload.get("ok", True):
+        console.warning(str(payload.get("error") or "Tools are not available."))
+        return
+
+    groups = dict(payload.get("groups") or {})
+    table = Table(
+        title="Available Tools",
+        show_header=True,
+        header_style="bold",
+        border_style="bright_black",
+        title_style="bold cyan",
+        padding=(0, 1),
+    )
+    table.add_column("Category", style="cyan", no_wrap=True)
+    table.add_column("Tools")
+
+    for category, names in groups.items():
+        table.add_row(str(category), ", ".join(sorted(str(name) for name in names)))
+
+    mcp_count = int(payload.get("mcp_count") or 0)
+    if mcp_count > 0:
+        table.add_row("mcp", f"{mcp_count} platform tools")
+
+    console.print(table)
+    console.system(f"{int(payload.get('total') or 0)} tools available")
+
+
+def build_usage_payload(ctx: "Context") -> dict[str, Any]:
+    """Build a serializable token usage summary."""
+    engine = ctx.engine
+    if engine is None:
+        return {"ok": False, "error": "No active engine — send a message first."}
+
+    tracker = getattr(engine, "usage_tracker", None)
+    if tracker is None:
+        return {"ok": False, "error": "Usage tracking not available."}
+
+    summary = tracker.summary()
+    cap_registry = getattr(engine, "model_capabilities", None)
+    context_length = 0
+    if cap_registry is not None:
+        caps = cap_registry.resolve(ctx.settings.llm_model)
+        context_length = int(caps.context_length)
+
+    return {
+        "ok": True,
+        "model": ctx.settings.llm_model,
+        "prompt_tokens": int(summary.prompt_tokens),
+        "completion_tokens": int(summary.completion_tokens),
+        "total_tokens": int(summary.total_tokens),
+        "turn_count": int(getattr(engine, "turn_count", 0)),
+        "context_used": int(getattr(engine, "context_token_count", 0)),
+        "context_length": context_length,
+    }
+
+
+def render_usage_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    """Render a serializable token usage summary."""
+    from leapflow.cli.tui_app.status import _compact_tokens
+
+    if not payload.get("ok", True):
+        console.warning(str(payload.get("error") or "Usage tracking not available."))
+        return
+
+    console.print()
+    prompt_tokens = int(payload.get("prompt_tokens") or 0)
+    completion_tokens = int(payload.get("completion_tokens") or 0)
+    total_tokens = int(payload.get("total_tokens") or 0)
+    turn_count = int(payload.get("turn_count") or 0)
+    context_used = int(payload.get("context_used") or 0)
+    context_length = int(payload.get("context_length") or 0)
+    lines = [
+        f"  Model:           {payload.get('model') or ''}",
+        f"  Input tokens:    {_compact_tokens(prompt_tokens):>8}  ({prompt_tokens:,})",
+        f"  Output tokens:   {_compact_tokens(completion_tokens):>8}  ({completion_tokens:,})",
+        f"  Total tokens:    {_compact_tokens(total_tokens):>8}  ({total_tokens:,})",
+        f"  Turns:           {turn_count}",
+    ]
+    if context_length > 0:
+        pct = int(context_used * 100 / context_length)
+        lines.append(
+            f"  Context:         {_compact_tokens(context_used)}/{_compact_tokens(context_length)} ({pct}%)"
+        )
+    for line in lines:
+        console.system(line)
+    console.print()
+
+
+def build_model_payload(ctx: "Context", args: str = "") -> dict[str, Any]:
+    """Build a serializable model summary or update the active model."""
+    model_arg = args.strip()
+    if model_arg:
+        payload = build_config_payload(ctx, f"llm set --model {shlex.quote(model_arg)}")
+        payload["view"] = "model"
+        payload["requested_model"] = model_arg
+        return payload
+
+    engine = ctx.engine
+    context_length = 0
+    if engine is not None:
+        cap_registry = getattr(engine, "model_capabilities", None)
+        if cap_registry is not None:
+            caps = cap_registry.resolve(ctx.settings.llm_model)
+            context_length = int(caps.context_length)
+    return {
+        "ok": True,
+        "view": "model",
+        "model": ctx.settings.llm_model,
+        "context_length": context_length,
+        "requested_model": "",
+    }
+
+
+def render_model_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    """Render a serializable model summary."""
+    if not payload.get("ok", True):
+        console.warning(str(payload.get("error") or payload.get("message") or "Model information is not available."))
+        return
+    requested = str(payload.get("requested_model") or "")
+    model = str(payload.get("model") or "")
+    if requested:
+        console.success(f"Model updated: {model}")
+        if payload.get("reloaded"):
+            console.system("Configuration reloaded for this session.")
+        return
+
+    console.system(f"Current model: {model}")
+    context_length = int(payload.get("context_length") or 0)
+    if context_length > 0:
+        console.system(f"Context length: {context_length:,}")
+
+
+def build_config_payload(ctx: "Context", args: str = "") -> dict[str, Any]:
+    """Execute a config command and return a serializable payload."""
+    from leapflow.config_service import ConfigService
+
+    service = ConfigService(ctx.settings)
+    try:
+        from leapflow.utils.shell_lex import split_args
+
+        tokens = split_args(args)
+    except ValueError as exc:
+        return {"ok": False, "message": f"Invalid /config syntax: {exc}"}
+    if not tokens:
+        tokens = ["show"]
+    action = tokens[0]
+    try:
+        if action == "show":
+            if len(tokens) > 1:
+                return {
+                    "ok": True,
+                    "view": "config",
+                    "mode": "show_detail",
+                    "field": _config_field_to_dict(service.describe(tokens[1])),
+                }
+            return _config_snapshot_payload(service)
+        if action == "keys":
+            return {"ok": True, "view": "config", "mode": "keys", "sources": list(service.writable_keys())}
+        if action == "list":
+            category = tokens[1] if len(tokens) > 1 and not tokens[1].startswith("--") else None
+            return {"ok": True, "view": "config", "mode": "list", "fields": [_config_field_to_dict(item) for item in service.list_fields(category)]}
+        if action == "sources":
+            return {"ok": True, "view": "config", "mode": "sources", "sources": list(service.sources())}
+        if action == "get" and len(tokens) == 2:
+            value = service.get(tokens[1])
+            return {"ok": True, "view": "config", "mode": "get", "values": [_config_value_to_dict(value)]}
+        if action == "set" and len(tokens) >= 3:
+            scope = _option_value(tokens[3:], "--scope", "profile")
+            result = service.set(tokens[1], tokens[2], scope=scope)  # type: ignore[arg-type]
+            return _config_mutation_payload(ctx, service, result)
+        if action == "unset" and len(tokens) >= 2:
+            scope = _option_value(tokens[2:], "--scope", "profile")
+            result = service.unset(tokens[1], scope=scope)  # type: ignore[arg-type]
+            return _config_mutation_payload(ctx, service, result)
+        if action == "llm":
+            return _build_llm_config_payload(ctx, service, tokens[1:])
+        if action == "secret":
+            return _build_secret_config_payload(ctx, service, tokens[1:])
+    except (KeyError, ValueError, RuntimeError) as exc:
+        return {"ok": False, "message": f"Config error: {exc}"}
+    return {"ok": False, "message": "Usage: /config [show|list|keys|sources|get|set|unset|llm|secret] ..."}
+
+
+_CONFIG_LIST_COMPACT_WIDTH = 92
+_CONFIG_LIST_FULL_WIDTH = 118
+
+
+def _display_width(console: object, default: int = 100) -> int:
+    """Return the active Rich console width with a safe fallback for tests."""
+    width = getattr(console, "width", None)
+    if isinstance(width, int) and width > 0:
+        return width
+    raw = getattr(console, "raw", None)
+    raw_width = getattr(raw, "width", None)
+    if isinstance(raw_width, int) and raw_width > 0:
+        return raw_width
+    return default
+
+
+def _shorten(text: object, limit: int) -> str:
+    """Shorten a cell value before Rich allocates table columns."""
+    value = str(text) if text is not None else ""
+    if limit <= 0:
+        return ""
+    if len(value) <= limit:
+        return value
+    return value[: max(1, limit - 1)] + "…"
+
+
+def _config_scope_text(item: dict[str, Any], *, limit: int) -> str:
+    scopes = ",".join(str(scope) for scope in item.get("scopes") or [])
+    return _shorten(scopes, limit)
+
+
+def _config_reload_text(item: dict[str, Any]) -> str:
+    value = item.get("hot_reload")
+    if isinstance(value, bool):
+        return "yes" if value else "no"
+    return str(value) if value is not None and str(value) else "no"
+
+
+def _config_meta_text(item: dict[str, Any], *, scope_limit: int) -> str:
+    parts = [str(item.get("type") or "?")]
+    scope = _config_scope_text(item, limit=scope_limit)
+    if scope:
+        parts.append(scope)
+    parts.append(f"reload:{_config_reload_text(item)}")
+    return " · ".join(parts)
+
+
+def _build_config_list_table(console: object, fields: list[dict[str, Any]]) -> object:
+    """Build a width-aware config list table for TUI rendering."""
+    from rich.table import Table
+
+    width = _display_width(console)
+    table = Table(title="Writable config fields", show_lines=False, expand=True)
+    if width < _CONFIG_LIST_COMPACT_WIDTH:
+        table.add_column("Key", no_wrap=True, overflow="ellipsis", max_width=32, ratio=2)
+        table.add_column("Value", overflow="fold", max_width=24, ratio=1)
+        table.add_column("Meta", overflow="fold", max_width=24, ratio=1)
+        for item in fields:
+            table.add_row(
+                _shorten(item.get("key"), 36),
+                _shorten(item.get("value"), 32),
+                _config_meta_text(item, scope_limit=14),
+            )
+        return table
+
+    if width < _CONFIG_LIST_FULL_WIDTH:
+        table.add_column("Key", no_wrap=True, overflow="ellipsis", max_width=34, ratio=2)
+        table.add_column("Value", overflow="fold", max_width=30, ratio=1)
+        table.add_column("Type", no_wrap=True, max_width=8)
+        table.add_column("Scope", no_wrap=True, overflow="ellipsis", max_width=18)
+        table.add_column("Reload", no_wrap=True, max_width=6)
+        for item in fields:
+            table.add_row(
+                _shorten(item.get("key"), 38),
+                _shorten(item.get("value"), 40),
+                str(item.get("type") or ""),
+                _config_scope_text(item, limit=18),
+                _config_reload_text(item),
+            )
+        return table
+
+    table.add_column("Key", no_wrap=True, overflow="ellipsis", max_width=36, ratio=2)
+    table.add_column("Value", overflow="fold", max_width=36, ratio=1)
+    table.add_column("Type", no_wrap=True, max_width=10)
+    table.add_column("Scope", no_wrap=True, overflow="ellipsis", max_width=22)
+    table.add_column("Reload", no_wrap=True, max_width=6)
+    table.add_column("Description", overflow="fold", ratio=2)
+    for item in fields:
+        table.add_row(
+            _shorten(item.get("key"), 42),
+            _shorten(item.get("value"), 48),
+            str(item.get("type") or ""),
+            _config_scope_text(item, limit=22),
+            _config_reload_text(item),
+            str(item.get("description") or ""),
+        )
+    return table
+
+
+def render_config_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    """Render config command output."""
+    if not payload.get("ok", True):
+        console.warning(str(payload.get("message") or "Config command failed."))
+        return
+    mode = str(payload.get("mode") or "show")
+    if mode in {"sources", "keys"}:
+        label = "Writable config keys" if mode == "keys" else "Config sources"
+        sources = [str(source) for source in payload.get("sources") or []]
+        if not sources:
+            console.system(f"No {label.lower()} found.")
+            return
+        console.system(f"{label}:")
+        for source in sources:
+            console.system(f"  {source}")
+        return
+    if mode == "list":
+        fields = [dict(item) for item in payload.get("fields") or []]
+        if not fields:
+            console.system("No writable config fields found.")
+            return
+        console.print(_build_config_list_table(console, fields))
+        console.system("Use /config show <key>, /config get <key>, /config set <key> <value>, or /config keys for compact output.")
+        return
+    if mode == "show_detail":
+        field = dict(payload.get("field") or {})
+        if not field:
+            console.warning("No config field details found.")
+            return
+        from rich.panel import Panel
+        from rich.text import Text
+
+        details = Text()
+        details.append(f"value: {field.get('value') or ''}\n")
+        details.append(f"type: {field.get('type') or ''}\n")
+        details.append(f"category: {field.get('category') or ''}\n")
+        details.append(f"scope: {','.join(str(scope) for scope in field.get('scopes') or [])}\n")
+        details.append(f"reload: {field.get('hot_reload') or ''}\n")
+        details.append(f"secret: {'true' if field.get('secret') else 'false'}\n")
+        value_hint = str(field.get("value_hint") or "")
+        if value_hint:
+            details.append(f"value hint: {value_hint}\n")
+        details.append(f"description: {field.get('description') or ''}")
+        examples = [str(example) for example in field.get("examples") or []]
+        if examples:
+            details.append(f"\nexample: {examples[0]}")
+        console.print(Panel(details, title=str(field.get("key") or "Config field"), border_style="cyan"))
+        return
+    if mode == "mutation":
+        console.success(str(payload.get("message") or "Config updated."))
+        for key in payload.get("changed_keys") or []:
+            console.system(f"  {key}")
+        warnings = payload.get("warnings") or []
+        for warning in warnings:
+            console.warning(str(warning))
+        if payload.get("reloaded"):
+            console.system("Configuration reloaded for this session.")
+        return
+    values = payload.get("values") or []
+    if values:
+        for item in values:
+            console.system(f"{item.get('key')}={item.get('value')}")
+    warnings = payload.get("warnings") or []
+    for warning in warnings:
+        console.warning(str(warning))
+
+
+def _config_snapshot_payload(service: Any) -> dict[str, Any]:
+    snapshot = service.snapshot()
+    return {
+        "ok": True,
+        "view": "config",
+        "mode": "show",
+        "values": [_config_value_to_dict(value) for value in snapshot.values],
+        "sources": list(snapshot.sources),
+        "warnings": list(snapshot.warnings),
+    }
+
+
+def _config_value_to_dict(value: Any) -> dict[str, Any]:
+    return {"key": value.key, "value": value.value, "source": value.source, "secret": value.secret}
+
+
+def _config_field_to_dict(value: Any) -> dict[str, Any]:
+    return {
+        "key": value.key,
+        "value": value.value,
+        "type": value.value_type,
+        "category": value.category,
+        "scopes": list(value.scopes),
+        "hot_reload": value.hot_reload,
+        "secret": value.secret,
+        "description": value.description,
+        "value_hint": value.value_hint,
+        "examples": list(value.examples),
+    }
+
+
+def _build_llm_config_payload(ctx: "Context", service: Any, tokens: list[str]) -> dict[str, Any]:
+    action = tokens[0] if tokens else "show"
+    if action == "show":
+        payload = _config_snapshot_payload(service)
+        payload["values"] = [item for item in payload["values"] if str(item.get("key") or "").startswith("llm.")]
+        return payload
+    if action != "set":
+        return {"ok": False, "message": "Usage: /config llm [show|set --model NAME --base-url URL --api-key KEY]"}
+    options = tokens[1:]
+    if "--ask-api-key" in options:
+        return {"ok": False, "message": "Use `leap config llm key` in a terminal for secure API key prompts."}
+    result = service.configure_llm(
+        api_key=_option_value(options, "--api-key"),
+        base_url=_option_value(options, "--base-url"),
+        model=_option_value(options, "--model"),
+        context_length=_option_int(options, "--context-length"),
+        max_retries=_option_int(options, "--max-retries"),
+        scope=_option_value(options, "--scope", "profile"),
+    )
+    return _config_mutation_payload(ctx, service, result)
+
+
+def _build_secret_config_payload(ctx: "Context", service: Any, tokens: list[str]) -> dict[str, Any]:
+    action = tokens[0] if tokens else "list"
+    if action == "list":
+        return {"ok": True, "view": "config", "mode": "sources", "sources": list(service.list_secrets())}
+    if action == "set" and len(tokens) >= 3:
+        scope = _option_value(tokens[3:], "--scope", "profile")
+        result = service.set_secret(tokens[1], tokens[2], scope=scope)  # type: ignore[arg-type]
+        return _config_mutation_payload(ctx, service, result)
+    if action == "get" and len(tokens) >= 2:
+        scope = _option_value(tokens[2:], "--scope", "profile")
+        reveal = "--reveal" in tokens[2:]
+        value = service.get_secret(tokens[1], scope=scope, reveal=reveal)  # type: ignore[arg-type]
+        return {"ok": True, "view": "config", "mode": "get", "values": [{"key": tokens[1], "value": value, "secret": not reveal}]}
+    if action == "delete" and len(tokens) >= 2:
+        scope = _option_value(tokens[2:], "--scope", "profile")
+        result = service.delete_secret(tokens[1], scope=scope)  # type: ignore[arg-type]
+        return _config_mutation_payload(ctx, service, result)
+    return {"ok": False, "message": "Usage: /config secret [list|set|get|delete] ..."}
+
+
+def _config_mutation_payload(ctx: "Context", service: Any, result: Any) -> dict[str, Any]:
+    reloaded = False
+    if result.changed_keys:
+        reloaded = bool(ctx.reload_runtime_config_if_changed(force=True))
+    return {
+        "ok": bool(result.ok),
+        "view": "config",
+        "mode": "mutation",
+        "message": result.message,
+        "changed_keys": list(result.changed_keys),
+        "warnings": list(getattr(result, "warnings", ()) or ()),
+        "reloaded": reloaded,
+        # Runtime values the status bar renders. A daemon-mode TUI is a separate
+        # process and cannot see the reload, so it needs them echoed back here;
+        # context length travels with the model because switching models usually
+        # changes it too.
+        "model": ctx.settings.llm_model,
+        "llm_context_length": int(getattr(ctx.settings, "llm_context_length", 0) or 0),
+    }
+
+
+def _option_value(tokens: list[str], option: str, default: str | None = None) -> str | None:
+    if option not in tokens:
+        return default
+    index = tokens.index(option)
+    if index + 1 >= len(tokens):
+        raise ValueError(f"Missing value for {option}")
+    return tokens[index + 1]
+
+
+def _option_int(tokens: list[str], option: str) -> int | None:
+    value = _option_value(tokens, option)
+    return int(value) if value is not None else None
+
+
+def handle_status(ctx: "Context", console: "LeapConsole", args: str) -> None:
+    """Display session status: model, context, platform, session info."""
+    from rich.panel import Panel
+    from rich.text import Text
+
+    info = Text()
+
+    info.append("Model:     ", style="dim")
+    info.append(f"{ctx.settings.llm_model}\n", style="bold")
+
+    engine = ctx.engine
+    if engine is not None:
+        cap_registry = getattr(engine, "model_capabilities", None)
+        ctx_len = 0
+        if cap_registry is not None:
+            caps = cap_registry.resolve(ctx.settings.llm_model)
+            ctx_len = caps.context_length
+        ctx_used = getattr(engine, "context_token_count", 0)
+        turn_count = getattr(engine, "turn_count", 0)
+
+        if ctx_len:
+            pct = int(ctx_used * 100 / ctx_len) if ctx_len else 0
+            info.append("Context:   ", style="dim")
+            pct_style = "bold red" if pct >= 90 else ("yellow" if pct >= 75 else "")
+            info.append(f"{ctx_used:,} / {ctx_len:,} ({pct}%)\n", style=pct_style)
+
+        info.append("Turns:     ", style="dim")
+        info.append(f"{turn_count}\n")
+
+    platform_status = "connected" if (hasattr(ctx.rpc, "connected") and ctx.rpc.connected) else "mock"
+    info.append("Platform:  ", style="dim")
+    p_style = "green" if platform_status == "connected" else "dim"
+    info.append(f"{platform_status}\n", style=p_style)
+
+    cwd = os.getcwd().replace(os.path.expanduser("~"), "~")
+    info.append("CWD:       ", style="dim")
+    info.append(f"{cwd}\n")
+
+    info.append("Profile:   ", style="dim")
+    info.append(f"{ctx.settings.profile}\n")
+
+    info.append("Config:    ", style="dim")
+    info.append(f"{str(ctx.settings.profile_layout.config_dir).replace(os.path.expanduser('~'), '~')}\n")
+
+    user_config = str(ctx.settings.layout.user_config_path).replace(os.path.expanduser("~"), "~")
+    info.append("User cfg:  ", style="dim")
+    info.append(f"{user_config}\n")
+
+    workspace_config = str(ctx.settings.workspace_root / ".leapflow" / "config.yaml")
+    info.append("Workspace: ", style="dim")
+    info.append(f"{workspace_config.replace(os.path.expanduser('~'), '~')}\n")
+
+    session_id = getattr(ctx.session, "session_id", "")
+    if session_id:
+        info.append("Session:   ", style="dim")
+        info.append(f"{session_id}\n")
+
+    from leapflow.engine.session import SessionMode
+    mode = "idle"
+    if ctx.session:
+        if ctx.session.mode == SessionMode.LEARNING:
+            mode = "learning"
+        elif ctx.session.mode == SessionMode.EXECUTING:
+            mode = "executing"
+    info.append("Mode:      ", style="dim")
+    info.append(f"{mode}\n")
+
+    gw = getattr(ctx, "gateway_server", None)
+    if gw is not None:
+        statuses = gw.platform_status()
+        connected = [s for s in statuses if s.connected]
+        info.append("Gateway:   ", style="dim")
+        if connected:
+            names = []
+            for s in connected:
+                m = gw.manifests.get(s.platform_id)
+                names.append(m.display_name if m else s.platform_id)
+            info.append(f"{', '.join(names)}\n", style="green")
+        else:
+            info.append("no connections\n", style="dim")
+
+    console.print(Panel(
+        info,
+        title="[bold cyan]LeapFlow Status[/]",
+        border_style="bright_black",
+        padding=(0, 2),
+    ))
+
+
+def handle_tool(ctx: "Context", console: "LeapConsole", args: str) -> None:
+    """Display available tools grouped by category."""
+    render_tool_payload(console, build_tool_payload(ctx))
+
+
+def handle_usage(ctx: "Context", console: "LeapConsole", args: str) -> None:
+    """Display token usage for the current session."""
+    render_usage_payload(console, build_usage_payload(ctx))
+
+
+def handle_model(ctx: "Context", console: "LeapConsole", args: str) -> None:
+    """Show or switch the active model."""
+    render_model_payload(console, build_model_payload(ctx, args))
+
+
+def handle_config(ctx: "Context", console: "LeapConsole", args: str) -> None:
+    """View or update runtime configuration."""
+    render_config_payload(console, build_config_payload(ctx, args))
+
+
+def handle_gateway(ctx: "Context", console: "LeapConsole", args: str) -> None:
+    """Display gateway status: connected platforms, available integrations."""
+    from rich.panel import Panel
+    from rich.text import Text
+
+    gw = getattr(ctx, "gateway_server", None)
+    if gw is None:
+        console.warning("Gateway not initialised.")
+        return
+
+    statuses = gw.platform_status()
+    if not statuses:
+        console.system("No platform manifests discovered.")
+        return
+
+    info = Text()
+    connected = [s for s in statuses if s.connected]
+    configured = [s for s in statuses if not s.connected and s.error == "configured but not connected"]
+    available = [s for s in statuses if not s.connected and not s.error]
+
+    import time
+
+    if connected:
+        info.append("Connected\n", style="bold green")
+        for s in connected:
+            m = gw.manifests.get(s.platform_id)
+            name = m.display_name if m else s.platform_id
+            uptime = ""
+            if s.connected_since > 0:
+                secs = int(time.time() - s.connected_since)
+                if secs < 60:
+                    uptime = f" ({secs}s)"
+                elif secs < 3600:
+                    uptime = f" ({secs // 60}m)"
+                else:
+                    uptime = f" ({secs // 3600}h {(secs % 3600) // 60}m)"
+            info.append(f"  ● {name}{uptime}\n", style="green")
+
+    if configured:
+        info.append("Configured (not connected)\n", style="bold yellow")
+        for s in configured:
+            m = gw.manifests.get(s.platform_id)
+            name = m.display_name if m else s.platform_id
+            info.append(f"  ○ {name}\n", style="yellow")
+
+    if available:
+        info.append("Available\n", style="bold dim")
+        names = [gw.manifests[s.platform_id].display_name for s in available if s.platform_id in gw.manifests]
+        info.append(f"  {', '.join(names)}\n", style="dim")
+
+    info.append("\n", style="dim")
+    info.append('Say "connect to <platform>" to set up a new integration.', style="dim italic")
+
+    console.print(Panel(
+        info,
+        title="[bold cyan]Gateway[/]",
+        border_style="bright_black",
+        padding=(0, 2),
+    ))
+
+
+def _app_usage() -> dict[str, Any]:
+    return {
+        "ok": False,
+        "error": "Usage: /app [platform] | /app status [platform] | /app connect <platform> [--option value] | /app disconnect <platform> | /app remove <platform> | /app events [status|start|stop] <platform> | /app actions <platform>",
+        "next_actions": ("/app", "/app <platform>", "/app status <platform>"),
+    }
+
+
+def _parse_app_options(tokens: list[str]) -> tuple[dict[str, str], str]:
+    options: dict[str, str] = {}
+    index = 0
+    while index < len(tokens):
+        token = tokens[index]
+        if not token.startswith("--") or token == "--":
+            return {}, f"Unexpected argument: {token}"
+        key_value = token[2:]
+        if "=" in key_value:
+            key, value = key_value.split("=", 1)
+            if not key:
+                return {}, f"Invalid option: {token}"
+            options[key] = value
+            index += 1
+            continue
+        if index + 1 >= len(tokens):
+            return {}, f"Missing value for option: {token}"
+        key = key_value
+        if not key:
+            return {}, f"Invalid option: {token}"
+        options[key] = tokens[index + 1]
+        index += 2
+    return options, ""
+
+
+def _parse_app_params(args: str) -> dict[str, Any]:
+    try:
+        from leapflow.utils.shell_lex import split_args
+
+        tokens = split_args(args)
+    except ValueError as exc:
+        return {"ok": False, "error": f"Invalid /app arguments: {exc}"}
+
+    if not tokens or tokens[0].lower() == "list":
+        if len(tokens) > 1:
+            return _app_usage()
+        return {"ok": True, "params": {"action": "list"}, "view": "list"}
+
+    head = tokens[0].lower()
+    if head == "status":
+        if len(tokens) > 2:
+            return _app_usage()
+        params: dict[str, Any] = {"action": "status"}
+        if len(tokens) == 2:
+            params["platform"] = tokens[1].lower()
+        return {"ok": True, "params": params, "view": "status"}
+
+    if head == "connect":
+        if len(tokens) < 2:
+            return _app_usage()
+        options, error = _parse_app_options(tokens[2:])
+        if error:
+            return {
+                "ok": False,
+                "error": error,
+                "next_actions": ("/app connect <platform> --<option> <value>",),
+            }
+        params = {"action": "connect", "platform": tokens[1].lower()}
+        if options:
+            params["options"] = options
+        return {"ok": True, "params": params, "view": "connect"}
+
+    if head in {"disconnect", "remove"}:
+        if len(tokens) != 2:
+            return _app_usage()
+        return {
+            "ok": True,
+            "params": {"action": head, "platform": tokens[1].lower()},
+            "view": head,
+        }
+
+    if head == "events":
+        if len(tokens) == 2:
+            return {
+                "ok": True,
+                "params": {"action": "events_status", "platform": tokens[1].lower()},
+                "view": "events",
+            }
+        if len(tokens) == 3 and tokens[1].lower() in {"status", "start", "stop"}:
+            event_action = tokens[1].lower()
+            action = "events_status" if event_action == "status" else f"events_{event_action}"
+            return {
+                "ok": True,
+                "params": {"action": action, "platform": tokens[2].lower()},
+                "view": "events",
+            }
+        return _app_usage()
+
+    if head == "actions":
+        if len(tokens) != 2:
+            return _app_usage()
+        return {"ok": True, "platform": tokens[1].lower(), "view": "actions"}
+
+    if len(tokens) == 1:
+        return {
+            "ok": True,
+            "params": {"action": "guide", "platform": tokens[0].lower()},
+            "view": "guide",
+        }
+
+    return _app_usage()
+
+
+def _resolve_app_platform(gw: Any, platform: str) -> tuple[str, str]:
+    if not platform:
+        return "", ""
+    manifests = getattr(gw, "manifests", {}) or {}
+    if platform in manifests:
+        return platform, ""
+    folded = platform.casefold()
+    matches = [pid for pid in manifests if str(pid).casefold() == folded]
+    if len(matches) == 1:
+        return matches[0], ""
+    return "", f"Unknown platform: {platform}"
+
+
+def _available_app_ids(gw: Any) -> list[str]:
+    manifests = getattr(gw, "manifests", {}) or {}
+    return sorted(str(platform_id) for platform_id in manifests)
+
+
+def _coerce_app_option(field: Any, value: str) -> tuple[Any, str]:
+    choices = tuple(getattr(field, "choices", ()) or ())
+    if choices and value not in choices:
+        return None, f"Invalid value for --{field.key}: {value}. Choices: {', '.join(map(str, choices))}"
+
+    field_type = str(getattr(field, "field_type", "string") or "string").lower()
+    if field_type in {"string", "choice"}:
+        return value, ""
+    if field_type in {"integer", "int"}:
+        try:
+            return int(value), ""
+        except ValueError:
+            return None, f"Invalid integer for --{field.key}: {value}"
+    if field_type in {"number", "float"}:
+        try:
+            return float(value), ""
+        except ValueError:
+            return None, f"Invalid number for --{field.key}: {value}"
+    if field_type in {"boolean", "bool"}:
+        lowered = value.casefold()
+        if lowered in {"1", "true", "yes", "on"}:
+            return True, ""
+        if lowered in {"0", "false", "no", "off"}:
+            return False, ""
+        return None, f"Invalid boolean for --{field.key}: {value}"
+    return value, ""
+
+
+def _validate_app_options(manifest: Any, options: dict[str, str]) -> tuple[dict[str, Any], str]:
+    if not options:
+        return {}, ""
+    fields = {str(field.key): field for field in getattr(manifest, "options", ())}
+    unknown = sorted(key for key in options if key not in fields)
+    if unknown:
+        available = ", ".join(sorted(fields)) or "no options"
+        return {}, f"Unknown option(s): {', '.join(unknown)}. Available options: {available}"
+
+    coerced: dict[str, Any] = {}
+    for key, value in options.items():
+        converted, error = _coerce_app_option(fields[key], value)
+        if error:
+            return {}, error
+        coerced[key] = converted
+    return coerced, ""
+
+
+async def build_app_payload(ctx: "Context", args: str = "") -> dict[str, Any]:
+    """Build a serializable App Connector slash-command payload."""
+    gw = getattr(ctx, "gateway_server", None)
+    if gw is None:
+        return {
+            "ok": False,
+            "error": "Gateway is not initialised in this session.",
+            "next_actions": ("Start an in-process LeapFlow session", "Use /help to inspect runtime support"),
+        }
+
+    parsed = _parse_app_params(args)
+    if not parsed.get("ok"):
+        parsed.setdefault("available", _available_app_ids(gw))
+        return parsed
+
+    from leapflow.tools.gateway_tool import platform_action_capability_summary, platform_connect_handler, set_gateway_server
+
+    set_gateway_server(gw)
+    if parsed.get("view") == "actions":
+        platform, error = _resolve_app_platform(gw, str(parsed.get("platform") or ""))
+        if error:
+            return {"ok": False, "error": error, "available": _available_app_ids(gw)}
+        manifest = gw.manifests.get(platform)
+        if manifest is None:
+            return {"ok": False, "error": f"Unknown platform: {platform}", "available": _available_app_ids(gw)}
+        actions = dict(getattr(manifest, "actions", {}) or {})
+        action_summaries = platform_action_capability_summary(platform)
+        return {
+            "ok": True,
+            "view": "actions",
+            "platform": platform,
+            "name": getattr(manifest, "display_name", platform),
+            "action_pack": str(actions.get("pack") or ""),
+            "actions": [item["name"] for item in action_summaries if item.get("name")],
+            "action_details": action_summaries,
+        }
+
+    params = dict(parsed.get("params") or {})
+    platform = str(params.get("platform") or "")
+    if platform:
+        resolved, error = _resolve_app_platform(gw, platform)
+        if error:
+            return {"ok": False, "error": error, "available": _available_app_ids(gw)}
+        params["platform"] = resolved
+        manifest = gw.manifests.get(resolved)
+        if manifest is not None and params.get("action") == "connect":
+            options, option_error = _validate_app_options(
+                manifest,
+                dict(params.get("options") or {}),
+            )
+            if option_error:
+                return {
+                    "ok": False,
+                    "error": option_error,
+                    "available": _available_app_ids(gw),
+                    "next_actions": (f"/app {resolved}", f"/app connect {resolved}"),
+                }
+            if options:
+                params["options"] = options
+
+    result = await platform_connect_handler(params)
+    view = str(parsed.get("view") or "")
+    if params.get("action") == "connect" and result.get("setup_guide"):
+        view = "guide"
+    return {
+        "ok": bool(result.get("ok")),
+        "view": view,
+        "params": params,
+        "result": result,
+    }
+
+
+def _append_result_metadata(lines: list[str], result: dict[str, Any]) -> None:
+    diagnostics = result.get("diagnostics") or result.get("metadata")
+    if isinstance(diagnostics, dict) and diagnostics:
+        for key in ("backend_kind", "profile", "identity", "auth_status", "configured", "current_mode"):
+            if diagnostics.get(key) is not None:
+                lines.append(f"  {key}: {diagnostics[key]}")
+    recovery_hint = result.get("recovery_hint")
+    if recovery_hint:
+        lines.append(f"  recovery: {recovery_hint}")
+    next_steps = result.get("next_steps")
+    if isinstance(next_steps, list) and next_steps:
+        lines.append("  next steps:")
+        lines.extend(f"    - {step}" for step in next_steps)
+
+
+def render_app_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    """Render a serializable App Connector slash-command payload."""
+    from rich.panel import Panel
+    from rich.table import Table
+    from rich.text import Text
+
+    if not payload.get("ok"):
+        result = dict(payload.get("result") or {})
+        message = (
+            payload.get("error")
+            or result.get("error")
+            or result.get("detail")
+            or "App command failed."
+        )
+        console.warning(str(message))
+        lines: list[str] = []
+        _append_result_metadata(lines, result)
+        for line in lines:
+            console.system(line)
+        available = payload.get("available")
+        if isinstance(available, list) and available:
+            console.system("Available: " + ", ".join(str(item) for item in available))
+        for action in payload.get("next_actions") or ():
+            console.system(f"  → {action}")
+        return
+
+    result = dict(payload.get("result") or {})
+    view = str(payload.get("view") or "")
+    if view == "list":
+        platforms = list(result.get("platforms") or [])
+        table = Table(title="App Connector", show_header=True, header_style="bold", border_style="bright_black")
+        table.add_column("App", style="cyan")
+        table.add_column("ID", style="bold")
+        table.add_column("State")
+        table.add_column("Category")
+        table.add_column("Next")
+        for entry in platforms:
+            platform_id = str(entry.get("id") or "")
+            state = str(entry.get("state") or "available")
+            style = "green" if state == "connected" else ("yellow" if state == "configured" else "dim")
+            table.add_row(
+                str(entry.get("name") or platform_id),
+                platform_id,
+                f"[{style}]{state}[/]",
+                str(entry.get("category") or ""),
+                f"/app {platform_id}",
+            )
+        console.print(table)
+        console.system("Next: /app <platform> · /app status <platform> · /app connect <platform>")
+        return
+
+    if view == "guide":
+        info = Text()
+        info.append(str(result.get("setup_guide") or "No setup guide available.") + "\n")
+        steps = result.get("setup_steps") or []
+        if steps:
+            info.append("\nSteps\n", style="bold")
+            for index, step in enumerate(steps, start=1):
+                info.append(f"  {index}. {step}\n")
+        preflight = result.get("preflight_checks") or []
+        if preflight:
+            info.append("\nPreflight\n", style="bold")
+            for check in preflight:
+                command = check.get("command") or ""
+                label = check.get("label") or check.get("key") or "check"
+                info.append(f"  - {label}: {command}\n")
+        fields = result.get("required_fields") or []
+        if fields:
+            info.append("\nRequired fields\n", style="bold")
+            for field in fields:
+                required = "required" if field.get("required") else "optional"
+                info.append(f"  - {field.get('key')}: {field.get('label')} ({required})\n")
+        console_url = result.get("console_url")
+        if console_url:
+            info.append(f"\nConsole: {console_url}\n", style="dim")
+        platform = str(result.get("platform") or payload.get("params", {}).get("platform") or "App")
+        console.print(Panel(info, title=f"[bold cyan]{platform} setup[/]", border_style="bright_black", padding=(0, 2)))
+        platform_id = str(payload.get("params", {}).get("platform") or "<platform>")
+        if fields:
+            console.system(
+                "Next: provide required credentials through the guided chat flow, "
+                f"then run /app connect {platform_id}"
+            )
+        else:
+            console.system(f"Next: /app connect {platform_id}")
+        return
+
+    if view == "status":
+        platforms = result.get("platforms")
+        if isinstance(platforms, list):
+            table = Table(title="App Status", show_header=True, header_style="bold", border_style="bright_black")
+            table.add_column("ID", style="bold")
+            table.add_column("Connected")
+            table.add_column("Detail")
+            for entry in platforms:
+                detail = str(entry.get("error") or entry.get("uptime") or "available")
+                table.add_row(str(entry.get("id") or ""), "yes" if entry.get("connected") else "no", detail)
+            console.print(table)
+            return
+        lines = [f"platform: {result.get('platform')}", f"connected: {bool(result.get('connected'))}"]
+        if result.get("error"):
+            lines.append(f"detail: {result['error']}")
+        if result.get("uptime"):
+            lines.append(f"uptime: {result['uptime']}")
+        _append_result_metadata(lines, result)
+        console.print(Panel("\n".join(lines), title="[bold cyan]App Status[/]", border_style="bright_black", padding=(0, 2)))
+        return
+
+    if view == "actions":
+        action_names = list(payload.get("actions") or [])
+        action_details = list(payload.get("action_details") or [])
+        lines = [f"platform: {payload.get('name')}"]
+        if payload.get("action_pack"):
+            lines.append(f"action pack: {payload['action_pack']}")
+        if action_names:
+            lines.append("registered actions:")
+            details_by_name = {str(item.get("name")): item for item in action_details}
+            for name in action_names:
+                detail = details_by_name.get(name, {})
+                description = str(detail.get("description") or "").strip()
+                suffix = f" — {description}" if description else ""
+                lines.append(f"  - {name}{suffix}")
+        else:
+            lines.append("registered actions: none")
+        console.print(Panel("\n".join(lines), title="[bold cyan]App Actions[/]", border_style="bright_black", padding=(0, 2)))
+        return
+
+    if result.get("ok"):
+        platform = result.get("platform") or payload.get("params", {}).get("platform") or "App"
+        status = result.get("status") or result.get("detail") or "ok"
+        lines = [f"{platform}: {status}"]
+        _append_result_metadata(lines, result)
+        console.success("App command completed")
+        console.system("\n".join(lines))
+        return
+
+    message = result.get("error") or result.get("detail") or "App command failed."
+    console.warning(str(message))
+    lines: list[str] = []
+    _append_result_metadata(lines, result)
+    for line in lines:
+        console.system(line)
+
+
+async def handle_app(ctx: "Context", console: "LeapConsole", args: str) -> None:
+    """Manage external App Connector integrations from slash commands."""
+    render_app_payload(console, await build_app_payload(ctx, args))
+
+
+# NOTE: screen clearing is owned by ``LeapApp.clear_screen()``. It must go
+# through the prompt_toolkit renderer that owns the TTY — a shell ``clear``
+# leaves the renderer's cursor cache stale and misplaces the next redraw — so
+# there is deliberately no clear handler here.
+
+
+# ══════════════════════════════════════════════════════════════════════
+# Unified command_execute: dispatches any engine-routed slash command
+# ══════════════════════════════════════════════════════════════════════
+
+
+def build_orient_payload(ctx: "Context") -> dict[str, Any]:
+    """Read-only unified orientation view (S4-D1) + pending re-entry status.
+
+    Surfaces what the agent is currently oriented on (immediate / working /
+    long-term layers, weight-ranked) plus any armed/due re-entry triggers.
+    Observe-only; changes no state.
+    """
+    engine = ctx.engine
+    if engine is None:
+        return {"ok": False, "error": "No active engine — send a message first."}
+    view_fn = getattr(engine, "orientation_view", None)
+    if view_fn is None:
+        return {"ok": False, "error": "Orientation view not available."}
+    orientation = view_fn()
+    lines = ["Orientation (immediate / working / long-term):"]
+    items = orientation.top(12)
+    if not items:
+        lines.append("  (empty — no active findings or open questions yet)")
+    else:
+        lines.extend(f"  - ({it.layer}) {it.text}" for it in items)
+    store = getattr(ctx, "_reentry_store", None)
+    if store is not None:
+        try:
+            import time as _time
+            armed = store.list_armed_events()
+            due = store.list_due(_time.time())
+            lines.append(f"Re-entry: {len(armed)} armed event trigger(s), {len(due)} due now.")
+        except Exception:
+            pass
+    return {
+        "ok": True,
+        "message": "\n".join(lines),
+        "orientation": orientation.summary(),
+    }
+
+
+async def command_execute(
+    ctx: "Context", name: str, args: str = "", session_id: str = "",
+) -> dict[str, Any]:
+    """Execute a slash command and return a serializable result payload.
+
+    This is the unified entry point for daemon-mode command execution.
+    Returns a dict with at minimum ``ok`` and ``message`` keys, plus
+    optional structured data for rich TUI rendering. ``session_id`` identifies
+    the calling client's session for commands that observe it (e.g. ``/board``).
+    """
+    if name == "status":
+        return build_status_payload(ctx)
+    if name == "orient":
+        return build_orient_payload(ctx)
+    if name == "tool":
+        return build_tool_payload(ctx)
+    if name == "usage":
+        return build_usage_payload(ctx)
+    if name == "model":
+        return build_model_payload(ctx, args)
+    if name == "config":
+        return build_config_payload(ctx, args)
+    if name == "gateway":
+        return build_gateway_payload(ctx)
+    if name == "host":
+        return await _execute_host(ctx, args)
+    if _is_app_command_name(name):
+        app_args = name[len("app"):].strip()
+        if app_args:
+            app_args = app_args + (" " + args if args else "")
+        else:
+            app_args = args
+        return await build_app_payload(ctx, app_args)
+    if name.startswith("teach") or name == "annotate":
+        return await _execute_teach(ctx, name, args)
+    if name == "skill" or name.startswith("skill "):
+        return _execute_skill(ctx, name, args)
+    if name.startswith("hub"):
+        return await _execute_hub(ctx, name, args)
+    if name == "run":
+        return {"ok": True, "stream": True, "prompt": args}
+    if name == "arm":
+        return await _execute_scheduler_arm(ctx, args)
+    if name == "task":
+        return _execute_scheduler_task(ctx)
+    if name == "board" or name.startswith("board "):
+        return await _execute_dashboard(ctx, name, args, session_id=session_id)
+    return {"ok": False, "message": f"Unknown command: /{name}"}
+
+
+async def _ensure_session_watch_refresh(
+    ctx: "Context", monitors: Any, session_id: str = "",
+) -> str:
+    """Ensure an active session watch exists and trigger one analysis cycle.
+
+    The analysis producer is LLM-backed and can take tens of seconds, so it is
+    scheduled in the background: arming the watch and opening the board must be
+    instant and must never block the command RPC past its timeout. The board
+    receives the resulting finding over WebSocket when the cycle completes.
+    ``session_id`` binds the watch to the caller's session so the analysis reads
+    that conversation rather than whichever session was last active.
+    Returns the session watch id.
+    """
+    from leapflow.monitor.session_producer import ensure_session_watch, session_watch_params
+
+    params = session_watch_params(getattr(ctx, "settings", None))
+    if session_id:
+        params["session_id"] = session_id
+    watch_id = await ensure_session_watch(monitors, params=params)
+    monitors.schedule_watch_once(watch_id, force=True)
+    return watch_id
+
+
+_BOARD_VERBS = frozenset({"templates", "refresh", "pause", "resume", "stop", "status"})
+
+# States in which a watch can still be paused/resumed/stopped (i.e. not terminal).
+_BOARD_CONTROLLABLE_STATES = frozenset(
+    {"armed", "watching", "due", "confirming", "executing", "suspended"}
+)
+
+
+async def _execute_dashboard(
+    ctx: "Context", name: str, args: str = "", session_id: str = "",
+) -> dict[str, Any]:
+    """Analyze the current session and render it through a template.
+
+    LeapBoard has a single analysis target — the current session. ``/board``
+    opens the default (``generic``) lens; ``/board <template>`` opens a known
+    lens. Reserved verbs manage templates and the session observation. Any other
+    token is an unknown command and is rejected (never silently coerced).
+    """
+    monitors = getattr(ctx, "monitors", None)
+    sub = name.split(" ", 1)[1].strip() if " " in name else ""
+    rest = (sub + ((" " + args) if args else "")).strip() if sub else args.strip()
+    try:
+        from leapflow.utils.shell_lex import split_args
+
+        tokens = split_args(rest) if rest else []
+    except ValueError:
+        tokens = rest.split()
+    verb = tokens[0].lower() if tokens else ""
+    rest_tokens = tokens[1:]
+
+    if verb == "templates":
+        return _execute_board_templates(ctx, rest_tokens)
+    if verb == "status":
+        return _execute_board_status(ctx, monitors)
+    if verb in ("refresh", "pause", "resume", "stop"):
+        return await _execute_board_control(
+            ctx, monitors, verb, target=rest_tokens[0] if rest_tokens else "",
+        )
+    if not verb:
+        return await _execute_board_open(ctx, monitors, template="", session_id=session_id)
+    # A non-empty, non-verb token must name a known template lens; otherwise it
+    # is an unknown command and is rejected rather than coerced to generic.
+    if verb in set(_template_library(ctx).names()):
+        return await _execute_board_open(ctx, monitors, template=verb, session_id=session_id)
+    return {
+        "ok": False,
+        "message": (
+            f"Unknown board command: '{verb}'. Use /board for the session board, "
+            "/board <template> for a lens (see /board templates), or "
+            "/board templates|refresh|pause|resume|stop|status."
+        ),
+    }
+
+
+async def _execute_board_open(
+    ctx: "Context", monitors: Any, *, template: str, session_id: str = "",
+) -> dict[str, Any]:
+    """Open the current-session board rendered with the requested template.
+
+    ``template`` is guaranteed to be empty (default) or a known lens by the
+    dispatcher, so there is no silent fallback here.
+    """
+    session_watch_id = ""
+    if monitors is not None:
+        try:
+            session_watch_id = await _ensure_session_watch_refresh(ctx, monitors, session_id)
+        except Exception:
+            logger.debug("dashboard: session watch refresh failed", exc_info=True)
+    # The client owns the dashboard server lifecycle (it spawns/validates it off
+    # the event loop), so the daemon only conveys the chosen lens here.
+    payload: dict[str, Any] = {
+        "ok": True, "view": "dashboard", "mode": "open", "template": template or "generic",
+    }
+    if session_watch_id:
+        payload["watch_id"] = session_watch_id
+    return payload
+
+
+async def _execute_board_control(
+    ctx: "Context", monitors: Any, verb: str, *, target: str = "",
+) -> dict[str, Any]:
+    """Control a board observation: refresh / pause / resume / stop.
+
+    Without ``target`` the verb applies to the current session watch (``refresh``
+    starts it if absent; the others require an existing one). With ``target`` it
+    applies to the watch whose id — a full id or a unique prefix, as shown by
+    ``/board status`` — matches, so ``/board stop <id>`` stops that watch.
+    """
+    if monitors is None:
+        return {"ok": False, "message": "Monitor runtime is unavailable (scheduler disabled)."}
+
+    if target:
+        watch_id = _resolve_watch_id(monitors, target)
+        if not watch_id:
+            return {"ok": False,
+                    "message": f"No board watch matches '{target}'. Run /board status to see ids."}
+    elif verb == "refresh":
+        from leapflow.monitor.session_producer import ensure_session_watch, session_watch_params
+        watch_id = await ensure_session_watch(
+            monitors, params=session_watch_params(getattr(ctx, "settings", None))
+        )
+    else:
+        watch_id = _find_session_watch_id(monitors)
+        if not watch_id:
+            return {"ok": False,
+                    "message": f"No active session board to {verb}. Run /board to start one."}
+
+    if verb == "refresh":
+        monitors.schedule_watch_once(watch_id, force=True)
+        return {"ok": True, "view": "dashboard", "mode": "control", "action": "refresh",
+                "watch_id": watch_id,
+                "message": "Re-analyzing the current session; the board updates when it completes."}
+
+    method = {"pause": monitors.pause_watch, "resume": monitors.resume_watch,
+              "stop": monitors.stop_watch}[verb]
+    view = method(watch_id)
+    if view is None:
+        return {"ok": False, "message": f"Watch not found: {watch_id[:8]}."}
+    label = view.name or watch_id[:8]
+    messages = {
+        "pause": f"Paused {label}; use /board resume to continue.",
+        "resume": f"Resumed {label}.",
+        "stop": f"Stopped {label}; run /board to start again.",
+    }
+    return {"ok": True, "view": "dashboard", "mode": "control", "action": verb,
+            "watch": view.to_dict(), "message": messages[verb]}
+
+
+def _resolve_watch_id(monitors: Any, target: str) -> str:
+    """Resolve a watch id from an exact id or a unique prefix (as /board status shows)."""
+    target = target.strip()
+    if not target:
+        return ""
+    try:
+        views = list(monitors.list_watches())
+    except Exception:
+        return ""
+    for view in views:
+        if view.watch_id == target:
+            return view.watch_id
+    prefix_matches = [view.watch_id for view in views if view.watch_id.startswith(target)]
+    return prefix_matches[0] if len(prefix_matches) == 1 else ""
+
+
+def _find_session_watch_id(monitors: Any) -> str:
+    """Return the current controllable session watch id, or empty when none is active."""
+    try:
+        views = list(monitors.list_watches())
+    except Exception:
+        return ""
+    for view in views:
+        if view.domain == "session" and view.state in _BOARD_CONTROLLABLE_STATES:
+            return view.watch_id
+    return ""
+
+
+def _execute_board_status(ctx: "Context", monitors: Any) -> dict[str, Any]:
+    """Return session-observation status: watch detail + recent findings + lenses.
+
+    Fields:
+      - ``templates`` / ``default``: available lenses and the default.
+      - ``watches``: every watch with state, run/finding counts, and last-run age.
+      - ``findings``: recent findings (severity, title, summary, age) across watches.
+    """
+    library = _template_library(ctx)
+    data: dict[str, Any] = {
+        "ok": True, "view": "dashboard", "mode": "status",
+        "templates": library.names(), "default": "generic",
+        "watches": [], "findings": [],
+    }
+    if monitors is None:
+        return data
+    try:
+        data["watches"] = [v.to_dict() for v in monitors.list_watches()]
+    except Exception:
+        logger.debug("dashboard: watch list unavailable", exc_info=True)
+    try:
+        data["findings"] = [f.to_dict() for f in monitors.list_findings(limit=20)]
+    except Exception:
+        logger.debug("dashboard: finding list unavailable", exc_info=True)
+    return data
+
+
+def _execute_board_templates(ctx: "Context", rest_tokens: list[str]) -> dict[str, Any]:
+    """Template hub: list / add / remove / show board templates."""
+    from leapflow.dashboard.templates import sanitize_template_id
+
+    library = _template_library(ctx)
+    op = rest_tokens[0].lower() if rest_tokens else "list"
+    args = rest_tokens[1:]
+
+    if op == "list":
+        items = [library.describe(name) or {"name": name} for name in library.names()]
+        return {"ok": True, "view": "dashboard", "mode": "templates",
+                "templates": items, "default": "generic"}
+
+    if op == "add":
+        positional = [t for t in args if not t.startswith("--")]
+        if not positional:
+            return {"ok": False, "message": "Usage: /board templates add <path.yaml> [--name id] [--force]"}
+        requested = _flag_value(args, "--name")
+        candidate = sanitize_template_id(requested or Path(positional[0]).stem)
+        if candidate in _BOARD_VERBS:
+            return {"ok": False, "message": f"'{candidate}' is a reserved board command; choose another --name."}
+        try:
+            installed = library.install(Path(positional[0]), name=requested, force="--force" in args)
+        except ValueError as exc:
+            return {"ok": False, "message": f"Could not add template: {exc}"}
+        return {"ok": True, "view": "dashboard", "mode": "templates", "action": "add",
+                "template": installed,
+                "message": f"Registered template '{installed}'. Open it with /board {installed}."}
+
+    if op == "remove":
+        if not args:
+            return {"ok": False, "message": "Usage: /board templates remove <id>"}
+        if library.source_of(args[0]) == "builtin":
+            return {"ok": False, "message": f"'{args[0]}' is a builtin template and cannot be removed."}
+        removed = library.uninstall(args[0])
+        return {"ok": bool(removed), "view": "dashboard", "mode": "templates", "action": "remove",
+                "message": f"Removed template '{args[0]}'." if removed else f"No custom template '{args[0]}'."}
+
+    if op == "show":
+        if not args:
+            return {"ok": False, "message": "Usage: /board templates show <id>"}
+        info = library.describe(args[0])
+        if info is None:
+            return {"ok": False, "message": f"Template not found: {args[0]}"}
+        return {"ok": True, "view": "dashboard", "mode": "templates", "action": "show", "detail": info}
+
+    return {"ok": False, "message": "Usage: /board templates [list|add|remove|show] ..."}
+
+
+def _template_library(ctx: "Context") -> Any:
+    """Build a TemplateLibrary bound to the profile's custom-template override dir."""
+    from leapflow.dashboard.templates import TemplateLibrary
+
+    override_dir = None
+    settings = getattr(ctx, "settings", None)
+    profile_layout = getattr(settings, "profile_layout", None) if settings is not None else None
+    if profile_layout is not None:
+        try:
+            override_dir = profile_layout.dashboard.templates_dir
+        except Exception:
+            override_dir = None
+    return TemplateLibrary(override_dir=override_dir)
+
+
+def _flag_value(tokens: list[str], flag: str) -> str:
+    """Return the value following ``flag`` in tokens, or '' when absent."""
+    if flag in tokens:
+        idx = tokens.index(flag)
+        if idx + 1 < len(tokens) and not tokens[idx + 1].startswith("--"):
+            return tokens[idx + 1]
+    return ""
+
+
+def _is_app_command_name(name: str) -> bool:
+    return name == "app" or name.startswith("app ")
+
+
+def build_status_payload(ctx: "Context") -> dict[str, Any]:
+    """Build a serializable status summary."""
+    engine = ctx.engine
+    context_length = 0
+    context_used = 0
+    turn_count = 0
+    if engine is not None:
+        cap_registry = getattr(engine, "model_capabilities", None)
+        if cap_registry is not None:
+            caps = cap_registry.resolve(ctx.settings.llm_model)
+            context_length = int(caps.context_length)
+        context_used = int(getattr(engine, "context_token_count", 0))
+        turn_count = int(getattr(engine, "turn_count", 0))
+
+    platform_status = "connected" if (hasattr(ctx.rpc, "connected") and ctx.rpc.connected) else "mock"
+    cwd = os.getcwd().replace(os.path.expanduser("~"), "~")
+
+    from leapflow.engine.session import SessionMode
+    mode = "idle"
+    if ctx.session:
+        if ctx.session.mode == SessionMode.LEARNING:
+            mode = "learning"
+        elif ctx.session.mode == SessionMode.EXECUTING:
+            mode = "executing"
+
+    gateway_connected: list[str] = []
+    gw = getattr(ctx, "gateway_server", None)
+    if gw is not None:
+        statuses = gw.platform_status()
+        for s in statuses:
+            if s.connected:
+                m = gw.manifests.get(s.platform_id)
+                gateway_connected.append(m.display_name if m else s.platform_id)
+
+    return {
+        "ok": True,
+        "view": "status",
+        "model": ctx.settings.llm_model,
+        "context_length": context_length,
+        "context_used": context_used,
+        "turn_count": turn_count,
+        "platform": platform_status,
+        "cwd": cwd,
+        "config_path": str(ctx.settings.profile_layout.config_dir).replace(os.path.expanduser("~"), "~"),
+        "user_config_path": str(ctx.settings.layout.user_config_path).replace(os.path.expanduser("~"), "~"),
+        "workspace_config_path": str(ctx.settings.workspace_root / ".leapflow" / "config.yaml").replace(os.path.expanduser("~"), "~"),
+        "session_id": getattr(ctx.session, "session_id", "") if ctx.session else "",
+        "mode": mode,
+        "gateway_connected": gateway_connected,
+    }
+
+
+def build_gateway_payload(ctx: "Context") -> dict[str, Any]:
+    """Build a serializable gateway status payload."""
+    import time as _time
+
+    gw = getattr(ctx, "gateway_server", None)
+    if gw is None:
+        return {"ok": False, "message": "Gateway not initialised."}
+
+    statuses = gw.platform_status()
+    if not statuses:
+        return {"ok": True, "view": "gateway", "connected": [], "configured": [], "available": []}
+
+    connected = []
+    configured = []
+    available = []
+    for s in statuses:
+        m = gw.manifests.get(s.platform_id)
+        name = m.display_name if m else s.platform_id
+        if s.connected:
+            uptime = ""
+            if s.connected_since > 0:
+                secs = int(_time.time() - s.connected_since)
+                if secs < 60:
+                    uptime = f"{secs}s"
+                elif secs < 3600:
+                    uptime = f"{secs // 60}m"
+                else:
+                    uptime = f"{secs // 3600}h {(secs % 3600) // 60}m"
+            connected.append({"name": name, "id": s.platform_id, "uptime": uptime})
+        elif s.error:
+            configured.append({"name": name, "id": s.platform_id})
+        else:
+            available.append({"name": name, "id": s.platform_id})
+    return {"ok": True, "view": "gateway", "connected": connected, "configured": configured, "available": available}
+
+
+async def _execute_host(ctx: "Context", args: str) -> dict[str, Any]:
+    """Execute /host command."""
+    action = args.strip().lower() if args.strip() else "status"
+    if action not in {"status", "start", "stop", "restart"}:
+        return {"ok": False, "message": "Usage: /host [status|start|stop|restart]"}
+    if action == "status":
+        result = await ctx.host_backend_status()
+    elif action == "start":
+        result = await ctx.host_backend_start()
+    elif action == "stop":
+        result = await ctx.host_backend_stop()
+    else:
+        result = await ctx.host_backend_restart()
+    return {"ok": True, "view": "host", "action": action, "result": result}
+
+
+async def _distill_background(session) -> None:
+    """Run distillation in background without blocking the RPC response."""
+    import logging
+    _log = logging.getLogger(__name__)
+    try:
+        final = await session.await_learning()
+        if final and final.candidates:
+            _log.info(
+                "background_distill: %d candidates, activated=%s",
+                len(final.candidates),
+                final.activated_skill_names or [],
+            )
+        else:
+            _log.info("background_distill: no candidates produced")
+    except Exception:
+        _log.warning("background_distill failed", exc_info=True)
+
+
+async def _execute_teach(ctx: "Context", name: str, args: str) -> dict[str, Any]:
+    """Execute teach commands.
+
+    Returns ``session_mode`` in the payload so the TUI client can track
+    whether it should route subsequent inputs as annotations.
+    """
+    from leapflow.engine.session import SessionMode
+
+    full_cmd = name + (" " + args if args else "")
+    if full_cmd in ("teach start", "teach") or full_cmd.startswith("teach start "):
+        if ctx.session is None:
+            return {"ok": False, "message": "No active session.", "session_mode": "idle"}
+        if ctx.session.mode == SessionMode.LEARNING:
+            return {"ok": False, "message": "Already in teaching mode. Say '/teach stop' to end.", "session_mode": "learning"}
+        goal = args if name == "teach start" else ""
+        try:
+            session = await ctx.session.enter_learning(goal=goal)
+            msg = f"Teaching started — session {session.session_id}"
+            if goal:
+                msg += f"\nGoal: {goal}"
+            msg += "\nCommands: /teach stop │ /teach discard │ /teach pause │ /teach resume │ /teach skip [n] │ /annotate <text>"
+            return {"ok": True, "message": msg, "session_mode": "learning"}
+        except Exception as e:
+            return {"ok": False, "message": str(e)}
+
+    if name == "teach stop":
+        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
+            return {"ok": False, "message": "Not in teaching mode.", "session_mode": "idle"}
+        try:
+            result = await ctx.session.exit_learning()
+            msg = f"Recording stopped — {result.step_count} steps, {result.duration:.1f}s"
+            if result.step_count == 0:
+                msg += "\nNo steps recorded — nothing to distill."
+            elif not getattr(ctx.settings, "has_llm_credentials", False):
+                msg += "\nNo LLM credentials — distillation skipped."
+            elif ctx.session.has_pending_distillation:
+                import asyncio
+                asyncio.create_task(_distill_background(ctx.session))
+                msg += "\nDistillation started in background."
+            else:
+                report = getattr(result, "learnability_report", None)
+                reason = getattr(report, "reason", "assessment decided to skip") if report else "auto-learn disabled"
+                msg += f"\nDistillation skipped: {reason}"
+            return {
+                "ok": True,
+                "message": msg,
+                "step_count": result.step_count,
+                "duration": result.duration,
+                "session_mode": "idle",
+            }
+        except Exception as e:
+            return {"ok": False, "message": str(e), "session_mode": "idle"}
+
+    if name == "teach pause":
+        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
+            return {"ok": False, "message": "Not in teaching mode."}
+        ctx.session.pause_learning()
+        return {"ok": True, "message": "Teaching paused.", "session_mode": "paused"}
+
+    if name == "teach resume":
+        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
+            return {"ok": False, "message": "Not in teaching mode."}
+        ctx.session.resume_learning()
+        return {"ok": True, "message": "Teaching resumed.", "session_mode": "learning"}
+
+    if name == "teach discard":
+        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
+            return {"ok": False, "message": "Not in teaching mode."}
+        ctx.session.discard_learning()
+        return {"ok": True, "message": "Recording discarded.", "session_mode": "idle"}
+
+    if name == "teach skip":
+        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
+            return {"ok": False, "message": "Not in teaching mode."}
+        n = 1
+        if args.strip().isdigit():
+            n = int(args.strip())
+        ctx.session.skip_steps(n)
+        return {"ok": True, "message": f"Marked last {n} step(s) as noise.", "session_mode": "learning"}
+
+    if name == "annotate":
+        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
+            return {"ok": False, "message": "Not in teaching mode."}
+        if not args.strip():
+            return {"ok": False, "message": "Usage: /annotate <text>"}
+        ctx.session.annotate(args.strip())
+        return {"ok": True, "message": f"Annotation recorded: {args.strip()}", "session_mode": "learning"}
+
+    if name == "teach status":
+        if not ctx.session:
+            return {"ok": True, "message": "No active session.", "session_mode": "idle"}
+        mode = ctx.session.mode.value
+        result_payload: dict[str, Any] = {"ok": True, "session_mode": mode}
+        if mode == "evolving" or ctx.session.is_distilling:
+            result_payload["message"] = "Distillation in progress…"
+            result_payload["distilling"] = True
+        elif mode == "learning":
+            step_count = ctx.session.recording_step_count
+            result_payload["message"] = f"Recording — {step_count} steps captured."
+            result_payload["step_count"] = step_count
+        else:
+            last = ctx.session.last_result
+            if last:
+                candidates = getattr(last, "candidates", None) or []
+                new_skills = getattr(last, "new_skills", None) or []
+                result_payload["message"] = (
+                    f"Idle. Last result: {last.step_count} steps, "
+                    f"{len(candidates)} candidates, "
+                    f"{len(new_skills)} activated."
+                )
+            else:
+                result_payload["message"] = "Idle. No previous distillation results."
+        return result_payload
+
+    return {"ok": False, "message": f"Unknown teach command: /{full_cmd}"}
+
+
+def _execute_skill(ctx: "Context", name: str, args: str) -> dict[str, Any]:
+    """Execute skill commands."""
+    full_cmd = name + (" " + args if args else "")
+    if full_cmd in ("skill", "skill list"):
+        skills = ctx.registry.list_all() if ctx.registry else []
+        if not skills:
+            return {"ok": True, "view": "skill_list", "skills": []}
+        entries = []
+        for s in skills:
+            m = s.metadata
+            entries.append({
+                "name": s.name,
+                "version": m.version,
+                "confidence": m.confidence,
+                "description": s.description[:80],
+            })
+        return {"ok": True, "view": "skill_list", "skills": entries}
+
+    if name == "skill show":
+        skill_name = args.strip()
+        if not skill_name:
+            return {"ok": False, "message": "Usage: /skill show <name>"}
+        skill = ctx.registry.get(skill_name) if ctx.registry else None
+        if skill is None:
+            return {"ok": False, "message": f"Skill '{skill_name}' not found."}
+        m = skill.metadata
+        return {
+            "ok": True,
+            "view": "skill_show",
+            "name": skill.name,
+            "description": skill.description,
+            "version": m.version,
+            "confidence": m.confidence,
+            "triggers": list(skill.triggers) if skill.triggers else [],
+        }
+
+    if name == "skill disable":
+        skill_name = args.strip()
+        if not skill_name:
+            return {"ok": False, "message": "Usage: /skill disable <name>"}
+        found = False
+        if ctx.skill_lib and ctx.skill_lib.deactivate_parameterized(skill_name):
+            found = True
+        if ctx.registry and ctx.registry.unregister(skill_name):
+            found = True
+        if found:
+            return {"ok": True, "message": f"Skill '{skill_name}' disabled."}
+        return {"ok": False, "message": f"Skill '{skill_name}' not found."}
+
+    if name == "skill delete":
+        skill_name = args.strip()
+        if not skill_name:
+            return {"ok": False, "message": "Usage: /skill delete <name>"}
+        found = False
+        if ctx.skill_lib:
+            stored = ctx.skill_lib.load_skill_by_title(skill_name)
+            if stored:
+                stored.status = "deleted"
+                ctx.skill_lib.update_skill(stored)
+                found = True
+        if ctx.registry and ctx.registry.unregister(skill_name):
+            found = True
+        if found:
+            return {"ok": True, "message": f"Skill '{skill_name}' deleted."}
+        return {"ok": False, "message": f"Skill '{skill_name}' not found."}
+
+    return {"ok": False, "message": f"Unknown skill command: /{full_cmd}"}
+
+
+async def _execute_hub(ctx: "Context", name: str, args: str) -> dict[str, Any]:
+    """Execute hub commands."""
+    try:
+        from leapflow.cli.commands.hub import cmd_hub_payload
+        return await cmd_hub_payload(ctx, name, args)
+    except ImportError:
+        pass
+    # Fallback: basic hub dispatch
+    sub = name[len("hub"):].strip() if name.startswith("hub") else ""
+    if not sub:
+        sub = args.split()[0] if args.split() else ""
+        args = " ".join(args.split()[1:])
+    command_parts = ["/hub"]
+    if sub:
+        command_parts.append(sub)
+    if args:
+        command_parts.append(args)
+    command = " ".join(command_parts)
+    return {"ok": False, "message": f"Hub command '{command}' is not yet implemented in this runtime."}
+
+
+def _execute_scheduler_task(ctx: "Context") -> dict[str, Any]:
+    """Execute /task command."""
+    scheduler = getattr(ctx, "scheduler", None)
+    if scheduler is None:
+        return {"ok": True, "view": "task", "tasks": [], "message": "No scheduler active."}
+    tasks = scheduler.list_tasks() if hasattr(scheduler, "list_tasks") else []
+    entries = [
+        {"name": t.name, "schedule": t.schedule, "next_run": str(getattr(t, "next_run", ""))}
+        for t in tasks
+    ]
+    return {"ok": True, "view": "task", "tasks": entries}
+
+
+async def _execute_scheduler_arm(ctx: "Context", args: str) -> dict[str, Any]:
+    """Execute /arm command."""
+    scheduler = getattr(ctx, "scheduler", None)
+    if scheduler is None:
+        return {"ok": False, "message": "Scheduler not active in this session."}
+    tokens = args.strip().split(None, 1)
+    if len(tokens) < 2:
+        return {"ok": False, "message": "Usage: /arm <skill> <cron>"}
+    skill_name, cron_expr = tokens
+    try:
+        task_id = await scheduler.arm(skill_name, cron_expr)
+        return {"ok": True, "message": f"Armed: {skill_name} → {cron_expr} (id={task_id})"}
+    except Exception as e:
+        return {"ok": False, "message": str(e)}
+
+
+def render_command_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    """Render a generic command_execute result payload in the TUI."""
+    if not payload.get("ok"):
+        console.warning(str(payload.get("message") or payload.get("error") or "Command failed."))
+        return
+
+    view = str(payload.get("view") or "")
+
+    if view == "status":
+        _render_status_view(console, payload)
+        return
+    if view == "model":
+        render_model_payload(console, payload)
+        return
+    if view == "config":
+        render_config_payload(console, payload)
+        return
+    if view == "gateway":
+        _render_gateway_view(console, payload)
+        return
+    if view == "host":
+        _render_host_view(console, payload)
+        return
+    if view == "skill_list":
+        _render_skill_list_view(console, payload)
+        return
+    if view == "skill_show":
+        _render_skill_show_view(console, payload)
+        return
+    if view == "task":
+        _render_task_view(console, payload)
+        return
+    if view == "dashboard":
+        _render_dashboard_view(console, payload)
+        return
+
+    msg = payload.get("message")
+    if msg:
+        console.success(str(msg))
+
+
+def _ago(ts: Any) -> str:
+    """Format an epoch timestamp as a compact relative age (e.g. '2m ago')."""
+    import time
+
+    try:
+        value = float(ts or 0)
+    except (TypeError, ValueError):
+        return ""
+    if value <= 0:
+        return "never"
+    delta = max(0, int(time.time() - value))
+    if delta < 60:
+        return f"{delta}s ago"
+    if delta < 3600:
+        return f"{delta // 60}m ago"
+    if delta < 86400:
+        return f"{delta // 3600}h ago"
+    return f"{delta // 86400}d ago"
+
+
+def _board_page_url() -> str:
+    """Best-effort token-scoped URL of the running board page, or '' when none.
+
+    The client owns the dashboard server, so the status renderer resolves the
+    live URL here (from discovery state) for users to copy; any failure or a
+    not-running server yields an empty string rather than raising.
+    """
+    try:
+        from leapflow.config import get_settings
+        from leapflow.dashboard import launcher
+
+        state = launcher.server_running(get_settings())
+        if not state:
+            return ""
+        return launcher.build_view_url(state["bind"], state["port"], state["token"])
+    except Exception:
+        logger.debug("dashboard: board page url lookup failed", exc_info=True)
+        return ""
+
+
+def _render_dashboard_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    from rich.table import Table
+
+    mode = str(payload.get("mode") or "")
+
+    if mode == "open":
+        # In the REPLs the browser is launched separately; this is a defensive
+        # text fallback for non-interactive callers.
+        url = payload.get("url")
+        if url:
+            console.system(f"Opening board: {url}")
+        elif payload.get("running"):
+            console.system("Dashboard is running.")
+        else:
+            console.system(str(payload.get("hint") or "Run `leap board` to open the web view."))
+        return
+
+    if mode == "control":
+        console.success(str(payload.get("message") or payload.get("action") or "done"))
+        return
+
+    if mode == "status":
+        templates = payload.get("templates") or []
+        console.system(
+            f"Templates: {', '.join(templates) or '-'} (default: {payload.get('default', 'generic')})"
+        )
+        watches = payload.get("watches") or []
+        if watches:
+            board_url = _board_page_url()
+            table = Table(title="Watches", title_style="bold cyan", border_style="bright_black")
+            for col in ("id", "name", "domain", "state", "runs", "findings", "last run"):
+                table.add_column(col)
+            # Full token URL of the board page, kept whole (folded, never cropped)
+            # so users can copy it straight from the table.
+            table.add_column("url", overflow="fold")
+            for w in watches:
+                table.add_row(
+                    str(w.get("watch_id", ""))[:8],
+                    str(w.get("name", "")),
+                    str(w.get("domain", "")),
+                    str(w.get("state", "")),
+                    str(w.get("run_count", 0)),
+                    str(w.get("finding_count", 0)),
+                    _ago(w.get("last_run_at", 0)),
+                    board_url,
+                )
+            console.print(table)
+        else:
+            console.system("Watches: none active — run /board to start session analysis.")
+        findings = payload.get("findings") or []
+        if findings:
+            console.system(f"Recent findings ({len(findings)}):")
+            markers = {"alert": "!!", "notable": " *", "info": " -"}
+            for f in findings[:20]:
+                sev = str(f.get("severity", "info"))
+                line = f"  {markers.get(sev, ' -')} [{sev}] {str(f.get('title', ''))}"
+                summary = str(f.get("summary", ""))
+                if summary:
+                    line += f" \u2014 {summary}"
+                age = _ago(f.get("ts", 0))
+                if age:
+                    line += f"  ({age})"
+                console.system(line)
+        else:
+            console.system("Findings: none yet.")
+        return
+
+    if mode == "templates":
+        action = str(payload.get("action") or "list")
+        if action == "list":
+            items = payload.get("templates") or []
+            if not items:
+                console.system("No templates available.")
+                return
+            table = Table(title="Templates", title_style="bold cyan", border_style="bright_black")
+            for col in ("name", "source", "title"):
+                table.add_column(col)
+            for item in items:
+                table.add_row(
+                    str(item.get("name", "")),
+                    str(item.get("source", "")),
+                    str(item.get("title", "")),
+                )
+            console.print(table)
+            return
+        if action == "show":
+            detail = payload.get("detail") or {}
+            console.system(
+                f"{detail.get('name')} [{detail.get('source')}] — {detail.get('title')}"
+            )
+            if detail.get("description"):
+                console.system(str(detail["description"]))
+            return
+        # add / remove success
+        console.success(str(payload.get("message") or "done"))
+        return
+
+    message = payload.get("message")
+    if message:
+        console.system(str(message))
+
+
+def _render_status_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    from rich.panel import Panel
+    from rich.text import Text
+
+    info = Text()
+    info.append("Model:     ", style="dim")
+    info.append(f"{payload.get('model')}\n", style="bold")
+
+    ctx_len = int(payload.get("context_length") or 0)
+    ctx_used = int(payload.get("context_used") or 0)
+    turn_count = int(payload.get("turn_count") or 0)
+    if ctx_len:
+        pct = int(ctx_used * 100 / ctx_len) if ctx_len else 0
+        info.append("Context:   ", style="dim")
+        pct_style = "bold red" if pct >= 90 else ("yellow" if pct >= 75 else "")
+        info.append(f"{ctx_used:,} / {ctx_len:,} ({pct}%)\n", style=pct_style)
+    info.append("Turns:     ", style="dim")
+    info.append(f"{turn_count}\n")
+    info.append("Platform:  ", style="dim")
+    p_status = str(payload.get("platform") or "")
+    p_style = "green" if p_status == "connected" else "dim"
+    info.append(f"{p_status}\n", style=p_style)
+    info.append("CWD:       ", style="dim")
+    info.append(f"{payload.get('cwd')}\n")
+    info.append("Config:    ", style="dim")
+    info.append(f"{payload.get('config_path')}\n")
+    session_id = payload.get("session_id")
+    if session_id:
+        info.append("Session:   ", style="dim")
+        info.append(f"{session_id}\n")
+    info.append("Mode:      ", style="dim")
+    info.append(f"{payload.get('mode')}\n")
+    gw = payload.get("gateway_connected") or []
+    if gw:
+        info.append("Gateway:   ", style="dim")
+        info.append(f"{', '.join(gw)}\n", style="green")
+
+    console.print(Panel(info, title="[bold cyan]LeapFlow Status[/]", border_style="bright_black", padding=(0, 2)))
+
+
+def _render_gateway_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    from rich.panel import Panel
+    from rich.text import Text
+
+    info = Text()
+    connected = payload.get("connected") or []
+    configured = payload.get("configured") or []
+    available = payload.get("available") or []
+
+    if connected:
+        info.append("Connected\n", style="bold green")
+        for entry in connected:
+            uptime = f" ({entry['uptime']})" if entry.get("uptime") else ""
+            info.append(f"  ● {entry['name']}{uptime}\n", style="green")
+    if configured:
+        info.append("Configured (not connected)\n", style="bold yellow")
+        for entry in configured:
+            info.append(f"  ○ {entry['name']}\n", style="yellow")
+    if available:
+        info.append("Available\n", style="bold dim")
+        names = [entry["name"] for entry in available]
+        info.append(f"  {', '.join(names)}\n", style="dim")
+    info.append("\n", style="dim")
+    info.append('Say "connect to <platform>" to set up a new integration.', style="dim italic")
+    console.print(Panel(info, title="[bold cyan]Gateway[/]", border_style="bright_black", padding=(0, 2)))
+
+
+def _render_host_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    result = payload.get("result") or {}
+    action = payload.get("action") or "status"
+    if action != "status":
+        console.success(f"Host {action} completed.")
+    lines = []
+    for key in ("status", "backend", "pid", "session_id"):
+        if key in result:
+            lines.append(f"  {key}: {result[key]}")
+    if lines:
+        console.system("\n".join(lines))
+
+
+def _render_skill_list_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    from rich.table import Table
+
+    skills = payload.get("skills") or []
+    if not skills:
+        console.system("No skills registered.")
+        return
+    table = Table(show_header=True, header_style="bold", border_style="dim")
+    table.add_column("Name", style="cyan", max_width=30)
+    table.add_column("Version", justify="center")
+    table.add_column("Confidence", justify="center")
+    table.add_column("Description", max_width=40)
+    for s in skills:
+        table.add_row(
+            str(s.get("name") or ""),
+            f"v{s.get('version', 0)}",
+            f"{float(s.get('confidence') or 0):.0%}",
+            str(s.get("description") or "")[:40],
+        )
+    console.print(table)
+
+
+def _render_skill_show_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    from rich.panel import Panel
+    from rich.text import Text
+
+    info = Text()
+    info.append(f"Name:        {payload.get('name')}\n")
+    info.append(f"Description: {payload.get('description')}\n")
+    info.append(f"Version:     v{payload.get('version', 0)}\n")
+    info.append(f"Confidence:  {float(payload.get('confidence') or 0):.0%}\n")
+    triggers = payload.get("triggers") or []
+    if triggers:
+        info.append(f"Triggers:    {', '.join(triggers)}")
+    console.print(Panel(info, title=str(payload.get("name") or "Skill"), border_style="cyan"))
+
+
+def _render_task_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    tasks = payload.get("tasks") or []
+    msg = payload.get("message")
+    if msg:
+        console.system(str(msg))
+        return
+    if not tasks:
+        console.system("No scheduled tasks.")
+        return
+    from rich.table import Table
+    table = Table(show_header=True, header_style="bold", border_style="dim")
+    table.add_column("Name", style="cyan")
+    table.add_column("Schedule")
+    table.add_column("Next Run")
+    for t in tasks:
+        table.add_row(str(t.get("name") or ""), str(t.get("schedule") or ""), str(t.get("next_run") or ""))
+    console.print(table)
diff --git a/src/leapflow/daemon/client.py b/src/leapflow/daemon/client.py
index 40cb9be..c1d471e 100644
--- a/src/leapflow/daemon/client.py
+++ b/src/leapflow/daemon/client.py
@@ -288,9 +288,12 @@ async def shutdown(self) -> None:
 
     async def _open(self) -> tuple[asyncio.StreamReader, asyncio.StreamWriter]:
         try:
+            # _timeout_s is the per-request read budget (heartbeat tests set it
+            # to 0.1s); connection establishment needs its own, larger floor or
+            # every RPC flakes under load when the handshake exceeds it.
             return await asyncio.wait_for(
                 get_transport().connect(self._sock_path.parent),
-                timeout=self._timeout_s,
+                timeout=max(self._timeout_s, 5.0),
             )
         except (TimeoutError, OSError) as exc:
             raise DaemonUnavailableError(
@@ -321,7 +324,7 @@ async def ensure_daemon_client(
 ) -> DaemonClient:
     """Return a client connected to a healthy daemon, starting one if needed."""
     runtime_dir = settings.runtime_dir
-    sock_path = runtime_dir / "leapd.sock"
+    sock_path = get_transport().readiness_path(runtime_dir)
     info = DaemonInfo.discover(runtime_dir)
     if info.is_healthy:
         _emit(status_callback, f"Connected to leapd (pid={info.pid}).")
diff --git a/src/leapflow/daemon/server.py b/src/leapflow/daemon/server.py
index 639cb74..0a5bfd9 100644
--- a/src/leapflow/daemon/server.py
+++ b/src/leapflow/daemon/server.py
@@ -289,7 +289,7 @@ async def serve_daemon(settings: Any, *, mock_host: bool = False) -> int:
     from leapflow.daemon.service import RuntimeLeapService
 
     runtime_dir = settings.runtime_dir
-    sock_path = runtime_dir / "leapd.sock"
+    sock_path = get_transport().readiness_path(runtime_dir)
     service = RuntimeLeapService(settings, mock_host=mock_host)
     await service.start()
     loop = asyncio.get_running_loop()
diff --git a/src/leapflow/daemon/session_registry.py b/src/leapflow/daemon/session_registry.py
index 2bc22aa..1c71ee8 100644
--- a/src/leapflow/daemon/session_registry.py
+++ b/src/leapflow/daemon/session_registry.py
@@ -49,15 +49,25 @@ def __init__(self, session_id: str, expected: Path, requested: Path) -> None:
 class SessionExecutionContext:
     """Per-session execution state: an engine + workspace + turn lock."""
 
+    # Coarse clocks quantize: on Windows, time.monotonic resolves to ~15.6ms,
+    # so two activities can share a timestamp. This counter stamps every
+    # activity strictly after the previous one, keeping "most recent" and
+    # "oldest" orderings deterministic.
+    _activity_counter = 0
+
     def __init__(self, session_id: str, engine: Any, workspace_root: Path) -> None:
         self.session_id = session_id
         self.engine = engine
         self.workspace_root = workspace_root
         self.lock = asyncio.Lock()  # serialize this session's own turns
         self.last_active = time.monotonic()
+        SessionExecutionContext._activity_counter += 1
+        self.activity_seq = SessionExecutionContext._activity_counter
 
     def touch(self) -> None:
         self.last_active = time.monotonic()
+        SessionExecutionContext._activity_counter += 1
+        self.activity_seq = SessionExecutionContext._activity_counter
 
 
 class SessionRegistry:
@@ -150,7 +160,7 @@ def _evict_oldest(self) -> None:
         ]
         if not candidates:
             return
-        oldest = min(candidates, key=lambda c: c.last_active)
+        oldest = min(candidates, key=lambda c: (c.last_active, c.activity_seq))
         del self._contexts[oldest.session_id]
 
     def active_count(self) -> int:
@@ -178,4 +188,7 @@ def most_recent_any_client(self) -> Optional[SessionExecutionContext]:
         """
         if not self._contexts:
             return None
-        return max(self._contexts.values(), key=lambda ctx: ctx.last_active)
+        return max(
+            self._contexts.values(),
+            key=lambda ctx: (ctx.last_active, ctx.activity_seq),
+        )
diff --git a/src/leapflow/dashboard/intent.py b/src/leapflow/dashboard/intent.py
index 44c6eb3..44a13a0 100644
--- a/src/leapflow/dashboard/intent.py
+++ b/src/leapflow/dashboard/intent.py
@@ -1,42 +1,43 @@
-"""DashboardIntent: the single normalized request behind ``/board`` and the tool.
-
-LeapBoard always analyzes the *current session*; the only view dimension is the
-**template** (a rendering lens). Control verbs
-(``templates``/``refresh``/``pause``/``resume``/``stop``/``status``) are handled
-at the command layer, so the intent that reaches the view builder is simply a
-template name — empty means the default (``generic``).
-"""
-
-from __future__ import annotations
-
-import shlex
-from dataclasses import dataclass
-from typing import Any, Mapping
-
-
-@dataclass(frozen=True)
-class DashboardIntent:
-    """A normalized dashboard request: which template to render the session with."""
-
-    template: str = ""
-
-    def to_dict(self) -> dict[str, Any]:
-        return {"template": self.template}
-
-    @classmethod
-    def from_params(cls, data: Mapping[str, Any]) -> "DashboardIntent":
-        """Build an intent from structured params (e.g. web ``?template=``)."""
-        data = data if isinstance(data, Mapping) else {}
-        return cls(template=str(data.get("template", "") or "").strip())
-
-    @classmethod
-    def from_args(cls, args: str) -> "DashboardIntent":
-        """Parse a slash argument string; the first token is the template name."""
-        try:
-            tokens = shlex.split(args or "")
-        except ValueError:
-            tokens = (args or "").split()
-        return cls(template=tokens[0].strip() if tokens else "")
-
-
-__all__ = ["DashboardIntent"]
+"""DashboardIntent: the single normalized request behind ``/board`` and the tool.
+
+LeapBoard always analyzes the *current session*; the only view dimension is the
+**template** (a rendering lens). Control verbs
+(``templates``/``refresh``/``pause``/``resume``/``stop``/``status``) are handled
+at the command layer, so the intent that reaches the view builder is simply a
+template name — empty means the default (``generic``).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Mapping
+
+from leapflow.utils.shell_lex import split_args
+
+
+@dataclass(frozen=True)
+class DashboardIntent:
+    """A normalized dashboard request: which template to render the session with."""
+
+    template: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"template": self.template}
+
+    @classmethod
+    def from_params(cls, data: Mapping[str, Any]) -> "DashboardIntent":
+        """Build an intent from structured params (e.g. web ``?template=``)."""
+        data = data if isinstance(data, Mapping) else {}
+        return cls(template=str(data.get("template", "") or "").strip())
+
+    @classmethod
+    def from_args(cls, args: str) -> "DashboardIntent":
+        """Parse a slash argument string; the first token is the template name."""
+        try:
+            tokens = split_args(args or "")
+        except ValueError:
+            tokens = (args or "").split()
+        return cls(template=tokens[0].strip() if tokens else "")
+
+
+__all__ = ["DashboardIntent"]
diff --git a/src/leapflow/tools/shell_tools.py b/src/leapflow/tools/shell_tools.py
index 6ef64c6..807cf6a 100644
--- a/src/leapflow/tools/shell_tools.py
+++ b/src/leapflow/tools/shell_tools.py
@@ -13,7 +13,6 @@
 import logging
 import os
 import re
-import shlex
 import subprocess
 import sys
 from pathlib import Path
@@ -27,6 +26,7 @@
     workspace_scope_error,
 )
 from leapflow.utils.process_group import ProcessGroup
+from leapflow.utils.shell_lex import split_args
 
 logger = logging.getLogger(__name__)
 
@@ -159,13 +159,16 @@ def _expand_operand(token: str) -> str:
     Expansions that are not a single filesystem operand are discarded: a variable
     holding a search list (``$PATH``) expands to ``os.pathsep``-joined entries
     that begin with ``/`` but name no file, so treating it as a path would block
-    ordinary commands like ``echo $PATH`` or ``PATH=$PATH:./bin npm test``.
+    ordinary commands like ``echo $PATH`` or ``PATH=$PATH:./bin npm test``. On
+    Windows, mixed-shell environments (MSYS/git-bash) join the same list with
+    ``:``, so both separators disqualify — except a drive-letter colon.
     """
     candidate = token.split("=", 1)[-1]
     if "$" not in candidate:
         return candidate
     expanded = os.path.expandvars(candidate)
-    if os.pathsep in expanded or any(char.isspace() for char in expanded):
+    body = expanded[2:] if len(expanded) >= 2 and expanded[1] == ":" else expanded
+    if os.pathsep in body or ":" in body or any(char.isspace() for char in expanded):
         return ""
     return expanded
 
@@ -175,6 +178,11 @@ def _has_parent_traversal(operand: str) -> bool:
     return ".." in Path(operand).parts
 
 
+# Drive-letter operands (``C:\...`` / ``C:/...``) address files exactly like
+# POSIX ``/...`` ones; without this the gate never inspects them on Windows.
+_WINDOWS_ABSOLUTE = re.compile(r"^[A-Za-z]:[\\/]")
+
+
 def _command_workspace_escape(command: str, cwd: Path | None = None) -> dict[str, Any] | None:
     """Reject path operands that resolve outside the active workspace.
 
@@ -195,7 +203,7 @@ def _command_workspace_escape(command: str, cwd: Path | None = None) -> dict[str
         return None
     base = cwd if cwd is not None else ctx.workspace_root
     try:
-        tokens = shlex.split(command)
+        tokens = split_args(command)
     except ValueError:
         tokens = command.split()
     for token in tokens:
@@ -204,7 +212,7 @@ def _command_workspace_escape(command: str, cwd: Path | None = None) -> dict[str
         operand = _expand_operand(token)
         if not operand:
             continue
-        if operand.startswith(("/", "~")):
+        if operand.startswith(("/", "~")) or _WINDOWS_ABSOLUTE.match(operand):
             path = Path(operand)
         elif _has_parent_traversal(operand):
             path = base / operand
diff --git a/src/leapflow/utils/shell_lex.py b/src/leapflow/utils/shell_lex.py
new file mode 100644
index 0000000..d8b0dc7
--- /dev/null
+++ b/src/leapflow/utils/shell_lex.py
@@ -0,0 +1,18 @@
+"""Shell-style argument tokenization that survives Windows paths."""
+
+from __future__ import annotations
+
+import os
+import shlex
+
+
+def split_args(text: str) -> list[str]:
+    """Tokenize a command/argument string like ``shlex.split``, keeping Windows paths.
+
+    POSIX shlex treats ``\\`` as an escape and silently strips the separators
+    out of ``C:\\a\\b.yaml``; on Windows ``\\`` is a path separator, so double
+    it before lexing. Quote semantics are otherwise unchanged. Raises
+    ``ValueError`` on unbalanced quoting, exactly like ``shlex.split``.
+    """
+    lexable = text.replace("\\", "\\\\") if os.name == "nt" else text
+    return shlex.split(lexable)
diff --git a/tests/_harness/cassette.py b/tests/_harness/cassette.py
index 3419b87..8569f64 100644
--- a/tests/_harness/cassette.py
+++ b/tests/_harness/cassette.py
@@ -46,6 +46,9 @@
     (re.compile(r"\b(?:sess|ws|req|traj|ep|skill|watch|call)-[0-9a-zA-Z]{6,}\b"), "<ID>"),
     (re.compile(r"\bcall_[0-9a-zA-Z]{6,}\b"), "<ID>"),
     (re.compile(r"/(?:private/)?(?:var|tmp)/[^\s\"',)\]]*"), "<TMP>"),
+    # Windows drive-letter paths: journeys scratch under %TEMP% and prompts
+    # plus tool results embed those paths, so normalize like POSIX /tmp.
+    (re.compile(r"[A-Za-z]:\\[^\s\"',)\]]*"), "<TMP>"),
     (re.compile(r"127\.0\.0\.1:\d+"), "127.0.0.1:<PORT>"),
     (re.compile(r"\b1[0-9]{9}(?:\.[0-9]+)?\b"), "<TS>"),
 )
diff --git a/tests/_harness/leapd.py b/tests/_harness/leapd.py
index bcc1345..b9c1479 100644
--- a/tests/_harness/leapd.py
+++ b/tests/_harness/leapd.py
@@ -22,6 +22,7 @@
 
 from leapflow.daemon.client import DaemonClient
 from leapflow.daemon.lifecycle import DaemonInfo, cleanup_stale, wait_ready
+from leapflow.daemon._transport import get_transport
 from leapflow.layout import build_layout
 
 READY_TIMEOUT_S = 60.0
@@ -152,7 +153,7 @@ class Leapd:
     @property
     def sock_path(self) -> Path:
         """Unix socket the daemon listens on."""
-        return self.runtime_dir / "leapd.sock"
+        return get_transport().readiness_path(self.runtime_dir)
 
     @property
     def log_path(self) -> Path:
@@ -248,7 +249,7 @@ def start_leapd(
     runtime_dir.mkdir(parents=True, exist_ok=True)
     cleanup_stale(runtime_dir)
 
-    sock_path = runtime_dir / "leapd.sock"
+    sock_path = get_transport().readiness_path(runtime_dir)
     if len(str(sock_path)) > MAX_SOCKET_PATH_LEN:
         raise LeapdStartupError(
             f"daemon socket path is {len(str(sock_path))} bytes, over the "
diff --git a/tests/conftest.py b/tests/conftest.py
index 956f86f..cfdccf3 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import sys
 import time
 from pathlib import Path
 from typing import Any, AsyncIterator, List, Optional
@@ -23,6 +24,30 @@
 from leapflow.storage.trajectory_store import TrajectoryStore
 
 
+# ════════════════════════════════════════════════════════════════
+# Headless prompt_toolkit output
+# ════════════════════════════════════════════════════════════════
+
+
+@pytest.fixture(autouse=(sys.platform == "win32"))
+def _headless_prompt_toolkit_output(monkeypatch: pytest.MonkeyPatch) -> None:
+    """On Windows, tests never attach to a real console; render through a DummyOutput.
+
+    prompt_toolkit's win32 default output probes the console screen buffer at
+    construction and raises NoConsoleScreenBufferError anywhere a real conhost
+    is absent (git-bash, CI, pytest capture). POSIX Vt100 output has no such
+    probe, so the fixture only arms on Windows. The import below is the exact
+    symbol Application resolves lazily, so replacing it covers every app the
+    tests build.
+    """
+    from prompt_toolkit.output import DummyOutput
+    from prompt_toolkit.output import defaults as _output_defaults
+
+    monkeypatch.setattr(
+        _output_defaults, "create_output", lambda *args, **kwargs: DummyOutput()
+    )
+
+
 # ════════════════════════════════════════════════════════════════
 # Layer markers — applied by path so existing files need no edit
 # ════════════════════════════════════════════════════════════════
diff --git a/tests/journeys/test_r6_lifecycle.py b/tests/journeys/test_r6_lifecycle.py
index cfeae7b..410dcb4 100644
--- a/tests/journeys/test_r6_lifecycle.py
+++ b/tests/journeys/test_r6_lifecycle.py
@@ -22,6 +22,7 @@
 
 from leapflow.daemon.client import DaemonUnavailableError
 from leapflow.daemon.lifecycle import DaemonInfo, cleanup_stale
+from leapflow.daemon._transport import get_transport
 from tests._harness.cassette_proxy import answer, scripted
 from tests._harness.journey import Journey, JourneyFactory
 from tests._harness.leapd import await_for, start_leapd
@@ -107,7 +108,8 @@ async def test_r6_daemon_lifecycle(journeys: JourneyFactory) -> None:
         # Simulate the crash case: runtime files present, no process behind them.
         journey.daemon.runtime_dir.mkdir(parents=True, exist_ok=True)
         (journey.daemon.runtime_dir / "leapd.pid").write_text("999999", encoding="utf-8")
-        (journey.daemon.runtime_dir / "leapd.sock").touch(exist_ok=True)
+        sock_path = get_transport().readiness_path(journey.daemon.runtime_dir)
+        sock_path.touch(exist_ok=True)
 
         stale = DaemonInfo.discover(journey.daemon.runtime_dir)
         assert not stale.is_healthy, "a stale socket was reported as healthy"
diff --git a/tests/regression/test_test_layer_contracts.py b/tests/regression/test_test_layer_contracts.py
index 126375f..66ab553 100644
--- a/tests/regression/test_test_layer_contracts.py
+++ b/tests/regression/test_test_layer_contracts.py
@@ -93,7 +93,7 @@ def _test_modules() -> list[pathlib.Path]:
 
 
 def _relative(path: pathlib.Path) -> str:
-    return str(path.relative_to(TESTS_ROOT))
+    return path.relative_to(TESTS_ROOT).as_posix()
 
 
 def _harness_modules() -> list[pathlib.Path]:
diff --git a/tests/test_cli_entrypoint.py b/tests/test_cli_entrypoint.py
index c65b1e6..46098e5 100644
--- a/tests/test_cli_entrypoint.py
+++ b/tests/test_cli_entrypoint.py
@@ -941,12 +941,13 @@ def stop(self) -> None:
 async def test_host_status_reports_daemon_host_backend(monkeypatch, tmp_path, capsys) -> None:
     from conftest import make_settings
     from leapflow.cli.commands import host as host_module
+    from leapflow.daemon._transport import get_transport
 
     class Info:
         pid = 123
         is_healthy = True
         is_running = True
-        sock_path = tmp_path / "leapd.sock"
+        sock_path = get_transport().readiness_path(tmp_path)
 
     settings = replace(make_settings(str(tmp_path)), use_cua_driver=True)
 
diff --git a/tests/test_code_tools.py b/tests/test_code_tools.py
index b454da2..3661a4b 100644
--- a/tests/test_code_tools.py
+++ b/tests/test_code_tools.py
@@ -1,486 +1,487 @@
-"""Tests for the P0 coding built-in tools: code_search, file_find, edit_file.
-
-Handlers are pure async functions (params dict -> result dict); exercised
-directly. Governance (read-only vs mutating classification) is verified against
-the tool registry so a failed read-only search never trips the batch-stop gate.
-"""
-from __future__ import annotations
-
-import asyncio
-
-from leapflow.tools import file_operations as fo
-from leapflow.tools.file_operations import code_search, edit_file, file_find, file_write
-from leapflow.tools.code_intel import code_intel
-
-
-def _run(coro):
-    return asyncio.run(coro)
-
-
-# ── code_search ──────────────────────────────────────────────────────
-
-def test_code_search_finds_matches_with_location(tmp_path) -> None:
-    (tmp_path / "a.py").write_text("import os\nprint('hello world')\nx = 1\n")
-    (tmp_path / "b.py").write_text("def hello():\n    return 'world'\n")
-
-    result = _run(code_search({"pattern": r"hello", "path": str(tmp_path)}))
-
-    assert result["ok"] is True
-    assert result["match_count"] >= 2
-    hits = {(m["path"].split("/")[-1], m["line"]) for m in result["matches"]}
-    assert ("a.py", 2) in hits and ("b.py", 1) in hits
-    assert all("text" in m and m["line"] for m in result["matches"])
-
-
-def test_code_search_glob_filter(tmp_path) -> None:
-    (tmp_path / "a.py").write_text("needle\n")
-    (tmp_path / "a.txt").write_text("needle\n")
-
-    result = _run(code_search({"pattern": "needle", "path": str(tmp_path), "glob": "*.py"}))
-
-    assert result["ok"] is True
-    assert result["match_count"] == 1
-    assert result["matches"][0]["path"].endswith("a.py")
-
-
-def test_code_search_skips_vcs_and_dep_dirs(tmp_path) -> None:
-    (tmp_path / "src.py").write_text("token = 1\n")
-    for skip in (".git", "node_modules", "__pycache__"):
-        d = tmp_path / skip
-        d.mkdir()
-        (d / "junk.py").write_text("token = 2\n")
-
-    result = _run(code_search({"pattern": "token", "path": str(tmp_path)}))
-
-    assert result["ok"] is True
-    assert result["match_count"] == 1              # only src.py, dep/vcs dirs skipped
-    assert result["matches"][0]["path"].endswith("src.py")
-
-
-def test_code_search_no_match_is_ok_empty(tmp_path) -> None:
-    (tmp_path / "a.py").write_text("nothing here\n")
-    result = _run(code_search({"pattern": "zzz-not-present", "path": str(tmp_path)}))
-    assert result["ok"] is True and result["match_count"] == 0
-
-
-def test_code_search_invalid_regex_is_structured_error(tmp_path) -> None:
-    # Force the Python backend so an invalid pattern surfaces as re.error uniformly.
-    import leapflow.tools.file_operations as mod
-    orig = mod.shutil.which
-    mod.shutil.which = lambda _name: None
-    try:
-        result = _run(code_search({"pattern": "([unclosed", "path": str(tmp_path)}))
-    finally:
-        mod.shutil.which = orig
-    assert result["ok"] is False and result.get("error_type") == "invalid_regex"
-
-
-def test_code_search_python_backend_matches(tmp_path, monkeypatch) -> None:
-    monkeypatch.setattr(fo.shutil, "which", lambda _name: None)  # force fallback
-    (tmp_path / "a.py").write_text("alpha\nbeta needle gamma\n")
-    result = _run(code_search({"pattern": "needle", "path": str(tmp_path)}))
-    assert result["ok"] is True and result["backend"] == "python"
-    assert result["match_count"] == 1 and result["matches"][0]["line"] == 2
-
-
-def test_code_search_multiple_patterns_or_combined_single_pass(tmp_path, monkeypatch) -> None:
-    """P1-B2: batched patterns run as ONE search (one potential process spawn)."""
-    monkeypatch.setattr(fo.shutil, "which", lambda _name: None)  # force fallback
-    (tmp_path / "a.py").write_text("alpha_token\n")
-    (tmp_path / "b.py").write_text("beta_token\n")
-    (tmp_path / "c.py").write_text("unrelated\n")
-
-    result = _run(code_search({
-        "pattern": "alpha_token",
-        "patterns": ["beta_token"],
-        "path": str(tmp_path),
-    }))
-
-    assert result["ok"] is True
-    assert result["match_count"] == 2
-    hit_paths = {m["path"] for m in result["matches"]}
-    assert any(p.endswith("a.py") for p in hit_paths)
-    assert any(p.endswith("b.py") for p in hit_paths)
-
-
-def test_code_search_patterns_only_without_primary_pattern(tmp_path, monkeypatch) -> None:
-    monkeypatch.setattr(fo.shutil, "which", lambda _name: None)
-    (tmp_path / "a.py").write_text("needle\n")
-    result = _run(code_search({"patterns": ["needle"], "path": str(tmp_path)}))
-    assert result["ok"] is True and result["match_count"] == 1
-
-
-# ── ripgrep provisioning persistence (P0-B1) ───────────────────────
-
-
-def test_ripgrep_provision_marker_blocks_reinstall_across_restarts(tmp_path, monkeypatch) -> None:
-    """A failed install attempt persisted on disk must stop later daemon starts
-    from re-spawning the installer's process storm."""
-    marker = tmp_path / "cache" / "ripgrep_provision.json"
-    monkeypatch.setattr(fo.shutil, "which", lambda _name: "/usr/local/bin/brew" if _name == "brew" else None)
-    monkeypatch.setattr(fo.sys, "platform", "darwin")
-
-    install_calls: list[list[str]] = []
-
-    def fake_run(args, **kwargs):
-        install_calls.append(list(args))
-        class _R:  # noqa: N801 - minimal stub
-            returncode = 1
-        return _R()
-
-    monkeypatch.setattr(fo.subprocess, "run", fake_run)
-
-    # First process lifetime: attempts the install once and persists the marker.
-    monkeypatch.setitem(fo._RG_PROVISION, "done", False)
-    monkeypatch.setitem(fo._RG_PROVISION, "available", False)
-    assert fo.ensure_ripgrep_available(autoinstall=True, marker_path=marker) is False
-    assert len(install_calls) == 1
-    assert marker.exists()
-
-    # Simulated restart (fresh in-process cache): marker must block a re-attempt.
-    monkeypatch.setitem(fo._RG_PROVISION, "done", False)
-    monkeypatch.setitem(fo._RG_PROVISION, "available", False)
-    assert fo.ensure_ripgrep_available(autoinstall=True, marker_path=marker) is False
-    assert len(install_calls) == 1  # no second installer spawn
-
-
-def test_ripgrep_provision_marker_ignored_when_rg_present(tmp_path, monkeypatch) -> None:
-    marker = tmp_path / "ripgrep_provision.json"
-    marker.write_text('{"attempted": true, "available": false}')
-    monkeypatch.setattr(fo.shutil, "which", lambda _name: "/opt/homebrew/bin/rg" if _name == "rg" else None)
-    monkeypatch.setitem(fo._RG_PROVISION, "done", False)
-    monkeypatch.setitem(fo._RG_PROVISION, "available", False)
-
-    assert fo.ensure_ripgrep_available(autoinstall=True, marker_path=marker) is True
-
-
-# ── file_find ────────────────────────────────────────────────────────
-
-def test_file_find_recursive_glob(tmp_path) -> None:
-    (tmp_path / "pkg").mkdir()
-    (tmp_path / "pkg" / "mod.py").write_text("x\n")
-    (tmp_path / "top.py").write_text("y\n")
-    (tmp_path / "note.md").write_text("z\n")
-
-    result = _run(file_find({"glob": "*.py", "path": str(tmp_path)}))
-
-    assert result["ok"] is True
-    found = {p.split("/")[-1] for p in result["files"]}
-    assert found == {"mod.py", "top.py"}
-
-
-def test_file_find_skips_dep_dirs(tmp_path) -> None:
-    (tmp_path / "keep.py").write_text("x\n")
-    (tmp_path / ".venv").mkdir()
-    (tmp_path / ".venv" / "lib.py").write_text("x\n")
-
-    result = _run(file_find({"glob": "*.py", "path": str(tmp_path)}))
-
-    assert [p.split("/")[-1] for p in result["files"]] == ["keep.py"]
-
-
-def test_file_find_truncates_at_max_results(tmp_path) -> None:
-    for i in range(10):
-        (tmp_path / f"f{i}.py").write_text("x\n")
-    result = _run(file_find({"glob": "*.py", "path": str(tmp_path), "max_results": 3}))
-    assert result["ok"] is True and result["file_count"] == 3 and result["truncated"] is True
-
-
-def test_file_find_missing_glob_errors(tmp_path) -> None:
-    result = _run(file_find({"path": str(tmp_path)}))
-    assert result["ok"] is False
-
-
-# ── edit_file ────────────────────────────────────────────────────────
-
-def test_edit_file_unique_anchor_replaces(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("a = 1\nb = 2\nc = 3\n")
-
-    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "b = 2", "new_text": "b = 20"}]}))
-
-    assert result["ok"] is True and result["changed"] is True and result["replacements"] == 1
-    assert f.read_text() == "a = 1\nb = 20\nc = 3\n"
-
-
-def test_edit_file_non_unique_anchor_is_rejected(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("x = 1\nx = 1\n")
-
-    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "x = 1", "new_text": "x = 2"}]}))
-
-    assert result["ok"] is False and result["error_type"] == "anchor_not_unique"
-    assert result["match_count"] == 2
-    assert f.read_text() == "x = 1\nx = 1\n"        # unchanged — no silent corruption
-
-
-def test_edit_file_replace_all(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("x = 1\nx = 1\n")
-    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "x = 1", "new_text": "x = 9", "replace_all": True}]}))
-    assert result["ok"] is True and result["replacements"] == 2
-    assert f.read_text() == "x = 9\nx = 9\n"
-
-
-def test_edit_file_anchor_not_found(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("hello\n")
-    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "nope", "new_text": "x"}]}))
-    assert result["ok"] is False and result["error_type"] == "anchor_not_found"
-    assert f.read_text() == "hello\n"
-
-
-def test_edit_file_dry_run_does_not_write(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("a = 1\n")
-    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "a = 1", "new_text": "a = 2"}], "dry_run": True}))
-    assert result["ok"] is True and result.get("dry_run") is True and result["changed"] is True
-    assert f.read_text() == "a = 1\n"               # not written
-
-
-def test_edit_file_sequential_multi_edits(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("one\ntwo\nthree\n")
-    result = _run(edit_file({"path": str(f), "edits": [
-        {"original_text": "one", "new_text": "1"},
-        {"original_text": "three", "new_text": "3"},
-    ]}))
-    assert result["ok"] is True and result["edits_applied"] == 2
-    assert f.read_text() == "1\ntwo\n3\n"
-
-
-def test_edit_file_missing_file_errors(tmp_path) -> None:
-    result = _run(edit_file({"path": str(tmp_path / "nope.py"), "edits": [{"original_text": "a", "new_text": "b"}]}))
-    assert result["ok"] is False and result["error_type"] == "file_not_found"
-
-
-def test_edit_file_single_edit_shorthand(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("k = 1\n")
-    result = _run(edit_file({"path": str(f), "original_text": "k = 1", "new_text": "k = 2"}))
-    assert result["ok"] is True and f.read_text() == "k = 2\n"
-
-
-# ── governance: registry classification ──────────────────────────────
-
-def test_new_tools_execution_policy_classification() -> None:
-    from leapflow.tools.registry_bootstrap import TOOL_DEFINITIONS, TOOL_HANDLERS, _BRIDGE_TOOLS
-    from leapflow.tools.name_resolver import ToolRegistry, TOOL_NAME_ALIASES
-    from leapflow.engine.tool_execution import execution_policy_for
-
-    reg = ToolRegistry.from_definitions(
-        TOOL_DEFINITIONS, TOOL_HANDLERS, bridge_tools=_BRIDGE_TOOLS, aliases=TOOL_NAME_ALIASES,
-    )
-    # Read-only search/find must NOT be side-effecting (else a failed search would
-    # trip the batch-stop gate); edit_file mutates like file_write.
-    assert execution_policy_for("code_search", reg.specs.get("code_search")) == "read_only"
-    assert execution_policy_for("file_find", reg.specs.get("file_find")) == "read_only"
-    assert execution_policy_for("edit_file", reg.specs.get("edit_file")) == "mutating_idempotent"
-
-
-# ── ripgrep provisioning: seamless fallback + best-effort auto-install ──
-
-def _reset_rg_cache() -> None:
-    fo._RG_PROVISION.update(done=False, available=False)
-
-
-def test_code_search_install_hint_when_ripgrep_missing(tmp_path, monkeypatch) -> None:
-    """With ripgrep absent, code_search still works (Python) and surfaces a
-    manual-install hint — the seamless fallback + fallback-to-manual path."""
-    monkeypatch.setattr(fo, "ripgrep_path", lambda: None)
-    (tmp_path / "a.py").write_text("needle here\n")
-    result = _run(code_search({"pattern": "needle", "path": str(tmp_path)}))
-    assert result["ok"] is True and result["backend"] == "python"
-    assert result["match_count"] == 1
-    assert "install_hint" in result and "ripgrep" in result["install_hint"]
-
-
-def test_ensure_ripgrep_present_does_not_install(monkeypatch) -> None:
-    _reset_rg_cache()
-    monkeypatch.setattr(fo, "ripgrep_path", lambda: "/usr/bin/rg")
-
-    def _no_install(*_a, **_k):
-        raise AssertionError("must not install when ripgrep is already present")
-
-    monkeypatch.setattr(fo.subprocess, "run", _no_install)
-    assert fo.ensure_ripgrep_available(autoinstall=True) is True
-
-
-def test_ensure_ripgrep_autoinstall_disabled_no_install(monkeypatch) -> None:
-    _reset_rg_cache()
-    monkeypatch.setattr(fo, "ripgrep_path", lambda: None)
-
-    def _no_install(*_a, **_k):
-        raise AssertionError("must not install when autoinstall disabled")
-
-    monkeypatch.setattr(fo.subprocess, "run", _no_install)
-    assert fo.ensure_ripgrep_available(autoinstall=False) is False
-
-
-def test_ensure_ripgrep_non_darwin_skips_install(monkeypatch) -> None:
-    _reset_rg_cache()
-    monkeypatch.setattr(fo, "ripgrep_path", lambda: None)
-    monkeypatch.setattr(fo.sys, "platform", "linux")
-
-    def _no_install(*_a, **_k):
-        raise AssertionError("no no-sudo installer on non-macOS -> Python fallback")
-
-    monkeypatch.setattr(fo.subprocess, "run", _no_install)
-    assert fo.ensure_ripgrep_available(autoinstall=True) is False
-
-
-def test_ensure_ripgrep_darwin_brew_install_succeeds(monkeypatch) -> None:
-    _reset_rg_cache()
-    monkeypatch.setattr(fo.sys, "platform", "darwin")
-    monkeypatch.setattr(fo.shutil, "which", lambda name: "/opt/homebrew/bin/brew" if name == "brew" else None)
-    # ripgrep missing before the install, present after it.
-    states = iter([None, "/opt/homebrew/bin/rg"])
-    monkeypatch.setattr(fo, "ripgrep_path", lambda: next(states))
-    captured: dict = {}
-
-    def _run_install(cmd, **_k):
-        captured["cmd"] = cmd
-        return None
-
-    monkeypatch.setattr(fo.subprocess, "run", _run_install)
-    assert fo.ensure_ripgrep_available(autoinstall=True) is True
-    assert captured["cmd"][:2] == ["brew", "install"]
-
-
-def test_ensure_ripgrep_is_cached(monkeypatch) -> None:
-    _reset_rg_cache()
-    fo._RG_PROVISION.update(done=True, available=True)
-
-    def _no_install(*_a, **_k):
-        raise AssertionError("cached result must not re-attempt install")
-
-    monkeypatch.setattr(fo.subprocess, "run", _no_install)
-    assert fo.ensure_ripgrep_available(autoinstall=True) is True
-    _reset_rg_cache()
-
-
-def test_ripgrep_install_hint_macos(monkeypatch) -> None:
-    monkeypatch.setattr(fo.sys, "platform", "darwin")
-    assert fo.ripgrep_install_hint() == "brew install ripgrep"
-
-
-# ── code_intel: precise document symbols (ast for Python, heuristic otherwise) ──
-
-def test_code_intel_python_ast_symbols(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text(
-        "import os\n"
-        "\n"
-        "class Foo:\n"
-        "    def method_a(self):\n"
-        "        return 1\n"
-        "\n"
-        "def top_level(x, y):\n"
-        "    return x + y\n"
-    )
-    result = _run(code_intel({"path": str(f)}))
-    assert result["ok"] is True and result["engine"] == "ast" and result["language"] == "py"
-    by_name = {s["name"]: s for s in result["symbols"]}
-    assert by_name["Foo"]["kind"] == "class" and by_name["Foo"]["line"] == 3
-    assert by_name["method_a"]["kind"] == "method" and by_name["method_a"]["parent"] == "Foo"
-    assert by_name["top_level"]["kind"] == "function" and by_name["top_level"]["line"] == 7
-    assert "def top_level(x, y):" in by_name["top_level"]["signature"]
-
-
-def test_code_intel_non_python_heuristic(tmp_path) -> None:
-    f = tmp_path / "m.js"
-    f.write_text("function foo() {\n  return 1;\n}\nconst bar = 2;\n")
-    result = _run(code_intel({"path": str(f)}))
-    assert result["ok"] is True and result["engine"] == "heuristic"
-    assert 1 in {s["line"] for s in result["symbols"]}   # 'function foo' line
-
-
-def test_code_intel_invalid_python_falls_back(tmp_path) -> None:
-    f = tmp_path / "bad.py"
-    f.write_text("def broken(:\n    pass\n")  # syntax error -> heuristic fallback, not failure
-    result = _run(code_intel({"path": str(f)}))
-    assert result["ok"] is True and result["engine"] == "heuristic-fallback"
-
-
-def test_code_intel_missing_path() -> None:
-    assert _run(code_intel({}))["ok"] is False
-
-
-def test_code_intel_file_not_found(tmp_path) -> None:
-    assert _run(code_intel({"path": str(tmp_path / "nope.py")}))["ok"] is False
-
-
-def test_code_intel_unsupported_operation(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("x = 1\n")
-    assert _run(code_intel({"path": str(f), "operation": "definition"}))["ok"] is False
-
-
-# ── polish: code_search context_lines + edit_file unified-diff mode ──
-
-def test_code_search_context_lines(tmp_path, monkeypatch) -> None:
-    monkeypatch.setattr(fo, "ripgrep_path", lambda: None)  # deterministic Python backend
-    (tmp_path / "a.py").write_text("line1\nline2\nNEEDLE\nline4\nline5\n")
-    result = _run(code_search({"pattern": "NEEDLE", "path": str(tmp_path), "context_lines": 2}))
-    assert result["ok"] is True and result["match_count"] == 1
-    match = result["matches"][0]
-    assert match["context_before"] == ["line1", "line2"]
-    assert match["context_after"] == ["line4", "line5"]
-
-
-def test_edit_file_apply_unified_diff(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("alpha\nbeta\ngamma\n")
-    diff = "--- a/m.py\n+++ b/m.py\n@@ -1,3 +1,3 @@\n alpha\n-beta\n+BETA\n gamma\n"
-    result = _run(edit_file({"path": str(f), "diff": diff}))
-    assert result["ok"] is True and result["changed"] is True
-    assert f.read_text() == "alpha\nBETA\ngamma\n"
-
-
-def test_edit_file_invalid_diff_is_rejected(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("x\n")
-    result = _run(edit_file({"path": str(f), "diff": "not a diff, no hunks"}))
-    assert result["ok"] is False and result["error_type"] == "invalid_diff"
-    assert f.read_text() == "x\n"
-
-
-# ── B1: advisory post-edit syntax verification ──
-
-def test_edit_file_flags_broken_python_syntax(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("x = 1\n")
-    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "x = 1", "new_text": "def broken(:"}]}))
-    assert result["ok"] is True and result["changed"] is True  # write is not blocked
-    assert result["syntax_ok"] is False and "syntax_error" in result
-
-
-def test_edit_file_valid_python_syntax_ok(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("x = 1\n")
-    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "x = 1", "new_text": "x = 2"}]}))
-    assert result["ok"] is True and result["syntax_ok"] is True
-
-
-def test_edit_file_non_python_has_no_syntax_field(tmp_path) -> None:
-    f = tmp_path / "m.txt"
-    f.write_text("hello\n")
-    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "hello", "new_text": "world"}]}))
-    assert result["ok"] is True and "syntax_ok" not in result
-
-
-def test_file_write_python_syntax_ok(tmp_path) -> None:
-    f = tmp_path / "n.py"
-    result = _run(file_write({"path": str(f), "content": "def ok():\n    return 1\n"}))
-    assert result["ok"] is True and result["syntax_ok"] is True
-
-
-def test_verify_edits_toggle_off(tmp_path) -> None:
-    fo.set_edit_verification(False)
-    try:
-        f = tmp_path / "m.py"
-        f.write_text("x = 1\n")
-        result = _run(edit_file({"path": str(f), "edits": [{"original_text": "x = 1", "new_text": "def broken(:"}]}))
-        assert result["ok"] is True and "syntax_ok" not in result
-    finally:
-        fo.set_edit_verification(True)
+"""Tests for the P0 coding built-in tools: code_search, file_find, edit_file.
+
+Handlers are pure async functions (params dict -> result dict); exercised
+directly. Governance (read-only vs mutating classification) is verified against
+the tool registry so a failed read-only search never trips the batch-stop gate.
+"""
+from __future__ import annotations
+
+import asyncio
+from pathlib import PurePath
+
+from leapflow.tools import file_operations as fo
+from leapflow.tools.file_operations import code_search, edit_file, file_find, file_write
+from leapflow.tools.code_intel import code_intel
+
+
+def _run(coro):
+    return asyncio.run(coro)
+
+
+# ── code_search ──────────────────────────────────────────────────────
+
+def test_code_search_finds_matches_with_location(tmp_path) -> None:
+    (tmp_path / "a.py").write_text("import os\nprint('hello world')\nx = 1\n")
+    (tmp_path / "b.py").write_text("def hello():\n    return 'world'\n")
+
+    result = _run(code_search({"pattern": r"hello", "path": str(tmp_path)}))
+
+    assert result["ok"] is True
+    assert result["match_count"] >= 2
+    hits = {(PurePath(m["path"]).name, m["line"]) for m in result["matches"]}
+    assert ("a.py", 2) in hits and ("b.py", 1) in hits
+    assert all("text" in m and m["line"] for m in result["matches"])
+
+
+def test_code_search_glob_filter(tmp_path) -> None:
+    (tmp_path / "a.py").write_text("needle\n")
+    (tmp_path / "a.txt").write_text("needle\n")
+
+    result = _run(code_search({"pattern": "needle", "path": str(tmp_path), "glob": "*.py"}))
+
+    assert result["ok"] is True
+    assert result["match_count"] == 1
+    assert result["matches"][0]["path"].endswith("a.py")
+
+
+def test_code_search_skips_vcs_and_dep_dirs(tmp_path) -> None:
+    (tmp_path / "src.py").write_text("token = 1\n")
+    for skip in (".git", "node_modules", "__pycache__"):
+        d = tmp_path / skip
+        d.mkdir()
+        (d / "junk.py").write_text("token = 2\n")
+
+    result = _run(code_search({"pattern": "token", "path": str(tmp_path)}))
+
+    assert result["ok"] is True
+    assert result["match_count"] == 1              # only src.py, dep/vcs dirs skipped
+    assert result["matches"][0]["path"].endswith("src.py")
+
+
+def test_code_search_no_match_is_ok_empty(tmp_path) -> None:
+    (tmp_path / "a.py").write_text("nothing here\n")
+    result = _run(code_search({"pattern": "zzz-not-present", "path": str(tmp_path)}))
+    assert result["ok"] is True and result["match_count"] == 0
+
+
+def test_code_search_invalid_regex_is_structured_error(tmp_path) -> None:
+    # Force the Python backend so an invalid pattern surfaces as re.error uniformly.
+    import leapflow.tools.file_operations as mod
+    orig = mod.shutil.which
+    mod.shutil.which = lambda _name: None
+    try:
+        result = _run(code_search({"pattern": "([unclosed", "path": str(tmp_path)}))
+    finally:
+        mod.shutil.which = orig
+    assert result["ok"] is False and result.get("error_type") == "invalid_regex"
+
+
+def test_code_search_python_backend_matches(tmp_path, monkeypatch) -> None:
+    monkeypatch.setattr(fo.shutil, "which", lambda _name: None)  # force fallback
+    (tmp_path / "a.py").write_text("alpha\nbeta needle gamma\n")
+    result = _run(code_search({"pattern": "needle", "path": str(tmp_path)}))
+    assert result["ok"] is True and result["backend"] == "python"
+    assert result["match_count"] == 1 and result["matches"][0]["line"] == 2
+
+
+def test_code_search_multiple_patterns_or_combined_single_pass(tmp_path, monkeypatch) -> None:
+    """P1-B2: batched patterns run as ONE search (one potential process spawn)."""
+    monkeypatch.setattr(fo.shutil, "which", lambda _name: None)  # force fallback
+    (tmp_path / "a.py").write_text("alpha_token\n")
+    (tmp_path / "b.py").write_text("beta_token\n")
+    (tmp_path / "c.py").write_text("unrelated\n")
+
+    result = _run(code_search({
+        "pattern": "alpha_token",
+        "patterns": ["beta_token"],
+        "path": str(tmp_path),
+    }))
+
+    assert result["ok"] is True
+    assert result["match_count"] == 2
+    hit_paths = {m["path"] for m in result["matches"]}
+    assert any(p.endswith("a.py") for p in hit_paths)
+    assert any(p.endswith("b.py") for p in hit_paths)
+
+
+def test_code_search_patterns_only_without_primary_pattern(tmp_path, monkeypatch) -> None:
+    monkeypatch.setattr(fo.shutil, "which", lambda _name: None)
+    (tmp_path / "a.py").write_text("needle\n")
+    result = _run(code_search({"patterns": ["needle"], "path": str(tmp_path)}))
+    assert result["ok"] is True and result["match_count"] == 1
+
+
+# ── ripgrep provisioning persistence (P0-B1) ───────────────────────
+
+
+def test_ripgrep_provision_marker_blocks_reinstall_across_restarts(tmp_path, monkeypatch) -> None:
+    """A failed install attempt persisted on disk must stop later daemon starts
+    from re-spawning the installer's process storm."""
+    marker = tmp_path / "cache" / "ripgrep_provision.json"
+    monkeypatch.setattr(fo.shutil, "which", lambda _name: "/usr/local/bin/brew" if _name == "brew" else None)
+    monkeypatch.setattr(fo.sys, "platform", "darwin")
+
+    install_calls: list[list[str]] = []
+
+    def fake_run(args, **kwargs):
+        install_calls.append(list(args))
+        class _R:  # noqa: N801 - minimal stub
+            returncode = 1
+        return _R()
+
+    monkeypatch.setattr(fo.subprocess, "run", fake_run)
+
+    # First process lifetime: attempts the install once and persists the marker.
+    monkeypatch.setitem(fo._RG_PROVISION, "done", False)
+    monkeypatch.setitem(fo._RG_PROVISION, "available", False)
+    assert fo.ensure_ripgrep_available(autoinstall=True, marker_path=marker) is False
+    assert len(install_calls) == 1
+    assert marker.exists()
+
+    # Simulated restart (fresh in-process cache): marker must block a re-attempt.
+    monkeypatch.setitem(fo._RG_PROVISION, "done", False)
+    monkeypatch.setitem(fo._RG_PROVISION, "available", False)
+    assert fo.ensure_ripgrep_available(autoinstall=True, marker_path=marker) is False
+    assert len(install_calls) == 1  # no second installer spawn
+
+
+def test_ripgrep_provision_marker_ignored_when_rg_present(tmp_path, monkeypatch) -> None:
+    marker = tmp_path / "ripgrep_provision.json"
+    marker.write_text('{"attempted": true, "available": false}')
+    monkeypatch.setattr(fo.shutil, "which", lambda _name: "/opt/homebrew/bin/rg" if _name == "rg" else None)
+    monkeypatch.setitem(fo._RG_PROVISION, "done", False)
+    monkeypatch.setitem(fo._RG_PROVISION, "available", False)
+
+    assert fo.ensure_ripgrep_available(autoinstall=True, marker_path=marker) is True
+
+
+# ── file_find ────────────────────────────────────────────────────────
+
+def test_file_find_recursive_glob(tmp_path) -> None:
+    (tmp_path / "pkg").mkdir()
+    (tmp_path / "pkg" / "mod.py").write_text("x\n")
+    (tmp_path / "top.py").write_text("y\n")
+    (tmp_path / "note.md").write_text("z\n")
+
+    result = _run(file_find({"glob": "*.py", "path": str(tmp_path)}))
+
+    assert result["ok"] is True
+    found = {PurePath(p).name for p in result["files"]}
+    assert found == {"mod.py", "top.py"}
+
+
+def test_file_find_skips_dep_dirs(tmp_path) -> None:
+    (tmp_path / "keep.py").write_text("x\n")
+    (tmp_path / ".venv").mkdir()
+    (tmp_path / ".venv" / "lib.py").write_text("x\n")
+
+    result = _run(file_find({"glob": "*.py", "path": str(tmp_path)}))
+
+    assert [PurePath(p).name for p in result["files"]] == ["keep.py"]
+
+
+def test_file_find_truncates_at_max_results(tmp_path) -> None:
+    for i in range(10):
+        (tmp_path / f"f{i}.py").write_text("x\n")
+    result = _run(file_find({"glob": "*.py", "path": str(tmp_path), "max_results": 3}))
+    assert result["ok"] is True and result["file_count"] == 3 and result["truncated"] is True
+
+
+def test_file_find_missing_glob_errors(tmp_path) -> None:
+    result = _run(file_find({"path": str(tmp_path)}))
+    assert result["ok"] is False
+
+
+# ── edit_file ────────────────────────────────────────────────────────
+
+def test_edit_file_unique_anchor_replaces(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("a = 1\nb = 2\nc = 3\n")
+
+    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "b = 2", "new_text": "b = 20"}]}))
+
+    assert result["ok"] is True and result["changed"] is True and result["replacements"] == 1
+    assert f.read_text() == "a = 1\nb = 20\nc = 3\n"
+
+
+def test_edit_file_non_unique_anchor_is_rejected(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("x = 1\nx = 1\n")
+
+    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "x = 1", "new_text": "x = 2"}]}))
+
+    assert result["ok"] is False and result["error_type"] == "anchor_not_unique"
+    assert result["match_count"] == 2
+    assert f.read_text() == "x = 1\nx = 1\n"        # unchanged — no silent corruption
+
+
+def test_edit_file_replace_all(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("x = 1\nx = 1\n")
+    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "x = 1", "new_text": "x = 9", "replace_all": True}]}))
+    assert result["ok"] is True and result["replacements"] == 2
+    assert f.read_text() == "x = 9\nx = 9\n"
+
+
+def test_edit_file_anchor_not_found(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("hello\n")
+    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "nope", "new_text": "x"}]}))
+    assert result["ok"] is False and result["error_type"] == "anchor_not_found"
+    assert f.read_text() == "hello\n"
+
+
+def test_edit_file_dry_run_does_not_write(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("a = 1\n")
+    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "a = 1", "new_text": "a = 2"}], "dry_run": True}))
+    assert result["ok"] is True and result.get("dry_run") is True and result["changed"] is True
+    assert f.read_text() == "a = 1\n"               # not written
+
+
+def test_edit_file_sequential_multi_edits(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("one\ntwo\nthree\n")
+    result = _run(edit_file({"path": str(f), "edits": [
+        {"original_text": "one", "new_text": "1"},
+        {"original_text": "three", "new_text": "3"},
+    ]}))
+    assert result["ok"] is True and result["edits_applied"] == 2
+    assert f.read_text() == "1\ntwo\n3\n"
+
+
+def test_edit_file_missing_file_errors(tmp_path) -> None:
+    result = _run(edit_file({"path": str(tmp_path / "nope.py"), "edits": [{"original_text": "a", "new_text": "b"}]}))
+    assert result["ok"] is False and result["error_type"] == "file_not_found"
+
+
+def test_edit_file_single_edit_shorthand(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("k = 1\n")
+    result = _run(edit_file({"path": str(f), "original_text": "k = 1", "new_text": "k = 2"}))
+    assert result["ok"] is True and f.read_text() == "k = 2\n"
+
+
+# ── governance: registry classification ──────────────────────────────
+
+def test_new_tools_execution_policy_classification() -> None:
+    from leapflow.tools.registry_bootstrap import TOOL_DEFINITIONS, TOOL_HANDLERS, _BRIDGE_TOOLS
+    from leapflow.tools.name_resolver import ToolRegistry, TOOL_NAME_ALIASES
+    from leapflow.engine.tool_execution import execution_policy_for
+
+    reg = ToolRegistry.from_definitions(
+        TOOL_DEFINITIONS, TOOL_HANDLERS, bridge_tools=_BRIDGE_TOOLS, aliases=TOOL_NAME_ALIASES,
+    )
+    # Read-only search/find must NOT be side-effecting (else a failed search would
+    # trip the batch-stop gate); edit_file mutates like file_write.
+    assert execution_policy_for("code_search", reg.specs.get("code_search")) == "read_only"
+    assert execution_policy_for("file_find", reg.specs.get("file_find")) == "read_only"
+    assert execution_policy_for("edit_file", reg.specs.get("edit_file")) == "mutating_idempotent"
+
+
+# ── ripgrep provisioning: seamless fallback + best-effort auto-install ──
+
+def _reset_rg_cache() -> None:
+    fo._RG_PROVISION.update(done=False, available=False)
+
+
+def test_code_search_install_hint_when_ripgrep_missing(tmp_path, monkeypatch) -> None:
+    """With ripgrep absent, code_search still works (Python) and surfaces a
+    manual-install hint — the seamless fallback + fallback-to-manual path."""
+    monkeypatch.setattr(fo, "ripgrep_path", lambda: None)
+    (tmp_path / "a.py").write_text("needle here\n")
+    result = _run(code_search({"pattern": "needle", "path": str(tmp_path)}))
+    assert result["ok"] is True and result["backend"] == "python"
+    assert result["match_count"] == 1
+    assert "install_hint" in result and "ripgrep" in result["install_hint"]
+
+
+def test_ensure_ripgrep_present_does_not_install(monkeypatch) -> None:
+    _reset_rg_cache()
+    monkeypatch.setattr(fo, "ripgrep_path", lambda: "/usr/bin/rg")
+
+    def _no_install(*_a, **_k):
+        raise AssertionError("must not install when ripgrep is already present")
+
+    monkeypatch.setattr(fo.subprocess, "run", _no_install)
+    assert fo.ensure_ripgrep_available(autoinstall=True) is True
+
+
+def test_ensure_ripgrep_autoinstall_disabled_no_install(monkeypatch) -> None:
+    _reset_rg_cache()
+    monkeypatch.setattr(fo, "ripgrep_path", lambda: None)
+
+    def _no_install(*_a, **_k):
+        raise AssertionError("must not install when autoinstall disabled")
+
+    monkeypatch.setattr(fo.subprocess, "run", _no_install)
+    assert fo.ensure_ripgrep_available(autoinstall=False) is False
+
+
+def test_ensure_ripgrep_non_darwin_skips_install(monkeypatch) -> None:
+    _reset_rg_cache()
+    monkeypatch.setattr(fo, "ripgrep_path", lambda: None)
+    monkeypatch.setattr(fo.sys, "platform", "linux")
+
+    def _no_install(*_a, **_k):
+        raise AssertionError("no no-sudo installer on non-macOS -> Python fallback")
+
+    monkeypatch.setattr(fo.subprocess, "run", _no_install)
+    assert fo.ensure_ripgrep_available(autoinstall=True) is False
+
+
+def test_ensure_ripgrep_darwin_brew_install_succeeds(monkeypatch) -> None:
+    _reset_rg_cache()
+    monkeypatch.setattr(fo.sys, "platform", "darwin")
+    monkeypatch.setattr(fo.shutil, "which", lambda name: "/opt/homebrew/bin/brew" if name == "brew" else None)
+    # ripgrep missing before the install, present after it.
+    states = iter([None, "/opt/homebrew/bin/rg"])
+    monkeypatch.setattr(fo, "ripgrep_path", lambda: next(states))
+    captured: dict = {}
+
+    def _run_install(cmd, **_k):
+        captured["cmd"] = cmd
+        return None
+
+    monkeypatch.setattr(fo.subprocess, "run", _run_install)
+    assert fo.ensure_ripgrep_available(autoinstall=True) is True
+    assert captured["cmd"][:2] == ["brew", "install"]
+
+
+def test_ensure_ripgrep_is_cached(monkeypatch) -> None:
+    _reset_rg_cache()
+    fo._RG_PROVISION.update(done=True, available=True)
+
+    def _no_install(*_a, **_k):
+        raise AssertionError("cached result must not re-attempt install")
+
+    monkeypatch.setattr(fo.subprocess, "run", _no_install)
+    assert fo.ensure_ripgrep_available(autoinstall=True) is True
+    _reset_rg_cache()
+
+
+def test_ripgrep_install_hint_macos(monkeypatch) -> None:
+    monkeypatch.setattr(fo.sys, "platform", "darwin")
+    assert fo.ripgrep_install_hint() == "brew install ripgrep"
+
+
+# ── code_intel: precise document symbols (ast for Python, heuristic otherwise) ──
+
+def test_code_intel_python_ast_symbols(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text(
+        "import os\n"
+        "\n"
+        "class Foo:\n"
+        "    def method_a(self):\n"
+        "        return 1\n"
+        "\n"
+        "def top_level(x, y):\n"
+        "    return x + y\n"
+    )
+    result = _run(code_intel({"path": str(f)}))
+    assert result["ok"] is True and result["engine"] == "ast" and result["language"] == "py"
+    by_name = {s["name"]: s for s in result["symbols"]}
+    assert by_name["Foo"]["kind"] == "class" and by_name["Foo"]["line"] == 3
+    assert by_name["method_a"]["kind"] == "method" and by_name["method_a"]["parent"] == "Foo"
+    assert by_name["top_level"]["kind"] == "function" and by_name["top_level"]["line"] == 7
+    assert "def top_level(x, y):" in by_name["top_level"]["signature"]
+
+
+def test_code_intel_non_python_heuristic(tmp_path) -> None:
+    f = tmp_path / "m.js"
+    f.write_text("function foo() {\n  return 1;\n}\nconst bar = 2;\n")
+    result = _run(code_intel({"path": str(f)}))
+    assert result["ok"] is True and result["engine"] == "heuristic"
+    assert 1 in {s["line"] for s in result["symbols"]}   # 'function foo' line
+
+
+def test_code_intel_invalid_python_falls_back(tmp_path) -> None:
+    f = tmp_path / "bad.py"
+    f.write_text("def broken(:\n    pass\n")  # syntax error -> heuristic fallback, not failure
+    result = _run(code_intel({"path": str(f)}))
+    assert result["ok"] is True and result["engine"] == "heuristic-fallback"
+
+
+def test_code_intel_missing_path() -> None:
+    assert _run(code_intel({}))["ok"] is False
+
+
+def test_code_intel_file_not_found(tmp_path) -> None:
+    assert _run(code_intel({"path": str(tmp_path / "nope.py")}))["ok"] is False
+
+
+def test_code_intel_unsupported_operation(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("x = 1\n")
+    assert _run(code_intel({"path": str(f), "operation": "definition"}))["ok"] is False
+
+
+# ── polish: code_search context_lines + edit_file unified-diff mode ──
+
+def test_code_search_context_lines(tmp_path, monkeypatch) -> None:
+    monkeypatch.setattr(fo, "ripgrep_path", lambda: None)  # deterministic Python backend
+    (tmp_path / "a.py").write_text("line1\nline2\nNEEDLE\nline4\nline5\n")
+    result = _run(code_search({"pattern": "NEEDLE", "path": str(tmp_path), "context_lines": 2}))
+    assert result["ok"] is True and result["match_count"] == 1
+    match = result["matches"][0]
+    assert match["context_before"] == ["line1", "line2"]
+    assert match["context_after"] == ["line4", "line5"]
+
+
+def test_edit_file_apply_unified_diff(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("alpha\nbeta\ngamma\n")
+    diff = "--- a/m.py\n+++ b/m.py\n@@ -1,3 +1,3 @@\n alpha\n-beta\n+BETA\n gamma\n"
+    result = _run(edit_file({"path": str(f), "diff": diff}))
+    assert result["ok"] is True and result["changed"] is True
+    assert f.read_text() == "alpha\nBETA\ngamma\n"
+
+
+def test_edit_file_invalid_diff_is_rejected(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("x\n")
+    result = _run(edit_file({"path": str(f), "diff": "not a diff, no hunks"}))
+    assert result["ok"] is False and result["error_type"] == "invalid_diff"
+    assert f.read_text() == "x\n"
+
+
+# ── B1: advisory post-edit syntax verification ──
+
+def test_edit_file_flags_broken_python_syntax(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("x = 1\n")
+    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "x = 1", "new_text": "def broken(:"}]}))
+    assert result["ok"] is True and result["changed"] is True  # write is not blocked
+    assert result["syntax_ok"] is False and "syntax_error" in result
+
+
+def test_edit_file_valid_python_syntax_ok(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("x = 1\n")
+    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "x = 1", "new_text": "x = 2"}]}))
+    assert result["ok"] is True and result["syntax_ok"] is True
+
+
+def test_edit_file_non_python_has_no_syntax_field(tmp_path) -> None:
+    f = tmp_path / "m.txt"
+    f.write_text("hello\n")
+    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "hello", "new_text": "world"}]}))
+    assert result["ok"] is True and "syntax_ok" not in result
+
+
+def test_file_write_python_syntax_ok(tmp_path) -> None:
+    f = tmp_path / "n.py"
+    result = _run(file_write({"path": str(f), "content": "def ok():\n    return 1\n"}))
+    assert result["ok"] is True and result["syntax_ok"] is True
+
+
+def test_verify_edits_toggle_off(tmp_path) -> None:
+    fo.set_edit_verification(False)
+    try:
+        f = tmp_path / "m.py"
+        f.write_text("x = 1\n")
+        result = _run(edit_file({"path": str(f), "edits": [{"original_text": "x = 1", "new_text": "def broken(:"}]}))
+        assert result["ok"] is True and "syntax_ok" not in result
+    finally:
+        fo.set_edit_verification(True)
diff --git a/tests/test_daemon_event_loop_blocking.py b/tests/test_daemon_event_loop_blocking.py
index 531b89a..67737a1 100644
--- a/tests/test_daemon_event_loop_blocking.py
+++ b/tests/test_daemon_event_loop_blocking.py
@@ -1,354 +1,356 @@
-"""Regression tests for the daemon event-loop permanent-blocking fix.
-
-Root cause chain (observed as a 43-minute daemon freeze where every RPC
-timed out):
-
-1. ``SemanticMemoryProvider._init_schema()`` created an index on
-   ``session_id`` *before* the ALTER TABLE migration that adds the column,
-   so legacy databases failed deferred init with a Binder Error.
-2. The failure made ``engine_chat`` re-enter ``_ensure_deferred()`` which
-   waited *unboundedly* on ``_deferred_lock``.
-3. ``initialize_deferred()`` ran heavy synchronous DuckDB operations
-   directly on the event-loop thread, freezing heartbeats and all RPCs.
-
-Validates:
-- legacy-schema DuckDB files migrate cleanly and end up with the session
-  index in place
-- ``engine_chat`` degrades to critical-only mode after a bounded wait
-  instead of hanging until deferred init completes
-- a foreground timeout on ``_ensure_deferred()`` never cancels the
-  background runner task (shielded wait), and the init is not re-executed
-- deferred DB work runs on the dedicated executor so concurrent tasks keep
-  running with sub-100ms scheduling gaps
-"""
-from __future__ import annotations
-
-import asyncio
-import time
-from pathlib import Path
-from typing import Any, List, Optional
-
-import duckdb
-import pytest
-
-from leapflow.cli.context import Context
-from leapflow.daemon.service import RuntimeLeapService
-from leapflow.memory.providers.semantic import SemanticMemoryProvider
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# 1. Semantic schema migration order (defect trigger)
-# ═══════════════════════════════════════════════════════════════════════════
-
-
-class TestSemanticSchemaMigrationOrder:
-    """Indexes on migrated columns must be created AFTER the migrations."""
-
-    @staticmethod
-    def _create_legacy_db(db_path: Path) -> None:
-        """Build a pre-migration leap_memory table (no domain/path/session_id)."""
-        con = duckdb.connect(str(db_path))
-        con.execute(
-            """
-            CREATE TABLE leap_memory (
-                id TEXT PRIMARY KEY,
-                kind TEXT NOT NULL,
-                content TEXT NOT NULL,
-                metadata TEXT,
-                created_at DOUBLE NOT NULL,
-                accessed_at DOUBLE NOT NULL,
-                access_count INTEGER NOT NULL DEFAULT 1
-            );
-            """
-        )
-        con.execute(
-            "INSERT INTO leap_memory (id, kind, content, created_at, accessed_at) "
-            "VALUES ('m1', 'note', 'legacy row', 1.0, 1.0)"
-        )
-        con.close()
-
-    @pytest.mark.asyncio
-    async def test_initialize_on_legacy_schema_succeeds(self, tmp_path: Path) -> None:
-        db_path = tmp_path / "legacy.duckdb"
-        self._create_legacy_db(db_path)
-
-        provider = SemanticMemoryProvider(source=db_path)
-        # Before the fix this raised a Binder Error: CREATE INDEX on
-        # session_id ran before ALTER TABLE ADD COLUMN session_id.
-        await provider.initialize()
-        try:
-            con = provider._connection()
-            cols = {
-                row[0]
-                for row in con.execute(
-                    "SELECT column_name FROM information_schema.columns "
-                    "WHERE table_name = 'leap_memory'"
-                ).fetchall()
-            }
-            assert {"domain", "path", "session_id"} <= cols
-
-            indexes = {
-                row[0]
-                for row in con.execute(
-                    "SELECT index_name FROM duckdb_indexes() "
-                    "WHERE table_name = 'leap_memory'"
-                ).fetchall()
-            }
-            assert "idx_lm_session" in indexes
-            assert "idx_lm_domain" in indexes
-
-            # Legacy data survives the migration
-            count = con.execute("SELECT COUNT(*) FROM leap_memory").fetchone()[0]
-            assert count == 1
-        finally:
-            await provider.shutdown()
-
-    @pytest.mark.asyncio
-    async def test_initialize_on_fresh_db_still_works(self, tmp_path: Path) -> None:
-        provider = SemanticMemoryProvider(source=tmp_path / "fresh.duckdb")
-        await provider.initialize()
-        try:
-            indexes = {
-                row[0]
-                for row in provider._connection().execute(
-                    "SELECT index_name FROM duckdb_indexes() "
-                    "WHERE table_name = 'leap_memory'"
-                ).fetchall()
-            }
-            assert "idx_lm_session" in indexes
-        finally:
-            await provider.shutdown()
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# 2. engine_chat bounded wait + critical-only degradation
-# ═══════════════════════════════════════════════════════════════════════════
-
-
-class _NeverReadyContext:
-    """Context stand-in whose deferred init never completes."""
-
-    def __init__(self) -> None:
-        self._deferred_initialized = False
-        self.ensure_calls = 0
-
-    async def _ensure_deferred(self) -> None:
-        self.ensure_calls += 1
-        await asyncio.Event().wait()  # blocks forever until cancelled
-
-
-class TestEngineChatDegradesOnDeferredTimeout:
-    """engine_chat must not hang when deferred init never finishes."""
-
-    @pytest.mark.asyncio
-    async def test_degrades_to_critical_only_after_timeout(self) -> None:
-        service = RuntimeLeapService.__new__(RuntimeLeapService)
-        fake_ctx = _NeverReadyContext()
-        service._ctx = fake_ctx
-        service._DEFERRED_WAIT_TIMEOUT_S = 0.1  # type: ignore[misc]
-        service._turn_admission = type(
-            "_Admission", (), {"locked": staticmethod(lambda: False)}
-        )()
-
-        stream = service.engine_chat("hello", request_id="req-degrade-1")
-        first_chunk: Any = await stream.__anext__()
-        assert first_chunk.event_type == "status"
-        assert "warming up" in first_chunk.content.lower()
-
-        # The next step must complete within the bounded wait (plus margin):
-        # a hang here means the degrade path was not taken.
-        try:
-            await asyncio.wait_for(stream.__anext__(), timeout=2.0)
-        except asyncio.TimeoutError:
-            pytest.fail(
-                "engine_chat hung on _ensure_deferred(); expected bounded "
-                "wait followed by critical-only degradation"
-            )
-        except (StopAsyncIteration, Exception):
-            # Reaching the deeper pipeline (which fails on the bare fake) is
-            # fine — the point is we got PAST the deferred wait quickly.
-            pass
-        finally:
-            await stream.aclose()
-
-        assert fake_ctx.ensure_calls == 1
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# 3. _ensure_deferred: shielded wait, cancel-safe, no duplicate init
-# ═══════════════════════════════════════════════════════════════════════════
-
-
-class TestEnsureDeferredCancelSafety:
-    """A foreground timeout must not cancel or re-run the background init."""
-
-    @staticmethod
-    def _bare_context() -> Context:
-        ctx = Context.__new__(Context)
-        ctx._deferred_initialized = False
-        ctx._deferred_lock = asyncio.Lock()
-        ctx._deferred_attempts = 0
-        ctx._deferred_task = None
-        return ctx
-
-    @pytest.mark.asyncio
-    async def test_timeout_does_not_cancel_background_runner(self) -> None:
-        ctx = self._bare_context()
-        release = asyncio.Event()
-        init_calls = 0
-
-        async def _slow_init() -> None:
-            nonlocal init_calls
-            init_calls += 1
-            await release.wait()
-
-        ctx.initialize_deferred = _slow_init  # type: ignore[method-assign]
-
-        # Background waiter (daemon's _run_deferred_init analog)
-        background = asyncio.create_task(ctx._ensure_deferred())
-        await asyncio.sleep(0.01)  # let the runner task start
-        runner: Optional[asyncio.Task[None]] = ctx._deferred_task
-        assert runner is not None and not runner.done()
-
-        # Foreground bounded wait times out (engine_chat analog)
-        with pytest.raises(asyncio.TimeoutError):
-            await asyncio.wait_for(ctx._ensure_deferred(), timeout=0.05)
-
-        # The runner must survive the foreground timeout untouched
-        assert not runner.cancelled()
-        assert not runner.done()
-        assert init_calls == 1  # no duplicate initialization
-
-        # Completing the init unblocks the background waiter
-        release.set()
-        await asyncio.wait_for(background, timeout=1.0)
-        assert ctx._deferred_initialized is True
-        assert init_calls == 1
-
-        # Subsequent calls are cheap no-ops
-        await ctx._ensure_deferred()
-        assert init_calls == 1
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# 4. Deferred DB work runs off the event loop (dedicated executor)
-# ═══════════════════════════════════════════════════════════════════════════
-
-
-class TestDeferredDbExecutor:
-    """Blocking DuckDB work must not freeze the event loop.
-
-    Asserted behaviorally below: scanning ``initialize_deferred``'s source for
-    ``_run_deferred_db`` occurrences would pin the current call-site layout
-    rather than the contract — that a blocking DB call keeps the loop
-    responsive and that ``status()`` still answers while the DB worker is busy.
-    """
-
-    @pytest.mark.asyncio
-    async def test_event_loop_stays_responsive_during_blocking_db_op(self) -> None:
-        ctx = Context.__new__(Context)
-        ctx._deferred_db_executor = None
-
-        ticks: List[float] = []
-        stop = asyncio.Event()
-
-        async def _ticker() -> None:
-            while not stop.is_set():
-                ticks.append(time.monotonic())
-                await asyncio.sleep(0.01)
-
-        ticker_task = asyncio.create_task(_ticker())
-        try:
-            start = time.monotonic()
-            result = await ctx._run_deferred_db(lambda: (time.sleep(0.3), 42)[1])
-            elapsed = time.monotonic() - start
-            assert result == 42
-            assert elapsed >= 0.3
-        finally:
-            stop.set()
-            await ticker_task
-            executor = ctx._deferred_db_executor
-            if executor is not None:
-                executor.shutdown(wait=True)
-
-        # The loop must have kept scheduling the ticker while the blocking
-        # sleep ran in the executor thread: gaps stay well under 100ms.
-        in_window = [t for t in ticks if start <= t <= start + 0.3]
-        assert len(in_window) >= 3, (
-            f"event loop starved during blocking DB op: only {len(in_window)} "
-            "ticker iterations observed in the 300ms window"
-        )
-        gaps = [b - a for a, b in zip(in_window, in_window[1:])]
-        assert gaps and max(gaps) < 0.1, (
-            f"event loop stalled for {max(gaps) if gaps else 0:.3f}s during "
-            "the blocking DB operation"
-        )
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# 5. Daemon control-plane responsiveness during deferred init
-# ═══════════════════════════════════════════════════════════════════════════
-
-
-class TestDaemonControlPlaneResponsiveness:
-    """Status/recovery RPCs must get scheduling priority over background init."""
-
-    @pytest.mark.asyncio
-    async def test_service_deferred_runner_yields_before_initialization(self) -> None:
-        order: list[str] = []
-
-        class FakeContext:
-            async def _ensure_deferred(self) -> None:
-                order.append("deferred")
-
-        async def _peer_control_plane_task() -> None:
-            order.append("peer")
-
-        service = RuntimeLeapService.__new__(RuntimeLeapService)
-        deferred = asyncio.create_task(service._run_deferred_init(FakeContext()))
-        peer = asyncio.create_task(_peer_control_plane_task())
-
-        await asyncio.gather(deferred, peer)
-
-        assert order == ["peer", "deferred"]
-
-    @pytest.mark.asyncio
-    async def test_status_returns_while_deferred_db_worker_is_busy(self, tmp_path: Path) -> None:
-        from conftest import make_settings
-        from types import SimpleNamespace
-
-        settings = make_settings(str(tmp_path))
-        service = RuntimeLeapService(settings, mock_host=True)
-        ctx = Context.__new__(Context)
-        ctx.settings = settings
-        ctx.engine = None
-        ctx._db_holder = SimpleNamespace(db_path=settings.duckdb_path)
-        ctx._deferred_initialized = False
-        ctx._deferred_lock = asyncio.Lock()
-        ctx._deferred_attempts = 0
-        ctx._deferred_task = None
-        ctx._deferred_db_executor = None
-
-        async def _slow_init() -> None:
-            await ctx._run_deferred_db(lambda: time.sleep(0.25))
-
-        ctx.initialize_deferred = _slow_init  # type: ignore[method-assign]
-        service._ctx = ctx
-        service._deferred_init_task = asyncio.create_task(service._run_deferred_init(ctx))
-        try:
-            for _ in range(50):
-                runner = getattr(ctx, "_deferred_task", None)
-                if runner is not None and not runner.done():
-                    break
-                await asyncio.sleep(0.01)
-            assert ctx._deferred_task is not None and not ctx._deferred_task.done()
-
-            status = await asyncio.wait_for(service.status(), timeout=0.1)
-
-            assert status["deferred_init"]["running"] is True
-            assert status["deferred_init"]["initialized"] is False
-        finally:
-            await service._deferred_init_task
-            executor = getattr(ctx, "_deferred_db_executor", None)
-            if executor is not None:
-                executor.shutdown(wait=True)
+"""Regression tests for the daemon event-loop permanent-blocking fix.
+
+Root cause chain (observed as a 43-minute daemon freeze where every RPC
+timed out):
+
+1. ``SemanticMemoryProvider._init_schema()`` created an index on
+   ``session_id`` *before* the ALTER TABLE migration that adds the column,
+   so legacy databases failed deferred init with a Binder Error.
+2. The failure made ``engine_chat`` re-enter ``_ensure_deferred()`` which
+   waited *unboundedly* on ``_deferred_lock``.
+3. ``initialize_deferred()`` ran heavy synchronous DuckDB operations
+   directly on the event-loop thread, freezing heartbeats and all RPCs.
+
+Validates:
+- legacy-schema DuckDB files migrate cleanly and end up with the session
+  index in place
+- ``engine_chat`` degrades to critical-only mode after a bounded wait
+  instead of hanging until deferred init completes
+- a foreground timeout on ``_ensure_deferred()`` never cancels the
+  background runner task (shielded wait), and the init is not re-executed
+- deferred DB work runs on the dedicated executor so concurrent tasks keep
+  running with sub-100ms scheduling gaps
+"""
+from __future__ import annotations
+
+import asyncio
+import time
+from pathlib import Path
+from typing import Any, List, Optional
+
+import duckdb
+import pytest
+
+from leapflow.cli.context import Context
+from leapflow.daemon.service import RuntimeLeapService
+from leapflow.memory.providers.semantic import SemanticMemoryProvider
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 1. Semantic schema migration order (defect trigger)
+# ═══════════════════════════════════════════════════════════════════════════
+
+
+class TestSemanticSchemaMigrationOrder:
+    """Indexes on migrated columns must be created AFTER the migrations."""
+
+    @staticmethod
+    def _create_legacy_db(db_path: Path) -> None:
+        """Build a pre-migration leap_memory table (no domain/path/session_id)."""
+        con = duckdb.connect(str(db_path))
+        con.execute(
+            """
+            CREATE TABLE leap_memory (
+                id TEXT PRIMARY KEY,
+                kind TEXT NOT NULL,
+                content TEXT NOT NULL,
+                metadata TEXT,
+                created_at DOUBLE NOT NULL,
+                accessed_at DOUBLE NOT NULL,
+                access_count INTEGER NOT NULL DEFAULT 1
+            );
+            """
+        )
+        con.execute(
+            "INSERT INTO leap_memory (id, kind, content, created_at, accessed_at) "
+            "VALUES ('m1', 'note', 'legacy row', 1.0, 1.0)"
+        )
+        con.close()
+
+    @pytest.mark.asyncio
+    async def test_initialize_on_legacy_schema_succeeds(self, tmp_path: Path) -> None:
+        db_path = tmp_path / "legacy.duckdb"
+        self._create_legacy_db(db_path)
+
+        provider = SemanticMemoryProvider(source=db_path)
+        # Before the fix this raised a Binder Error: CREATE INDEX on
+        # session_id ran before ALTER TABLE ADD COLUMN session_id.
+        await provider.initialize()
+        try:
+            con = provider._connection()
+            cols = {
+                row[0]
+                for row in con.execute(
+                    "SELECT column_name FROM information_schema.columns "
+                    "WHERE table_name = 'leap_memory'"
+                ).fetchall()
+            }
+            assert {"domain", "path", "session_id"} <= cols
+
+            indexes = {
+                row[0]
+                for row in con.execute(
+                    "SELECT index_name FROM duckdb_indexes() "
+                    "WHERE table_name = 'leap_memory'"
+                ).fetchall()
+            }
+            assert "idx_lm_session" in indexes
+            assert "idx_lm_domain" in indexes
+
+            # Legacy data survives the migration
+            count = con.execute("SELECT COUNT(*) FROM leap_memory").fetchone()[0]
+            assert count == 1
+        finally:
+            await provider.shutdown()
+
+    @pytest.mark.asyncio
+    async def test_initialize_on_fresh_db_still_works(self, tmp_path: Path) -> None:
+        provider = SemanticMemoryProvider(source=tmp_path / "fresh.duckdb")
+        await provider.initialize()
+        try:
+            indexes = {
+                row[0]
+                for row in provider._connection().execute(
+                    "SELECT index_name FROM duckdb_indexes() "
+                    "WHERE table_name = 'leap_memory'"
+                ).fetchall()
+            }
+            assert "idx_lm_session" in indexes
+        finally:
+            await provider.shutdown()
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 2. engine_chat bounded wait + critical-only degradation
+# ═══════════════════════════════════════════════════════════════════════════
+
+
+class _NeverReadyContext:
+    """Context stand-in whose deferred init never completes."""
+
+    def __init__(self) -> None:
+        self._deferred_initialized = False
+        self.ensure_calls = 0
+
+    async def _ensure_deferred(self) -> None:
+        self.ensure_calls += 1
+        await asyncio.Event().wait()  # blocks forever until cancelled
+
+
+class TestEngineChatDegradesOnDeferredTimeout:
+    """engine_chat must not hang when deferred init never finishes."""
+
+    @pytest.mark.asyncio
+    async def test_degrades_to_critical_only_after_timeout(self) -> None:
+        service = RuntimeLeapService.__new__(RuntimeLeapService)
+        fake_ctx = _NeverReadyContext()
+        service._ctx = fake_ctx
+        service._DEFERRED_WAIT_TIMEOUT_S = 0.1  # type: ignore[misc]
+        service._turn_admission = type(
+            "_Admission", (), {"locked": staticmethod(lambda: False)}
+        )()
+
+        stream = service.engine_chat("hello", request_id="req-degrade-1")
+        first_chunk: Any = await stream.__anext__()
+        assert first_chunk.event_type == "status"
+        assert "warming up" in first_chunk.content.lower()
+
+        # The next step must complete within the bounded wait (plus margin):
+        # a hang here means the degrade path was not taken.
+        try:
+            await asyncio.wait_for(stream.__anext__(), timeout=2.0)
+        except asyncio.TimeoutError:
+            pytest.fail(
+                "engine_chat hung on _ensure_deferred(); expected bounded "
+                "wait followed by critical-only degradation"
+            )
+        except (StopAsyncIteration, Exception):
+            # Reaching the deeper pipeline (which fails on the bare fake) is
+            # fine — the point is we got PAST the deferred wait quickly.
+            pass
+        finally:
+            await stream.aclose()
+
+        assert fake_ctx.ensure_calls == 1
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 3. _ensure_deferred: shielded wait, cancel-safe, no duplicate init
+# ═══════════════════════════════════════════════════════════════════════════
+
+
+class TestEnsureDeferredCancelSafety:
+    """A foreground timeout must not cancel or re-run the background init."""
+
+    @staticmethod
+    def _bare_context() -> Context:
+        ctx = Context.__new__(Context)
+        ctx._deferred_initialized = False
+        ctx._deferred_lock = asyncio.Lock()
+        ctx._deferred_attempts = 0
+        ctx._deferred_task = None
+        return ctx
+
+    @pytest.mark.asyncio
+    async def test_timeout_does_not_cancel_background_runner(self) -> None:
+        ctx = self._bare_context()
+        release = asyncio.Event()
+        init_calls = 0
+
+        async def _slow_init() -> None:
+            nonlocal init_calls
+            init_calls += 1
+            await release.wait()
+
+        ctx.initialize_deferred = _slow_init  # type: ignore[method-assign]
+
+        # Background waiter (daemon's _run_deferred_init analog)
+        background = asyncio.create_task(ctx._ensure_deferred())
+        await asyncio.sleep(0.01)  # let the runner task start
+        runner: Optional[asyncio.Task[None]] = ctx._deferred_task
+        assert runner is not None and not runner.done()
+
+        # Foreground bounded wait times out (engine_chat analog)
+        with pytest.raises(asyncio.TimeoutError):
+            await asyncio.wait_for(ctx._ensure_deferred(), timeout=0.05)
+
+        # The runner must survive the foreground timeout untouched
+        assert not runner.cancelled()
+        assert not runner.done()
+        assert init_calls == 1  # no duplicate initialization
+
+        # Completing the init unblocks the background waiter
+        release.set()
+        await asyncio.wait_for(background, timeout=1.0)
+        assert ctx._deferred_initialized is True
+        assert init_calls == 1
+
+        # Subsequent calls are cheap no-ops
+        await ctx._ensure_deferred()
+        assert init_calls == 1
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 4. Deferred DB work runs off the event loop (dedicated executor)
+# ═══════════════════════════════════════════════════════════════════════════
+
+
+class TestDeferredDbExecutor:
+    """Blocking DuckDB work must not freeze the event loop.
+
+    Asserted behaviorally below: scanning ``initialize_deferred``'s source for
+    ``_run_deferred_db`` occurrences would pin the current call-site layout
+    rather than the contract — that a blocking DB call keeps the loop
+    responsive and that ``status()`` still answers while the DB worker is busy.
+    """
+
+    @pytest.mark.asyncio
+    async def test_event_loop_stays_responsive_during_blocking_db_op(self) -> None:
+        ctx = Context.__new__(Context)
+        ctx._deferred_db_executor = None
+
+        ticks: List[float] = []
+        stop = asyncio.Event()
+
+        async def _ticker() -> None:
+            while not stop.is_set():
+                ticks.append(time.monotonic())
+                await asyncio.sleep(0.01)
+
+        ticker_task = asyncio.create_task(_ticker())
+        try:
+            start = time.monotonic()
+            result = await ctx._run_deferred_db(lambda: (time.sleep(0.3), 42)[1])
+            elapsed = time.monotonic() - start
+            assert result == 42
+            # Windows' monotonic clock quantizes to ~15.6ms, so the measured
+            # interval can read a few ms short of the blocking sleep itself.
+            assert elapsed >= 0.3 - 0.03
+        finally:
+            stop.set()
+            await ticker_task
+            executor = ctx._deferred_db_executor
+            if executor is not None:
+                executor.shutdown(wait=True)
+
+        # The loop must have kept scheduling the ticker while the blocking
+        # sleep ran in the executor thread: gaps stay well under 100ms.
+        in_window = [t for t in ticks if start <= t <= start + 0.3]
+        assert len(in_window) >= 3, (
+            f"event loop starved during blocking DB op: only {len(in_window)} "
+            "ticker iterations observed in the 300ms window"
+        )
+        gaps = [b - a for a, b in zip(in_window, in_window[1:])]
+        assert gaps and max(gaps) < 0.1, (
+            f"event loop stalled for {max(gaps) if gaps else 0:.3f}s during "
+            "the blocking DB operation"
+        )
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 5. Daemon control-plane responsiveness during deferred init
+# ═══════════════════════════════════════════════════════════════════════════
+
+
+class TestDaemonControlPlaneResponsiveness:
+    """Status/recovery RPCs must get scheduling priority over background init."""
+
+    @pytest.mark.asyncio
+    async def test_service_deferred_runner_yields_before_initialization(self) -> None:
+        order: list[str] = []
+
+        class FakeContext:
+            async def _ensure_deferred(self) -> None:
+                order.append("deferred")
+
+        async def _peer_control_plane_task() -> None:
+            order.append("peer")
+
+        service = RuntimeLeapService.__new__(RuntimeLeapService)
+        deferred = asyncio.create_task(service._run_deferred_init(FakeContext()))
+        peer = asyncio.create_task(_peer_control_plane_task())
+
+        await asyncio.gather(deferred, peer)
+
+        assert order == ["peer", "deferred"]
+
+    @pytest.mark.asyncio
+    async def test_status_returns_while_deferred_db_worker_is_busy(self, tmp_path: Path) -> None:
+        from conftest import make_settings
+        from types import SimpleNamespace
+
+        settings = make_settings(str(tmp_path))
+        service = RuntimeLeapService(settings, mock_host=True)
+        ctx = Context.__new__(Context)
+        ctx.settings = settings
+        ctx.engine = None
+        ctx._db_holder = SimpleNamespace(db_path=settings.duckdb_path)
+        ctx._deferred_initialized = False
+        ctx._deferred_lock = asyncio.Lock()
+        ctx._deferred_attempts = 0
+        ctx._deferred_task = None
+        ctx._deferred_db_executor = None
+
+        async def _slow_init() -> None:
+            await ctx._run_deferred_db(lambda: time.sleep(0.25))
+
+        ctx.initialize_deferred = _slow_init  # type: ignore[method-assign]
+        service._ctx = ctx
+        service._deferred_init_task = asyncio.create_task(service._run_deferred_init(ctx))
+        try:
+            for _ in range(50):
+                runner = getattr(ctx, "_deferred_task", None)
+                if runner is not None and not runner.done():
+                    break
+                await asyncio.sleep(0.01)
+            assert ctx._deferred_task is not None and not ctx._deferred_task.done()
+
+            status = await asyncio.wait_for(service.status(), timeout=0.1)
+
+            assert status["deferred_init"]["running"] is True
+            assert status["deferred_init"]["initialized"] is False
+        finally:
+            await service._deferred_init_task
+            executor = getattr(ctx, "_deferred_db_executor", None)
+            if executor is not None:
+                executor.shutdown(wait=True)
diff --git a/tests/test_daemon_rpc.py b/tests/test_daemon_rpc.py
index 67793bd..54adccd 100644
--- a/tests/test_daemon_rpc.py
+++ b/tests/test_daemon_rpc.py
@@ -20,7 +20,7 @@
 
 
 def _short_tempdir() -> str:
-    """Base directory for temp runtime dirs holding ``leapd.sock``.
+    """Base directory for temp runtime dirs holding ``leapd.sock`` or ``leapd.port``.
 
     AF_UNIX socket paths cap near 108 chars, and macOS's default TMPDIR
     (/var/folders/...) is too long, so POSIX keeps /tmp; Windows has no
@@ -125,7 +125,7 @@ async def engine_chat(self, message: str, **kwargs: Any) -> AsyncIterator[Stream
 async def _start_server(runtime_dir: Path, service=None, *, stream_heartbeat_s: float | None = None):
     server = UnixRpcServer(
         service or _FakeService(),
-        sock_path=runtime_dir / "leapd.sock",
+        sock_path=get_transport().readiness_path(runtime_dir),
         runtime_dir=runtime_dir,
         stream_heartbeat_s=stream_heartbeat_s,
     )
@@ -143,7 +143,8 @@ async def _start_server(runtime_dir: Path, service=None, *, stream_heartbeat_s:
 async def test_daemon_client_receives_stream_events() -> None:
     with tempfile.TemporaryDirectory(prefix="lfd-", dir=_short_tempdir()) as root:
         server, task, runtime_dir = await _start_server(Path(root) / "runtime")
-        client = DaemonClient(runtime_dir / "leapd.sock")
+        socket_path = get_transport().readiness_path(runtime_dir)
+        client = DaemonClient(socket_path)
 
         try:
             events = [event async for event in client.engine_chat("world")]
@@ -167,7 +168,8 @@ async def test_daemon_server_injects_rpc_request_id_into_engine_chat() -> None:
     with tempfile.TemporaryDirectory(prefix="lfd-", dir=_short_tempdir()) as root:
         service = _RequestIdCaptureService()
         server, task, runtime_dir = await _start_server(Path(root) / "runtime", service=service)
-        client = DaemonClient(runtime_dir / "leapd.sock")
+        socket_path = get_transport().readiness_path(runtime_dir)
+        client = DaemonClient(socket_path)
 
         try:
             events = [event async for event in client.engine_chat("world")]
@@ -593,7 +595,8 @@ async def test_daemon_client_can_cancel_engine_turn() -> None:
     with tempfile.TemporaryDirectory(prefix="lfd-", dir=_short_tempdir()) as root:
         service = _FakeService()
         server, task, runtime_dir = await _start_server(Path(root) / "runtime", service=service)
-        client = DaemonClient(runtime_dir / "leapd.sock")
+        socket_path = get_transport().readiness_path(runtime_dir)
+        client = DaemonClient(socket_path)
 
         try:
             cancelled = await client.engine_cancel()
@@ -617,7 +620,8 @@ async def test_daemon_client_stream_heartbeat_prevents_idle_timeout() -> None:
             service=_SlowFirstChunkService(),
             stream_heartbeat_s=0.03,
         )
-        client = DaemonClient(runtime_dir / "leapd.sock", timeout_s=0.1)
+        socket_path = get_transport().readiness_path(runtime_dir)
+        client = DaemonClient(socket_path, timeout_s=0.1)
 
         try:
             events = [event async for event in client.engine_chat("world")]
@@ -647,7 +651,8 @@ async def test_dispatch_stream_keeps_contextvar_token_valid_across_chunks() -> N
         server, task, runtime_dir = await _start_server(
             Path(root) / "runtime", service=_ContextVarStreamingService(),
         )
-        client = DaemonClient(runtime_dir / "leapd.sock")
+        socket_path = get_transport().readiness_path(runtime_dir)
+        client = DaemonClient(socket_path)
         events = []
         try:
             async for event in client.engine_chat("hi"):
@@ -1003,7 +1008,8 @@ def reload_runtime_config_if_changed(self) -> bool:
         server, task, runtime_dir = await _start_server(Path(root) / "runtime", service=service)
 
         async def consume(session_id: str, decision: str) -> list[str]:
-            client = DaemonClient(runtime_dir / "leapd.sock")
+            socket_path = get_transport().readiness_path(runtime_dir)
+            client = DaemonClient(socket_path)
             contents: list[str] = []
             async for event in client.engine_chat("hi", session_id=session_id):
                 if event.type == "approval_request":
@@ -1088,7 +1094,8 @@ def reload_runtime_config_if_changed(self) -> bool:
         server, task, runtime_dir = await _start_server(Path(root) / "runtime", service=service)
 
         async def consume(session_id: str) -> list[tuple[str, str, dict[str, Any]]]:
-            client = DaemonClient(runtime_dir / "leapd.sock")
+            socket_path = get_transport().readiness_path(runtime_dir)
+            client = DaemonClient(socket_path)
             events: list[tuple[str, str, dict[str, Any]]] = []
             async for event in client.engine_chat("hi", session_id=session_id):
                 metadata = dict(event.metadata or {})
@@ -1235,7 +1242,7 @@ async def shutdown(self) -> None:
         shutdown_event = asyncio.Event()
         server = UnixRpcServer(
             service,
-            sock_path=runtime_dir / "leapd.sock",
+            sock_path=get_transport().readiness_path(runtime_dir),
             runtime_dir=runtime_dir,
             on_shutdown=shutdown_event.set,
         )
@@ -1248,7 +1255,8 @@ async def shutdown(self) -> None:
         else:
             task.cancel()
             raise AssertionError("server did not start")
-        client = DaemonClient(runtime_dir / "leapd.sock")
+        socket_path = get_transport().readiness_path(runtime_dir)
+        client = DaemonClient(socket_path)
         try:
             await client.shutdown()
             await asyncio.wait_for(shutdown_event.wait(), timeout=1.0)
@@ -1311,7 +1319,8 @@ async def host_restart(self) -> dict[str, Any]:
 
     with tempfile.TemporaryDirectory(prefix="lfd-", dir=_short_tempdir()) as root:
         server, task, runtime_dir = await _start_server(Path(root) / "runtime", service=HostRpcService())
-        client = DaemonClient(runtime_dir / "leapd.sock")
+        socket_path = get_transport().readiness_path(runtime_dir)
+        client = DaemonClient(socket_path)
         try:
             status = await client.host_status()
             started = await client.host_start()
@@ -1369,7 +1378,8 @@ async def app_command(self, args: str = "") -> dict[str, Any]:
 
     with tempfile.TemporaryDirectory(prefix="lfd-", dir=_short_tempdir()) as root:
         server, task, runtime_dir = await _start_server(Path(root) / "runtime", service=SlashMetadataService())
-        client = DaemonClient(runtime_dir / "leapd.sock")
+        socket_path = get_transport().readiness_path(runtime_dir)
+        client = DaemonClient(socket_path)
         try:
             tools = await client.tools_list()
             usage = await client.usage_summary()
@@ -1520,7 +1530,8 @@ async def approval_cancel(self, pending_id: str, reason: str = "cancelled") -> d
 
     with tempfile.TemporaryDirectory(prefix="lfd-", dir=_short_tempdir()) as root:
         server, task, runtime_dir = await _start_server(Path(root) / "runtime", service=ApprovalRpcService())
-        client = DaemonClient(runtime_dir / "leapd.sock")
+        socket_path = get_transport().readiness_path(runtime_dir)
+        client = DaemonClient(socket_path)
         try:
             result = await client.approval_resolve("p1", "allow_once", reason="user")
             status = await client.approval_status()
@@ -1542,7 +1553,8 @@ async def approval_cancel(self, pending_id: str, reason: str = "cancelled") -> d
 async def test_daemon_client_reports_unknown_method() -> None:
     with tempfile.TemporaryDirectory(prefix="lfd-", dir=_short_tempdir()) as root:
         server, task, runtime_dir = await _start_server(Path(root) / "runtime")
-        client = DaemonClient(runtime_dir / "leapd.sock")
+        socket_path = get_transport().readiness_path(runtime_dir)
+        client = DaemonClient(socket_path)
 
         try:
             with pytest.raises(DaemonUnavailableError, match="Unknown method"):
@@ -1567,7 +1579,7 @@ async def test_ensure_daemon_client_reuses_healthy_daemon() -> None:
 
         try:
             client = await ensure_daemon_client(settings)
-            assert client.sock_path == runtime_dir / "leapd.sock"
+            assert client.sock_path == get_transport().readiness_path(runtime_dir)
             status = await client.status()
         finally:
             task.cancel()
@@ -1587,7 +1599,8 @@ async def test_daemon_client_surfaces_stream_errors() -> None:
             Path(root) / "runtime",
             service=_FailingStreamService(),
         )
-        client = DaemonClient(runtime_dir / "leapd.sock")
+        socket_path = get_transport().readiness_path(runtime_dir)
+        client = DaemonClient(socket_path)
         events = []
 
         try:
@@ -1783,7 +1796,7 @@ async def test_ensure_daemon_client_does_not_spawn_when_daemon_unhealthy(
     settings = make_settings(str(tmp_path))
     unhealthy = DaemonInfo(
         pid=4321,
-        sock_path=settings.runtime_dir / "leapd.sock",
+        sock_path=get_transport().readiness_path(settings.runtime_dir),
         start_time=1.0,
         is_running=True,
         is_healthy=False,
@@ -1810,7 +1823,7 @@ async def test_recover_daemon_client_probes_rpc_and_force_restarts(
     from leapflow.daemon.lifecycle import StopDaemonResult
 
     settings = make_settings(str(tmp_path))
-    sock_path = settings.runtime_dir / "leapd.sock"
+    sock_path = get_transport().readiness_path(settings.runtime_dir)
     attempts = 0
 
     async def fake_ensure(*args, **kwargs):
@@ -1915,7 +1928,7 @@ def test_stop_daemon_sends_sigterm_waits_and_cleans(monkeypatch, tmp_path) -> No
 
     running = lifecycle_module.DaemonInfo(
         pid=1234,
-        sock_path=tmp_path / "runtime" / "leapd.sock",
+        sock_path=get_transport().readiness_path(tmp_path / "runtime"),
         start_time=None,
         is_running=True,
         is_healthy=True,
@@ -1954,7 +1967,7 @@ def test_stop_daemon_force_escalates_after_timeout(monkeypatch, tmp_path) -> Non
 
     running = lifecycle_module.DaemonInfo(
         pid=1234,
-        sock_path=tmp_path / "runtime" / "leapd.sock",
+        sock_path=get_transport().readiness_path(tmp_path / "runtime"),
         start_time=None,
         is_running=True,
         is_healthy=False,
@@ -1983,7 +1996,7 @@ def test_stop_daemon_narrates_progress(monkeypatch, tmp_path) -> None:
 
     running = lifecycle_module.DaemonInfo(
         pid=4885,
-        sock_path=tmp_path / "runtime" / "leapd.sock",
+        sock_path=get_transport().readiness_path(tmp_path / "runtime"),
         start_time=None,
         is_running=True,
         is_healthy=False,
diff --git a/tests/test_dev_terminal_tools.py b/tests/test_dev_terminal_tools.py
index ad0a122..64a0e95 100644
--- a/tests/test_dev_terminal_tools.py
+++ b/tests/test_dev_terminal_tools.py
@@ -7,6 +7,7 @@
 from __future__ import annotations
 
 import asyncio
+import sys
 
 from leapflow.tools import dev_tools
 from leapflow.tools import terminal_session as ts
@@ -113,18 +114,22 @@ def test_terminal_disabled_by_default() -> None:
 
 def test_terminal_session_lifecycle() -> None:
     ts.set_terminal_sessions_enabled(True)
+    sid = ""
     try:
         opened = _run(terminal_open({}))
-        assert opened["ok"] is True
+        assert opened["ok"] is True, opened
         sid = opened["session_id"]
 
-        sent = _run(terminal_send({"session_id": sid, "input": "echo hello-term", "wait": 0.6}))
+        # PowerShell cold-starts slowly (banner + profile + first prompt),
+        # especially under parallel xdist load; widen the capture budget there.
+        send_wait, read_wait, reads = (2.0, 1.0, 8) if sys.platform == "win32" else (0.6, 0.4, 5)
+        sent = _run(terminal_send({"session_id": sid, "input": "echo hello-term", "wait": send_wait}))
         assert sent["ok"] is True
         output = sent["output"]
-        for _ in range(5):
+        for _ in range(reads):
             if "hello-term" in output:
                 break
-            output += _run(terminal_read({"session_id": sid, "wait": 0.4}))["output"]
+            output += _run(terminal_read({"session_id": sid, "wait": read_wait}))["output"]
         assert "hello-term" in output
 
         listed = _run(terminal_list({}))
@@ -132,10 +137,13 @@ def test_terminal_session_lifecycle() -> None:
 
         closed = _run(terminal_close({"session_id": sid}))
         assert closed["ok"] is True and closed["closed"] is True
+        sid = ""
 
         after = _run(terminal_send({"session_id": sid, "input": "x"}))
         assert after["ok"] is False and after["failure_code"] == "session_not_found"
     finally:
+        if sid:
+            _run(terminal_close({"session_id": sid}))
         ts.set_terminal_sessions_enabled(False)
 
 
@@ -153,9 +161,9 @@ def test_terminal_max_sessions(monkeypatch) -> None:
     monkeypatch.setattr(ts, "_MAX_SESSIONS", 1)
     opened = _run(terminal_open({}))
     try:
-        assert opened["ok"] is True
+        assert opened["ok"] is True, opened
         second = _run(terminal_open({}))
         assert second["ok"] is False and second["failure_code"] == "too_many_sessions"
     finally:
-        _run(terminal_close({"session_id": opened["session_id"]}))
+        _run(terminal_close({"session_id": opened.get("session_id", "")}))
         ts.set_terminal_sessions_enabled(False)
diff --git a/tests/test_tool_call_hardening.py b/tests/test_tool_call_hardening.py
index c03dbe1..e98ae9b 100644
--- a/tests/test_tool_call_hardening.py
+++ b/tests/test_tool_call_hardening.py
@@ -1,356 +1,372 @@
-"""Tests for P0 tool-calling / result hardening in the agent loop:
-
-- A1: pre-execution required-argument validation (_validate_tool_arguments)
-- B2: structure-aware tool-result truncation (_truncate_result_for_budget)
-
-Both are pure module functions, exercised directly.
-"""
-from __future__ import annotations
-
-import asyncio
-import json
-
-from leapflow.engine.engine import (
-    _head_tail_truncate,
-    _truncate_result_for_budget,
-    _validate_tool_arguments,
-)
-from leapflow.tools.name_resolver import ToolSpec
-
-
-def _spec(name: str, required: set[str], params: set[str]) -> ToolSpec:
-    return ToolSpec(name=name, parameters=frozenset(params), required=frozenset(required))
-
-
-# ── A1: argument validation ──────────────────────────────────────────
-
-def test_validate_missing_required_returns_structured_error() -> None:
-    spec = _spec("edit_file", {"path"}, {"path", "edits", "diff"})
-    result = _validate_tool_arguments(spec, {"edits": []})  # path missing
-    assert result is not None
-    assert result["ok"] is False and result["error_type"] == "invalid_arguments"
-    assert result["missing"] == ["path"]
-    assert "path" in result["accepted_parameters"]
-    # Must not penalize failure budgets or trip the batch-stop gate.
-    assert result["counts_as_failure"] is False and result["retryable"] is True
-    assert "execution_policy" not in result
-
-
-def test_validate_present_required_passes() -> None:
-    spec = _spec("edit_file", {"path"}, {"path", "edits"})
-    assert _validate_tool_arguments(spec, {"path": "/x", "edits": []}) is None
-
-
-def test_validate_no_required_is_skipped() -> None:
-    spec = _spec("terminal_list", set(), set())
-    assert _validate_tool_arguments(spec, {}) is None
-
-
-def test_validate_present_but_empty_is_not_missing() -> None:
-    # Presence-only: an empty but present required value is the handler's concern
-    # (e.g. text_replace new="" is a valid delete), not a validation rejection.
-    spec = _spec("text_replace", {"text", "old", "new"}, {"text", "old", "new"})
-    assert _validate_tool_arguments(spec, {"text": "abc", "old": "a", "new": ""}) is None
-
-
-def test_validate_none_spec_is_skipped() -> None:
-    assert _validate_tool_arguments(None, {"anything": 1}) is None
-
-
-# ── B2: structure-aware truncation ───────────────────────────────────
-
-def test_truncate_within_budget_is_unchanged() -> None:
-    payload = {"ok": True, "stdout": "small output"}
-    text = _truncate_result_for_budget(payload, 1000)
-    assert json.loads(text) == payload
-
-
-def test_truncate_preserves_head_and_tail_of_large_field() -> None:
-    payload = {"ok": False, "stdout": "HEAD_MARKER" + ("x" * 6000) + "TAIL_ERROR"}
-    text = _truncate_result_for_budget(payload, 800)
-    assert len(text) <= 800
-    obj = json.loads(text)  # still valid JSON (shrank the field, not the JSON string)
-    assert "TAIL_ERROR" in obj["stdout"]   # the actual error at the tail survives
-    assert "HEAD_MARKER" in obj["stdout"]  # head survives
-    assert "elided" in obj["stdout"]       # explicit elision marker
-
-
-def test_truncate_nondict_payload_is_safe() -> None:
-    text = _truncate_result_for_budget("a very long string " * 100, 50)
-    assert len(text) <= 50
-
-
-def test_head_tail_truncate_keeps_both_ends() -> None:
-    text = "START" + ("m" * 1000) + "END"
-    out = _head_tail_truncate(text, 200)
-    assert out.startswith("START") and out.endswith("END") and "elided" in out
-    assert len(out) < len(text)
-
-
-def test_head_tail_truncate_short_text_unchanged() -> None:
-    assert _head_tail_truncate("short", 200) == "short"
-
-
-def test_truncate_list_field_pruned_and_annotated() -> None:
-    """List fields (e.g. file_list entries) must be pruned, not string-cut."""
-    entries = [{"name": f"file_{i}.py", "type": "file", "size": 1000} for i in range(80)]
-    payload = {"ok": True, "kind": "file_list_evidence", "path": "/proj", "entries": entries, "entry_count": 80}
-    text = _truncate_result_for_budget(payload, 1000)
-    obj = json.loads(text)  # must be valid JSON — not a raw string cut
-    assert obj["ok"] is True
-    assert len(obj["entries"]) < 80           # entries were pruned
-    assert "entries_omitted" in obj           # omission count is explicit
-    assert obj["entries_omitted"] + len(obj["entries"]) == 80
-
-
-def test_truncate_over_budget_dict_never_returns_malformed_json() -> None:
-    """When every shrinking strategy fails, a valid sentinel dict is returned."""
-    # A dict where string truncation alone cannot bring it under budget because
-    # the overhead fields themselves exceed the budget.
-    payload = {"ok": True, "kind": "file_list_evidence", "entries": [], "entry_count": 0,
-               "irreducible": "x" * 100}
-    text = _truncate_result_for_budget(payload, 80)  # budget is tiny
-    # Must parse as JSON (no raw cut)
-    obj = json.loads(text)
-    assert isinstance(obj, dict)
-
-
-def test_compaction_preserves_invalid_argument_repair_hints() -> None:
-    from leapflow.engine.context_control import ToolEvidenceBuilder
-    builder = ToolEvidenceBuilder()
-    invalid = {
-        "ok": False,
-        "error": "Invalid arguments for edit_file: missing required parameter(s): path",
-        "error_type": "invalid_arguments",
-        "missing": ["path"],
-        "accepted_parameters": ["diff", "edits", "path"],
-        "retryable": True,
-        "counts_as_failure": False,
-    }
-    compact = builder.build("edit_file", {}, invalid)
-    assert compact["error_type"] == "invalid_arguments"
-    assert compact["missing"] == ["path"]
-    assert compact["accepted_parameters"] == ["diff", "edits", "path"]
-
-
-def test_compaction_preserves_anchor_not_unique_match_count() -> None:
-    from leapflow.engine.context_control import ToolEvidenceBuilder
-    builder = ToolEvidenceBuilder()
-    result = {"ok": False, "error": "not unique", "error_type": "anchor_not_unique", "match_count": 3}
-    compact = builder.build("edit_file", {}, result)
-    assert compact["error_type"] == "anchor_not_unique" and compact["match_count"] == 3
-
-
-# ── failure visibility: stdout/stderr survive compaction; shell_run sets error ──
-
-def test_compact_error_preserves_shell_output() -> None:
-    """A failed shell result must keep stderr (the traceback) + returncode so the
-    agent can diagnose the cause instead of seeing a bare 'unknown error'."""
-    from leapflow.engine.context_control import ToolEvidenceBuilder
-    builder = ToolEvidenceBuilder()
-    failed = {
-        "ok": False,
-        "returncode": 1,
-        "stdout": "partial output",
-        "stderr": "Traceback (most recent call last):\n  ...\nModuleNotFoundError: No module named 'yfinance'",
-        "error": "ModuleNotFoundError: No module named 'yfinance'",
-    }
-    compact = builder.build("shell_run", {}, failed)
-    assert compact["ok"] is False and compact["returncode"] == 1
-    assert "ModuleNotFoundError" in compact["stderr"]   # traceback preserved
-    assert "yfinance" in compact["error"]
-
-
-def test_compact_error_preserves_stderr_without_error_field() -> None:
-    from leapflow.engine.context_control import ToolEvidenceBuilder
-    builder = ToolEvidenceBuilder()
-    result = {"ok": False, "returncode": 2, "stdout": "", "stderr": "boom: the real error"}
-    compact = builder.build("shell_run", {}, result)
-    assert "boom: the real error" in compact["stderr"] and compact["returncode"] == 2
-
-
-def test_shell_run_populates_error_on_failure() -> None:
-    from leapflow.tools.shell_tools import shell_run
-    result = asyncio.run(shell_run({"command": "echo BOOM_ERR 1>&2; exit 2"}))
-    assert result["ok"] is False and result["returncode"] == 2
-    assert "BOOM_ERR" in result["error"] and "BOOM_ERR" in result["stderr"]
-
-
-def test_shell_run_success_has_no_error_field() -> None:
-    from leapflow.tools.shell_tools import shell_run
-    result = asyncio.run(shell_run({"command": "echo ok"}))
-    assert result["ok"] is True and "error" not in result and "ok" in result["stdout"]
-
-
-def test_workspace_context_resolves_relative_paths_and_blocks_cross_workspace(tmp_path) -> None:
-    from leapflow.tools.execution_context import (
-        ToolExecutionContext,
-        reset_tool_context,
-        set_tool_context,
-    )
-    from leapflow.tools.file_operations import code_search, file_read
-    from leapflow.tools.repo_map import repo_map
-    from leapflow.tools.shell_tools import shell_run
-
-    workspace = tmp_path / "work"
-    other = tmp_path / "other"
-    workspace.mkdir()
-    other.mkdir()
-    (workspace / "alpha.txt").write_text("needle in workspace", encoding="utf-8")
-    (other / "secret.txt").write_text("needle outside", encoding="utf-8")
-
-    token = set_tool_context(
-        ToolExecutionContext.from_strings(
-            workspace_root=str(workspace),
-            session_id="sess-work",
-            task_id="turn-test",
-        )
-    )
-    try:
-        read_result = asyncio.run(file_read({"path": "alpha.txt"}))
-        assert read_result["ok"] is True
-        assert read_result["path"] == str((workspace / "alpha.txt").resolve())
-
-        search_result = asyncio.run(code_search({"pattern": "needle", "path": "."}))
-        assert search_result["ok"] is True
-        assert search_result["path"] == str(workspace.resolve())
-        assert search_result["match_count"] == 1
-
-        repo_result = asyncio.run(repo_map({"path": "."}))
-        assert repo_result["ok"] is True
-        assert repo_result["root"] == str(workspace.resolve())
-
-        shell_result = asyncio.run(shell_run({"command": "pwd"}))
-        assert shell_result["ok"] is True
-        assert shell_result["cwd"] == str(workspace.resolve())
-
-        blocked = asyncio.run(file_read({"path": str(other / "secret.txt")}))
-        assert blocked["ok"] is False
-        assert blocked["error_type"] == "outside_workspace"
-        assert blocked["workspace_root"] == str(workspace.resolve())
-
-        blocked_shell = asyncio.run(shell_run({"command": f"cat {other / 'secret.txt'}"}))
-        assert blocked_shell["ok"] is False
-        assert blocked_shell["error_type"] == "outside_workspace"
-        assert blocked_shell["workspace_root"] == str(workspace.resolve())
-    finally:
-        reset_tool_context(token)
-
-
-def test_shell_gate_blocks_expanded_and_relative_escapes(tmp_path, monkeypatch) -> None:
-    """The gate must judge the resolved target, not how the operand is spelled.
-
-    A guard that only inspects literal ``/``/``~`` operands passes ``$HOME/...``
-    and ``../../..`` straight through, so the same file is reachable by choosing
-    a different spelling and the workspace boundary stops being a boundary.
-    """
-    from leapflow.tools.execution_context import (
-        ToolExecutionContext,
-        reset_tool_context,
-        set_tool_context,
-    )
-    from leapflow.tools.shell_tools import shell_run
-
-    workspace = tmp_path / "work"
-    other = tmp_path / "other"
-    workspace.mkdir()
-    (workspace / "sub").mkdir()
-    other.mkdir()
-    (workspace / "alpha.txt").write_text("inside", encoding="utf-8")
-    (other / "secret.txt").write_text("outside", encoding="utf-8")
-    monkeypatch.setenv("LEAP_TEST_OUTSIDE", str(other))
-
-    token = set_tool_context(
-        ToolExecutionContext.from_strings(workspace_root=str(workspace), session_id="sess-gate")
-    )
-    try:
-        for command in (
-            "cat $LEAP_TEST_OUTSIDE/secret.txt",
-            "cat ${LEAP_TEST_OUTSIDE}/secret.txt",
-            "cat ../other/secret.txt",
-            "cat --file=$LEAP_TEST_OUTSIDE/secret.txt",
-            "cd $LEAP_TEST_OUTSIDE && cat secret.txt",
-        ):
-            result = asyncio.run(shell_run({"command": command}))
-            assert result["ok"] is False, command
-            assert result["error_type"] == "outside_workspace", command
-            assert result["resolved_path"].startswith(str(other.resolve())), command
-
-        # Traversal that stays inside must still run: the gate judges the resolved
-        # target, so `sub/../alpha.txt` is an ordinary in-workspace read.
-        inside = asyncio.run(shell_run({"command": "cat sub/../alpha.txt"}))
-        assert inside["ok"] is True
-        assert inside["stdout"].strip() == "inside"
-    finally:
-        reset_tool_context(token)
-
-
-def test_shell_gate_allows_search_list_variables(tmp_path, monkeypatch) -> None:
-    """Expanding a variable must not turn ordinary commands into refusals.
-
-    ``$PATH`` expands to an ``os.pathsep``-joined list that begins with ``/`` but
-    names no file. Treating that as a path operand blocked ``echo $PATH`` and
-    ``PATH=$PATH:./bin npm test``, which have nothing to do with the workspace
-    boundary.
-    """
-    from leapflow.tools.execution_context import (
-        ToolExecutionContext,
-        reset_tool_context,
-        set_tool_context,
-    )
-    from leapflow.tools.shell_tools import _command_workspace_escape
-
-    workspace = tmp_path / "work"
-    workspace.mkdir()
-    monkeypatch.setenv("PATH", "/usr/local/bin:/usr/bin:/bin")
-    monkeypatch.setenv("LEAP_TEST_HOME", str(tmp_path / "outside"))
-
-    token = set_tool_context(
-        ToolExecutionContext.from_strings(workspace_root=str(workspace), session_id="sess-list")
-    )
-    try:
-        for command in (
-            "echo $PATH",
-            "export PATH=$PATH:/usr/local/bin && make",
-            "PATH=$PATH:./node_modules/.bin npm test",
-        ):
-            assert _command_workspace_escape(command, cwd=workspace) is None, command
-
-        # A single-path variable must still be gated.
-        blocked = _command_workspace_escape("cat $LEAP_TEST_HOME/secret", cwd=workspace)
-        assert blocked is not None
-        assert blocked["error_type"] == "outside_workspace"
-    finally:
-        reset_tool_context(token)
-
-
-def test_shell_gate_redirects_leapflow_config_targets(tmp_path) -> None:
-    """Refusing a config path must name the capability that serves the goal.
-
-    Without the redirect the model only learns "not here" and moves the same
-    probe to another spelling, which is the loop the config tools exist to end.
-    """
-    from leapflow.tools.execution_context import (
-        ToolExecutionContext,
-        reset_tool_context,
-        set_tool_context,
-    )
-    from leapflow.tools.shell_tools import _command_workspace_escape
-    from leapflow.config import get_settings
-
-    workspace = tmp_path / "work"
-    workspace.mkdir()
-    config_path = get_settings().layout.global_config_dir / "user.yaml"
-
-    token = set_tool_context(
-        ToolExecutionContext.from_strings(workspace_root=str(workspace), session_id="sess-hint")
-    )
-    try:
-        error = _command_workspace_escape(f"cat {config_path}", cwd=workspace)
-    finally:
-        reset_tool_context(token)
-
-    assert error is not None
-    assert error["error_type"] == "outside_workspace"
-    assert "config_get" in error["error"]
-    assert "cannot be lifted by approval" in error["error"]
+"""Tests for P0 tool-calling / result hardening in the agent loop:
+
+- A1: pre-execution required-argument validation (_validate_tool_arguments)
+- B2: structure-aware tool-result truncation (_truncate_result_for_budget)
+
+Both are pure module functions, exercised directly.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+
+from leapflow.engine.engine import (
+    _head_tail_truncate,
+    _truncate_result_for_budget,
+    _validate_tool_arguments,
+)
+from leapflow.tools.name_resolver import ToolSpec
+
+
+def _spec(name: str, required: set[str], params: set[str]) -> ToolSpec:
+    return ToolSpec(name=name, parameters=frozenset(params), required=frozenset(required))
+
+
+# ── A1: argument validation ──────────────────────────────────────────
+
+def test_validate_missing_required_returns_structured_error() -> None:
+    spec = _spec("edit_file", {"path"}, {"path", "edits", "diff"})
+    result = _validate_tool_arguments(spec, {"edits": []})  # path missing
+    assert result is not None
+    assert result["ok"] is False and result["error_type"] == "invalid_arguments"
+    assert result["missing"] == ["path"]
+    assert "path" in result["accepted_parameters"]
+    # Must not penalize failure budgets or trip the batch-stop gate.
+    assert result["counts_as_failure"] is False and result["retryable"] is True
+    assert "execution_policy" not in result
+
+
+def test_validate_present_required_passes() -> None:
+    spec = _spec("edit_file", {"path"}, {"path", "edits"})
+    assert _validate_tool_arguments(spec, {"path": "/x", "edits": []}) is None
+
+
+def test_validate_no_required_is_skipped() -> None:
+    spec = _spec("terminal_list", set(), set())
+    assert _validate_tool_arguments(spec, {}) is None
+
+
+def test_validate_present_but_empty_is_not_missing() -> None:
+    # Presence-only: an empty but present required value is the handler's concern
+    # (e.g. text_replace new="" is a valid delete), not a validation rejection.
+    spec = _spec("text_replace", {"text", "old", "new"}, {"text", "old", "new"})
+    assert _validate_tool_arguments(spec, {"text": "abc", "old": "a", "new": ""}) is None
+
+
+def test_validate_none_spec_is_skipped() -> None:
+    assert _validate_tool_arguments(None, {"anything": 1}) is None
+
+
+# ── B2: structure-aware truncation ───────────────────────────────────
+
+def test_truncate_within_budget_is_unchanged() -> None:
+    payload = {"ok": True, "stdout": "small output"}
+    text = _truncate_result_for_budget(payload, 1000)
+    assert json.loads(text) == payload
+
+
+def test_truncate_preserves_head_and_tail_of_large_field() -> None:
+    payload = {"ok": False, "stdout": "HEAD_MARKER" + ("x" * 6000) + "TAIL_ERROR"}
+    text = _truncate_result_for_budget(payload, 800)
+    assert len(text) <= 800
+    obj = json.loads(text)  # still valid JSON (shrank the field, not the JSON string)
+    assert "TAIL_ERROR" in obj["stdout"]   # the actual error at the tail survives
+    assert "HEAD_MARKER" in obj["stdout"]  # head survives
+    assert "elided" in obj["stdout"]       # explicit elision marker
+
+
+def test_truncate_nondict_payload_is_safe() -> None:
+    text = _truncate_result_for_budget("a very long string " * 100, 50)
+    assert len(text) <= 50
+
+
+def test_head_tail_truncate_keeps_both_ends() -> None:
+    text = "START" + ("m" * 1000) + "END"
+    out = _head_tail_truncate(text, 200)
+    assert out.startswith("START") and out.endswith("END") and "elided" in out
+    assert len(out) < len(text)
+
+
+def test_head_tail_truncate_short_text_unchanged() -> None:
+    assert _head_tail_truncate("short", 200) == "short"
+
+
+def test_truncate_list_field_pruned_and_annotated() -> None:
+    """List fields (e.g. file_list entries) must be pruned, not string-cut."""
+    entries = [{"name": f"file_{i}.py", "type": "file", "size": 1000} for i in range(80)]
+    payload = {"ok": True, "kind": "file_list_evidence", "path": "/proj", "entries": entries, "entry_count": 80}
+    text = _truncate_result_for_budget(payload, 1000)
+    obj = json.loads(text)  # must be valid JSON — not a raw string cut
+    assert obj["ok"] is True
+    assert len(obj["entries"]) < 80           # entries were pruned
+    assert "entries_omitted" in obj           # omission count is explicit
+    assert obj["entries_omitted"] + len(obj["entries"]) == 80
+
+
+def test_truncate_over_budget_dict_never_returns_malformed_json() -> None:
+    """When every shrinking strategy fails, a valid sentinel dict is returned."""
+    # A dict where string truncation alone cannot bring it under budget because
+    # the overhead fields themselves exceed the budget.
+    payload = {"ok": True, "kind": "file_list_evidence", "entries": [], "entry_count": 0,
+               "irreducible": "x" * 100}
+    text = _truncate_result_for_budget(payload, 80)  # budget is tiny
+    # Must parse as JSON (no raw cut)
+    obj = json.loads(text)
+    assert isinstance(obj, dict)
+
+
+def test_compaction_preserves_invalid_argument_repair_hints() -> None:
+    from leapflow.engine.context_control import ToolEvidenceBuilder
+    builder = ToolEvidenceBuilder()
+    invalid = {
+        "ok": False,
+        "error": "Invalid arguments for edit_file: missing required parameter(s): path",
+        "error_type": "invalid_arguments",
+        "missing": ["path"],
+        "accepted_parameters": ["diff", "edits", "path"],
+        "retryable": True,
+        "counts_as_failure": False,
+    }
+    compact = builder.build("edit_file", {}, invalid)
+    assert compact["error_type"] == "invalid_arguments"
+    assert compact["missing"] == ["path"]
+    assert compact["accepted_parameters"] == ["diff", "edits", "path"]
+
+
+def test_compaction_preserves_anchor_not_unique_match_count() -> None:
+    from leapflow.engine.context_control import ToolEvidenceBuilder
+    builder = ToolEvidenceBuilder()
+    result = {"ok": False, "error": "not unique", "error_type": "anchor_not_unique", "match_count": 3}
+    compact = builder.build("edit_file", {}, result)
+    assert compact["error_type"] == "anchor_not_unique" and compact["match_count"] == 3
+
+
+# ── failure visibility: stdout/stderr survive compaction; shell_run sets error ──
+
+def test_compact_error_preserves_shell_output() -> None:
+    """A failed shell result must keep stderr (the traceback) + returncode so the
+    agent can diagnose the cause instead of seeing a bare 'unknown error'."""
+    from leapflow.engine.context_control import ToolEvidenceBuilder
+    builder = ToolEvidenceBuilder()
+    failed = {
+        "ok": False,
+        "returncode": 1,
+        "stdout": "partial output",
+        "stderr": "Traceback (most recent call last):\n  ...\nModuleNotFoundError: No module named 'yfinance'",
+        "error": "ModuleNotFoundError: No module named 'yfinance'",
+    }
+    compact = builder.build("shell_run", {}, failed)
+    assert compact["ok"] is False and compact["returncode"] == 1
+    assert "ModuleNotFoundError" in compact["stderr"]   # traceback preserved
+    assert "yfinance" in compact["error"]
+
+
+def test_compact_error_preserves_stderr_without_error_field() -> None:
+    from leapflow.engine.context_control import ToolEvidenceBuilder
+    builder = ToolEvidenceBuilder()
+    result = {"ok": False, "returncode": 2, "stdout": "", "stderr": "boom: the real error"}
+    compact = builder.build("shell_run", {}, result)
+    assert "boom: the real error" in compact["stderr"] and compact["returncode"] == 2
+
+
+def test_shell_run_populates_error_on_failure() -> None:
+    import os
+
+    from leapflow.tools.shell_tools import shell_run
+    # cmd.exe (the Windows shell backend) has no ';' separator; '&&' works on both.
+    joiner = "&&" if os.name == "nt" else ";"
+    result = asyncio.run(shell_run({"command": f"echo BOOM_ERR 1>&2 {joiner} exit 2"}))
+    assert result["ok"] is False and result["returncode"] == 2
+    assert "BOOM_ERR" in result["error"] and "BOOM_ERR" in result["stderr"]
+
+
+def test_shell_run_success_has_no_error_field() -> None:
+    from leapflow.tools.shell_tools import shell_run
+    result = asyncio.run(shell_run({"command": "echo ok"}))
+    assert result["ok"] is True and "error" not in result and "ok" in result["stdout"]
+
+
+def test_workspace_context_resolves_relative_paths_and_blocks_cross_workspace(tmp_path) -> None:
+    from leapflow.tools.execution_context import (
+        ToolExecutionContext,
+        reset_tool_context,
+        set_tool_context,
+    )
+    from leapflow.tools.file_operations import code_search, file_read
+    from leapflow.tools.repo_map import repo_map
+    from leapflow.tools.shell_tools import shell_run
+
+    workspace = tmp_path / "work"
+    other = tmp_path / "other"
+    workspace.mkdir()
+    other.mkdir()
+    (workspace / "alpha.txt").write_text("needle in workspace", encoding="utf-8")
+    (other / "secret.txt").write_text("needle outside", encoding="utf-8")
+
+    token = set_tool_context(
+        ToolExecutionContext.from_strings(
+            workspace_root=str(workspace),
+            session_id="sess-work",
+            task_id="turn-test",
+        )
+    )
+    try:
+        read_result = asyncio.run(file_read({"path": "alpha.txt"}))
+        assert read_result["ok"] is True
+        assert read_result["path"] == str((workspace / "alpha.txt").resolve())
+
+        search_result = asyncio.run(code_search({"pattern": "needle", "path": "."}))
+        assert search_result["ok"] is True
+        assert search_result["path"] == str(workspace.resolve())
+        assert search_result["match_count"] == 1
+
+        repo_result = asyncio.run(repo_map({"path": "."}))
+        assert repo_result["ok"] is True
+        assert repo_result["root"] == str(workspace.resolve())
+
+        pwd_command = "echo %CD%" if os.name == "nt" else "pwd"
+        shell_result = asyncio.run(shell_run({"command": pwd_command}))
+        assert shell_result["ok"] is True, shell_result
+        assert shell_result["cwd"] == str(workspace.resolve())
+
+        blocked = asyncio.run(file_read({"path": str(other / "secret.txt")}))
+        assert blocked["ok"] is False
+        assert blocked["error_type"] == "outside_workspace"
+        assert blocked["workspace_root"] == str(workspace.resolve())
+
+        blocked_shell = asyncio.run(shell_run({"command": f"cat {other / 'secret.txt'}"}))
+        assert blocked_shell["ok"] is False
+        assert blocked_shell["error_type"] == "outside_workspace"
+        assert blocked_shell["workspace_root"] == str(workspace.resolve())
+    finally:
+        reset_tool_context(token)
+
+
+def test_shell_gate_blocks_expanded_and_relative_escapes(tmp_path, monkeypatch) -> None:
+    """The gate must judge the resolved target, not how the operand is spelled.
+
+    A guard that only inspects literal ``/``/``~`` operands passes ``$HOME/...``
+    and ``../../..`` straight through, so the same file is reachable by choosing
+    a different spelling and the workspace boundary stops being a boundary.
+    """
+    from leapflow.tools.execution_context import (
+        ToolExecutionContext,
+        reset_tool_context,
+        set_tool_context,
+    )
+    from leapflow.tools.shell_tools import shell_run
+
+    import os
+
+    workspace = tmp_path / "work"
+    other = tmp_path / "other"
+    workspace.mkdir()
+    (workspace / "sub").mkdir()
+    other.mkdir()
+    (workspace / "alpha.txt").write_text("inside", encoding="utf-8")
+    (other / "secret.txt").write_text("outside", encoding="utf-8")
+    monkeypatch.setenv("LEAP_TEST_OUTSIDE", str(other))
+
+    token = set_tool_context(
+        ToolExecutionContext.from_strings(workspace_root=str(workspace), session_id="sess-gate")
+    )
+    try:
+        for command in (
+            "cat $LEAP_TEST_OUTSIDE/secret.txt",
+            "cat ${LEAP_TEST_OUTSIDE}/secret.txt",
+            "cat ../other/secret.txt",
+            "cat --file=$LEAP_TEST_OUTSIDE/secret.txt",
+            "cd $LEAP_TEST_OUTSIDE && cat secret.txt",
+        ):
+            result = asyncio.run(shell_run({"command": command}))
+            assert result["ok"] is False, command
+            assert result["error_type"] == "outside_workspace", command
+            assert result["resolved_path"].startswith(str(other.resolve())), command
+
+        # Traversal that stays inside must still run: the gate judges the resolved
+        # target, so `sub/../alpha.txt` is an ordinary in-workspace read, and the
+        # content must come back. On Windows no cmd-era builtin reads a '..'
+        # operand (Git's MSYS cat falls back to stdin and hangs, cmd's `type`
+        # rejects the path), so the read goes through PowerShell's Get-Content —
+        # as a command argument; the shell backend stays cmd.
+        if os.name == "nt":
+            command = 'powershell -NoProfile -Command "Get-Content sub/../alpha.txt"'
+        else:
+            command = "cat sub/../alpha.txt"
+        inside = asyncio.run(shell_run({"command": command}))
+        assert inside["ok"] is True
+        assert inside["stdout"].strip() == "inside"
+    finally:
+        reset_tool_context(token)
+
+
+def test_shell_gate_allows_search_list_variables(tmp_path, monkeypatch) -> None:
+    """Expanding a variable must not turn ordinary commands into refusals.
+
+    ``$PATH`` expands to an ``os.pathsep``-joined list that begins with ``/`` but
+    names no file. Treating that as a path operand blocked ``echo $PATH`` and
+    ``PATH=$PATH:./bin npm test``, which have nothing to do with the workspace
+    boundary.
+    """
+    from leapflow.tools.execution_context import (
+        ToolExecutionContext,
+        reset_tool_context,
+        set_tool_context,
+    )
+    from leapflow.tools.shell_tools import _command_workspace_escape
+
+    workspace = tmp_path / "work"
+    workspace.mkdir()
+    monkeypatch.setenv("PATH", "/usr/local/bin:/usr/bin:/bin")
+    monkeypatch.setenv("LEAP_TEST_HOME", str(tmp_path / "outside"))
+
+    token = set_tool_context(
+        ToolExecutionContext.from_strings(workspace_root=str(workspace), session_id="sess-list")
+    )
+    try:
+        for command in (
+            "echo $PATH",
+            "export PATH=$PATH:/usr/local/bin && make",
+            "PATH=$PATH:./node_modules/.bin npm test",
+        ):
+            assert _command_workspace_escape(command, cwd=workspace) is None, command
+
+        # A single-path variable must still be gated.
+        blocked = _command_workspace_escape("cat $LEAP_TEST_HOME/secret", cwd=workspace)
+        assert blocked is not None
+        assert blocked["error_type"] == "outside_workspace"
+    finally:
+        reset_tool_context(token)
+
+
+def test_shell_gate_redirects_leapflow_config_targets(tmp_path) -> None:
+    """Refusing a config path must name the capability that serves the goal.
+
+    Without the redirect the model only learns "not here" and moves the same
+    probe to another spelling, which is the loop the config tools exist to end.
+    """
+    from leapflow.tools.execution_context import (
+        ToolExecutionContext,
+        reset_tool_context,
+        set_tool_context,
+    )
+    from leapflow.tools.shell_tools import _command_workspace_escape
+    from leapflow.config import get_settings
+
+    workspace = tmp_path / "work"
+    workspace.mkdir()
+    config_path = get_settings().layout.global_config_dir / "user.yaml"
+
+    token = set_tool_context(
+        ToolExecutionContext.from_strings(workspace_root=str(workspace), session_id="sess-hint")
+    )
+    try:
+        error = _command_workspace_escape(f"cat {config_path}", cwd=workspace)
+    finally:
+        reset_tool_context(token)
+
+    assert error is not None
+    assert error["error_type"] == "outside_workspace"
+    assert "config_get" in error["error"]
+    assert "cannot be lifted by approval" in error["error"]
diff --git a/tools/impact.py b/tools/impact.py
index 51fc76d..237aee1 100644
--- a/tools/impact.py
+++ b/tools/impact.py
@@ -193,7 +193,7 @@ def test_modules_importing(modules: set[str]) -> set[str]:
                 for name in names
                 for module in modules
             ):
-                selected.add(str(path.relative_to(REPO_ROOT)))
+                selected.add(path.relative_to(REPO_ROOT).as_posix())
                 break
     return selected
 
@@ -338,7 +338,7 @@ def journey_metadata() -> list[JourneyMeta]:
                 continue
         found.append(
             JourneyMeta(
-                path=str(path.relative_to(REPO_ROOT)),
+                path=path.relative_to(REPO_ROOT).as_posix(),
                 subject_paths=subjects,
                 live_signal=live,
             )
@@ -451,7 +451,7 @@ def build_map() -> int:
         if not test_file.endswith(".py"):
             continue
         try:
-            relative = str(Path(file_path).resolve().relative_to(REPO_ROOT))
+            relative = Path(file_path).resolve().relative_to(REPO_ROOT).as_posix()
         except ValueError:
             continue
         mapping.setdefault(test_file, set()).add(relative)

From feacecac8e2f57222dc8fadb49670e3373b5f67e Mon Sep 17 00:00:00 2001
From: fanqiNO1 <1848839264@qq.com>
Date: Fri, 7 Aug 2026 13:24:21 +0800
Subject: [PATCH 3/4] fix CRLF to LF

---
 src/leapflow/cli/commands/slash_handlers.py | 4274 +++++++++----------
 src/leapflow/dashboard/intent.py            |   86 +-
 tests/test_code_tools.py                    |  974 ++---
 tests/test_daemon_event_loop_blocking.py    |  712 +--
 tests/test_tool_call_hardening.py           |  744 ++--
 5 files changed, 3395 insertions(+), 3395 deletions(-)

diff --git a/src/leapflow/cli/commands/slash_handlers.py b/src/leapflow/cli/commands/slash_handlers.py
index e2724b0..d0ce849 100644
--- a/src/leapflow/cli/commands/slash_handlers.py
+++ b/src/leapflow/cli/commands/slash_handlers.py
@@ -1,2137 +1,2137 @@
-"""Slash-command handler implementations.
-
-Each handler follows the signature ``(ctx, console, args) -> None``.
-All display logic uses ``LeapConsole`` for consistent theming.
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-import shlex
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from leapflow.cli.context import Context
-    from leapflow.cli.tui_app.console import LeapConsole
-
-
-logger = logging.getLogger(__name__)
-
-
-def build_tool_payload(ctx: "Context") -> dict[str, Any]:
-    """Build a serializable tool summary for local or daemon rendering."""
-    from leapflow.cli.banner import _categorize_tools
-    from leapflow.tools.registry_bootstrap import TOOL_DEFINITIONS
-
-    tool_groups = _categorize_tools(TOOL_DEFINITIONS)
-    groups = {category: sorted(names) for category, names in tool_groups.items()}
-    mcp_count = 0
-    if hasattr(ctx.rpc, "connected") and ctx.rpc.connected:
-        mcp_count = len(getattr(ctx, "platform_tools", []))
-    return {
-        "ok": True,
-        "groups": groups,
-        "total": sum(len(names) for names in groups.values()),
-        "mcp_count": mcp_count,
-    }
-
-
-def render_tool_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    """Render a serializable tool summary."""
-    from rich.table import Table
-
-    if not payload.get("ok", True):
-        console.warning(str(payload.get("error") or "Tools are not available."))
-        return
-
-    groups = dict(payload.get("groups") or {})
-    table = Table(
-        title="Available Tools",
-        show_header=True,
-        header_style="bold",
-        border_style="bright_black",
-        title_style="bold cyan",
-        padding=(0, 1),
-    )
-    table.add_column("Category", style="cyan", no_wrap=True)
-    table.add_column("Tools")
-
-    for category, names in groups.items():
-        table.add_row(str(category), ", ".join(sorted(str(name) for name in names)))
-
-    mcp_count = int(payload.get("mcp_count") or 0)
-    if mcp_count > 0:
-        table.add_row("mcp", f"{mcp_count} platform tools")
-
-    console.print(table)
-    console.system(f"{int(payload.get('total') or 0)} tools available")
-
-
-def build_usage_payload(ctx: "Context") -> dict[str, Any]:
-    """Build a serializable token usage summary."""
-    engine = ctx.engine
-    if engine is None:
-        return {"ok": False, "error": "No active engine — send a message first."}
-
-    tracker = getattr(engine, "usage_tracker", None)
-    if tracker is None:
-        return {"ok": False, "error": "Usage tracking not available."}
-
-    summary = tracker.summary()
-    cap_registry = getattr(engine, "model_capabilities", None)
-    context_length = 0
-    if cap_registry is not None:
-        caps = cap_registry.resolve(ctx.settings.llm_model)
-        context_length = int(caps.context_length)
-
-    return {
-        "ok": True,
-        "model": ctx.settings.llm_model,
-        "prompt_tokens": int(summary.prompt_tokens),
-        "completion_tokens": int(summary.completion_tokens),
-        "total_tokens": int(summary.total_tokens),
-        "turn_count": int(getattr(engine, "turn_count", 0)),
-        "context_used": int(getattr(engine, "context_token_count", 0)),
-        "context_length": context_length,
-    }
-
-
-def render_usage_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    """Render a serializable token usage summary."""
-    from leapflow.cli.tui_app.status import _compact_tokens
-
-    if not payload.get("ok", True):
-        console.warning(str(payload.get("error") or "Usage tracking not available."))
-        return
-
-    console.print()
-    prompt_tokens = int(payload.get("prompt_tokens") or 0)
-    completion_tokens = int(payload.get("completion_tokens") or 0)
-    total_tokens = int(payload.get("total_tokens") or 0)
-    turn_count = int(payload.get("turn_count") or 0)
-    context_used = int(payload.get("context_used") or 0)
-    context_length = int(payload.get("context_length") or 0)
-    lines = [
-        f"  Model:           {payload.get('model') or ''}",
-        f"  Input tokens:    {_compact_tokens(prompt_tokens):>8}  ({prompt_tokens:,})",
-        f"  Output tokens:   {_compact_tokens(completion_tokens):>8}  ({completion_tokens:,})",
-        f"  Total tokens:    {_compact_tokens(total_tokens):>8}  ({total_tokens:,})",
-        f"  Turns:           {turn_count}",
-    ]
-    if context_length > 0:
-        pct = int(context_used * 100 / context_length)
-        lines.append(
-            f"  Context:         {_compact_tokens(context_used)}/{_compact_tokens(context_length)} ({pct}%)"
-        )
-    for line in lines:
-        console.system(line)
-    console.print()
-
-
-def build_model_payload(ctx: "Context", args: str = "") -> dict[str, Any]:
-    """Build a serializable model summary or update the active model."""
-    model_arg = args.strip()
-    if model_arg:
-        payload = build_config_payload(ctx, f"llm set --model {shlex.quote(model_arg)}")
-        payload["view"] = "model"
-        payload["requested_model"] = model_arg
-        return payload
-
-    engine = ctx.engine
-    context_length = 0
-    if engine is not None:
-        cap_registry = getattr(engine, "model_capabilities", None)
-        if cap_registry is not None:
-            caps = cap_registry.resolve(ctx.settings.llm_model)
-            context_length = int(caps.context_length)
-    return {
-        "ok": True,
-        "view": "model",
-        "model": ctx.settings.llm_model,
-        "context_length": context_length,
-        "requested_model": "",
-    }
-
-
-def render_model_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    """Render a serializable model summary."""
-    if not payload.get("ok", True):
-        console.warning(str(payload.get("error") or payload.get("message") or "Model information is not available."))
-        return
-    requested = str(payload.get("requested_model") or "")
-    model = str(payload.get("model") or "")
-    if requested:
-        console.success(f"Model updated: {model}")
-        if payload.get("reloaded"):
-            console.system("Configuration reloaded for this session.")
-        return
-
-    console.system(f"Current model: {model}")
-    context_length = int(payload.get("context_length") or 0)
-    if context_length > 0:
-        console.system(f"Context length: {context_length:,}")
-
-
-def build_config_payload(ctx: "Context", args: str = "") -> dict[str, Any]:
-    """Execute a config command and return a serializable payload."""
-    from leapflow.config_service import ConfigService
-
-    service = ConfigService(ctx.settings)
-    try:
-        from leapflow.utils.shell_lex import split_args
-
-        tokens = split_args(args)
-    except ValueError as exc:
-        return {"ok": False, "message": f"Invalid /config syntax: {exc}"}
-    if not tokens:
-        tokens = ["show"]
-    action = tokens[0]
-    try:
-        if action == "show":
-            if len(tokens) > 1:
-                return {
-                    "ok": True,
-                    "view": "config",
-                    "mode": "show_detail",
-                    "field": _config_field_to_dict(service.describe(tokens[1])),
-                }
-            return _config_snapshot_payload(service)
-        if action == "keys":
-            return {"ok": True, "view": "config", "mode": "keys", "sources": list(service.writable_keys())}
-        if action == "list":
-            category = tokens[1] if len(tokens) > 1 and not tokens[1].startswith("--") else None
-            return {"ok": True, "view": "config", "mode": "list", "fields": [_config_field_to_dict(item) for item in service.list_fields(category)]}
-        if action == "sources":
-            return {"ok": True, "view": "config", "mode": "sources", "sources": list(service.sources())}
-        if action == "get" and len(tokens) == 2:
-            value = service.get(tokens[1])
-            return {"ok": True, "view": "config", "mode": "get", "values": [_config_value_to_dict(value)]}
-        if action == "set" and len(tokens) >= 3:
-            scope = _option_value(tokens[3:], "--scope", "profile")
-            result = service.set(tokens[1], tokens[2], scope=scope)  # type: ignore[arg-type]
-            return _config_mutation_payload(ctx, service, result)
-        if action == "unset" and len(tokens) >= 2:
-            scope = _option_value(tokens[2:], "--scope", "profile")
-            result = service.unset(tokens[1], scope=scope)  # type: ignore[arg-type]
-            return _config_mutation_payload(ctx, service, result)
-        if action == "llm":
-            return _build_llm_config_payload(ctx, service, tokens[1:])
-        if action == "secret":
-            return _build_secret_config_payload(ctx, service, tokens[1:])
-    except (KeyError, ValueError, RuntimeError) as exc:
-        return {"ok": False, "message": f"Config error: {exc}"}
-    return {"ok": False, "message": "Usage: /config [show|list|keys|sources|get|set|unset|llm|secret] ..."}
-
-
-_CONFIG_LIST_COMPACT_WIDTH = 92
-_CONFIG_LIST_FULL_WIDTH = 118
-
-
-def _display_width(console: object, default: int = 100) -> int:
-    """Return the active Rich console width with a safe fallback for tests."""
-    width = getattr(console, "width", None)
-    if isinstance(width, int) and width > 0:
-        return width
-    raw = getattr(console, "raw", None)
-    raw_width = getattr(raw, "width", None)
-    if isinstance(raw_width, int) and raw_width > 0:
-        return raw_width
-    return default
-
-
-def _shorten(text: object, limit: int) -> str:
-    """Shorten a cell value before Rich allocates table columns."""
-    value = str(text) if text is not None else ""
-    if limit <= 0:
-        return ""
-    if len(value) <= limit:
-        return value
-    return value[: max(1, limit - 1)] + "…"
-
-
-def _config_scope_text(item: dict[str, Any], *, limit: int) -> str:
-    scopes = ",".join(str(scope) for scope in item.get("scopes") or [])
-    return _shorten(scopes, limit)
-
-
-def _config_reload_text(item: dict[str, Any]) -> str:
-    value = item.get("hot_reload")
-    if isinstance(value, bool):
-        return "yes" if value else "no"
-    return str(value) if value is not None and str(value) else "no"
-
-
-def _config_meta_text(item: dict[str, Any], *, scope_limit: int) -> str:
-    parts = [str(item.get("type") or "?")]
-    scope = _config_scope_text(item, limit=scope_limit)
-    if scope:
-        parts.append(scope)
-    parts.append(f"reload:{_config_reload_text(item)}")
-    return " · ".join(parts)
-
-
-def _build_config_list_table(console: object, fields: list[dict[str, Any]]) -> object:
-    """Build a width-aware config list table for TUI rendering."""
-    from rich.table import Table
-
-    width = _display_width(console)
-    table = Table(title="Writable config fields", show_lines=False, expand=True)
-    if width < _CONFIG_LIST_COMPACT_WIDTH:
-        table.add_column("Key", no_wrap=True, overflow="ellipsis", max_width=32, ratio=2)
-        table.add_column("Value", overflow="fold", max_width=24, ratio=1)
-        table.add_column("Meta", overflow="fold", max_width=24, ratio=1)
-        for item in fields:
-            table.add_row(
-                _shorten(item.get("key"), 36),
-                _shorten(item.get("value"), 32),
-                _config_meta_text(item, scope_limit=14),
-            )
-        return table
-
-    if width < _CONFIG_LIST_FULL_WIDTH:
-        table.add_column("Key", no_wrap=True, overflow="ellipsis", max_width=34, ratio=2)
-        table.add_column("Value", overflow="fold", max_width=30, ratio=1)
-        table.add_column("Type", no_wrap=True, max_width=8)
-        table.add_column("Scope", no_wrap=True, overflow="ellipsis", max_width=18)
-        table.add_column("Reload", no_wrap=True, max_width=6)
-        for item in fields:
-            table.add_row(
-                _shorten(item.get("key"), 38),
-                _shorten(item.get("value"), 40),
-                str(item.get("type") or ""),
-                _config_scope_text(item, limit=18),
-                _config_reload_text(item),
-            )
-        return table
-
-    table.add_column("Key", no_wrap=True, overflow="ellipsis", max_width=36, ratio=2)
-    table.add_column("Value", overflow="fold", max_width=36, ratio=1)
-    table.add_column("Type", no_wrap=True, max_width=10)
-    table.add_column("Scope", no_wrap=True, overflow="ellipsis", max_width=22)
-    table.add_column("Reload", no_wrap=True, max_width=6)
-    table.add_column("Description", overflow="fold", ratio=2)
-    for item in fields:
-        table.add_row(
-            _shorten(item.get("key"), 42),
-            _shorten(item.get("value"), 48),
-            str(item.get("type") or ""),
-            _config_scope_text(item, limit=22),
-            _config_reload_text(item),
-            str(item.get("description") or ""),
-        )
-    return table
-
-
-def render_config_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    """Render config command output."""
-    if not payload.get("ok", True):
-        console.warning(str(payload.get("message") or "Config command failed."))
-        return
-    mode = str(payload.get("mode") or "show")
-    if mode in {"sources", "keys"}:
-        label = "Writable config keys" if mode == "keys" else "Config sources"
-        sources = [str(source) for source in payload.get("sources") or []]
-        if not sources:
-            console.system(f"No {label.lower()} found.")
-            return
-        console.system(f"{label}:")
-        for source in sources:
-            console.system(f"  {source}")
-        return
-    if mode == "list":
-        fields = [dict(item) for item in payload.get("fields") or []]
-        if not fields:
-            console.system("No writable config fields found.")
-            return
-        console.print(_build_config_list_table(console, fields))
-        console.system("Use /config show <key>, /config get <key>, /config set <key> <value>, or /config keys for compact output.")
-        return
-    if mode == "show_detail":
-        field = dict(payload.get("field") or {})
-        if not field:
-            console.warning("No config field details found.")
-            return
-        from rich.panel import Panel
-        from rich.text import Text
-
-        details = Text()
-        details.append(f"value: {field.get('value') or ''}\n")
-        details.append(f"type: {field.get('type') or ''}\n")
-        details.append(f"category: {field.get('category') or ''}\n")
-        details.append(f"scope: {','.join(str(scope) for scope in field.get('scopes') or [])}\n")
-        details.append(f"reload: {field.get('hot_reload') or ''}\n")
-        details.append(f"secret: {'true' if field.get('secret') else 'false'}\n")
-        value_hint = str(field.get("value_hint") or "")
-        if value_hint:
-            details.append(f"value hint: {value_hint}\n")
-        details.append(f"description: {field.get('description') or ''}")
-        examples = [str(example) for example in field.get("examples") or []]
-        if examples:
-            details.append(f"\nexample: {examples[0]}")
-        console.print(Panel(details, title=str(field.get("key") or "Config field"), border_style="cyan"))
-        return
-    if mode == "mutation":
-        console.success(str(payload.get("message") or "Config updated."))
-        for key in payload.get("changed_keys") or []:
-            console.system(f"  {key}")
-        warnings = payload.get("warnings") or []
-        for warning in warnings:
-            console.warning(str(warning))
-        if payload.get("reloaded"):
-            console.system("Configuration reloaded for this session.")
-        return
-    values = payload.get("values") or []
-    if values:
-        for item in values:
-            console.system(f"{item.get('key')}={item.get('value')}")
-    warnings = payload.get("warnings") or []
-    for warning in warnings:
-        console.warning(str(warning))
-
-
-def _config_snapshot_payload(service: Any) -> dict[str, Any]:
-    snapshot = service.snapshot()
-    return {
-        "ok": True,
-        "view": "config",
-        "mode": "show",
-        "values": [_config_value_to_dict(value) for value in snapshot.values],
-        "sources": list(snapshot.sources),
-        "warnings": list(snapshot.warnings),
-    }
-
-
-def _config_value_to_dict(value: Any) -> dict[str, Any]:
-    return {"key": value.key, "value": value.value, "source": value.source, "secret": value.secret}
-
-
-def _config_field_to_dict(value: Any) -> dict[str, Any]:
-    return {
-        "key": value.key,
-        "value": value.value,
-        "type": value.value_type,
-        "category": value.category,
-        "scopes": list(value.scopes),
-        "hot_reload": value.hot_reload,
-        "secret": value.secret,
-        "description": value.description,
-        "value_hint": value.value_hint,
-        "examples": list(value.examples),
-    }
-
-
-def _build_llm_config_payload(ctx: "Context", service: Any, tokens: list[str]) -> dict[str, Any]:
-    action = tokens[0] if tokens else "show"
-    if action == "show":
-        payload = _config_snapshot_payload(service)
-        payload["values"] = [item for item in payload["values"] if str(item.get("key") or "").startswith("llm.")]
-        return payload
-    if action != "set":
-        return {"ok": False, "message": "Usage: /config llm [show|set --model NAME --base-url URL --api-key KEY]"}
-    options = tokens[1:]
-    if "--ask-api-key" in options:
-        return {"ok": False, "message": "Use `leap config llm key` in a terminal for secure API key prompts."}
-    result = service.configure_llm(
-        api_key=_option_value(options, "--api-key"),
-        base_url=_option_value(options, "--base-url"),
-        model=_option_value(options, "--model"),
-        context_length=_option_int(options, "--context-length"),
-        max_retries=_option_int(options, "--max-retries"),
-        scope=_option_value(options, "--scope", "profile"),
-    )
-    return _config_mutation_payload(ctx, service, result)
-
-
-def _build_secret_config_payload(ctx: "Context", service: Any, tokens: list[str]) -> dict[str, Any]:
-    action = tokens[0] if tokens else "list"
-    if action == "list":
-        return {"ok": True, "view": "config", "mode": "sources", "sources": list(service.list_secrets())}
-    if action == "set" and len(tokens) >= 3:
-        scope = _option_value(tokens[3:], "--scope", "profile")
-        result = service.set_secret(tokens[1], tokens[2], scope=scope)  # type: ignore[arg-type]
-        return _config_mutation_payload(ctx, service, result)
-    if action == "get" and len(tokens) >= 2:
-        scope = _option_value(tokens[2:], "--scope", "profile")
-        reveal = "--reveal" in tokens[2:]
-        value = service.get_secret(tokens[1], scope=scope, reveal=reveal)  # type: ignore[arg-type]
-        return {"ok": True, "view": "config", "mode": "get", "values": [{"key": tokens[1], "value": value, "secret": not reveal}]}
-    if action == "delete" and len(tokens) >= 2:
-        scope = _option_value(tokens[2:], "--scope", "profile")
-        result = service.delete_secret(tokens[1], scope=scope)  # type: ignore[arg-type]
-        return _config_mutation_payload(ctx, service, result)
-    return {"ok": False, "message": "Usage: /config secret [list|set|get|delete] ..."}
-
-
-def _config_mutation_payload(ctx: "Context", service: Any, result: Any) -> dict[str, Any]:
-    reloaded = False
-    if result.changed_keys:
-        reloaded = bool(ctx.reload_runtime_config_if_changed(force=True))
-    return {
-        "ok": bool(result.ok),
-        "view": "config",
-        "mode": "mutation",
-        "message": result.message,
-        "changed_keys": list(result.changed_keys),
-        "warnings": list(getattr(result, "warnings", ()) or ()),
-        "reloaded": reloaded,
-        # Runtime values the status bar renders. A daemon-mode TUI is a separate
-        # process and cannot see the reload, so it needs them echoed back here;
-        # context length travels with the model because switching models usually
-        # changes it too.
-        "model": ctx.settings.llm_model,
-        "llm_context_length": int(getattr(ctx.settings, "llm_context_length", 0) or 0),
-    }
-
-
-def _option_value(tokens: list[str], option: str, default: str | None = None) -> str | None:
-    if option not in tokens:
-        return default
-    index = tokens.index(option)
-    if index + 1 >= len(tokens):
-        raise ValueError(f"Missing value for {option}")
-    return tokens[index + 1]
-
-
-def _option_int(tokens: list[str], option: str) -> int | None:
-    value = _option_value(tokens, option)
-    return int(value) if value is not None else None
-
-
-def handle_status(ctx: "Context", console: "LeapConsole", args: str) -> None:
-    """Display session status: model, context, platform, session info."""
-    from rich.panel import Panel
-    from rich.text import Text
-
-    info = Text()
-
-    info.append("Model:     ", style="dim")
-    info.append(f"{ctx.settings.llm_model}\n", style="bold")
-
-    engine = ctx.engine
-    if engine is not None:
-        cap_registry = getattr(engine, "model_capabilities", None)
-        ctx_len = 0
-        if cap_registry is not None:
-            caps = cap_registry.resolve(ctx.settings.llm_model)
-            ctx_len = caps.context_length
-        ctx_used = getattr(engine, "context_token_count", 0)
-        turn_count = getattr(engine, "turn_count", 0)
-
-        if ctx_len:
-            pct = int(ctx_used * 100 / ctx_len) if ctx_len else 0
-            info.append("Context:   ", style="dim")
-            pct_style = "bold red" if pct >= 90 else ("yellow" if pct >= 75 else "")
-            info.append(f"{ctx_used:,} / {ctx_len:,} ({pct}%)\n", style=pct_style)
-
-        info.append("Turns:     ", style="dim")
-        info.append(f"{turn_count}\n")
-
-    platform_status = "connected" if (hasattr(ctx.rpc, "connected") and ctx.rpc.connected) else "mock"
-    info.append("Platform:  ", style="dim")
-    p_style = "green" if platform_status == "connected" else "dim"
-    info.append(f"{platform_status}\n", style=p_style)
-
-    cwd = os.getcwd().replace(os.path.expanduser("~"), "~")
-    info.append("CWD:       ", style="dim")
-    info.append(f"{cwd}\n")
-
-    info.append("Profile:   ", style="dim")
-    info.append(f"{ctx.settings.profile}\n")
-
-    info.append("Config:    ", style="dim")
-    info.append(f"{str(ctx.settings.profile_layout.config_dir).replace(os.path.expanduser('~'), '~')}\n")
-
-    user_config = str(ctx.settings.layout.user_config_path).replace(os.path.expanduser("~"), "~")
-    info.append("User cfg:  ", style="dim")
-    info.append(f"{user_config}\n")
-
-    workspace_config = str(ctx.settings.workspace_root / ".leapflow" / "config.yaml")
-    info.append("Workspace: ", style="dim")
-    info.append(f"{workspace_config.replace(os.path.expanduser('~'), '~')}\n")
-
-    session_id = getattr(ctx.session, "session_id", "")
-    if session_id:
-        info.append("Session:   ", style="dim")
-        info.append(f"{session_id}\n")
-
-    from leapflow.engine.session import SessionMode
-    mode = "idle"
-    if ctx.session:
-        if ctx.session.mode == SessionMode.LEARNING:
-            mode = "learning"
-        elif ctx.session.mode == SessionMode.EXECUTING:
-            mode = "executing"
-    info.append("Mode:      ", style="dim")
-    info.append(f"{mode}\n")
-
-    gw = getattr(ctx, "gateway_server", None)
-    if gw is not None:
-        statuses = gw.platform_status()
-        connected = [s for s in statuses if s.connected]
-        info.append("Gateway:   ", style="dim")
-        if connected:
-            names = []
-            for s in connected:
-                m = gw.manifests.get(s.platform_id)
-                names.append(m.display_name if m else s.platform_id)
-            info.append(f"{', '.join(names)}\n", style="green")
-        else:
-            info.append("no connections\n", style="dim")
-
-    console.print(Panel(
-        info,
-        title="[bold cyan]LeapFlow Status[/]",
-        border_style="bright_black",
-        padding=(0, 2),
-    ))
-
-
-def handle_tool(ctx: "Context", console: "LeapConsole", args: str) -> None:
-    """Display available tools grouped by category."""
-    render_tool_payload(console, build_tool_payload(ctx))
-
-
-def handle_usage(ctx: "Context", console: "LeapConsole", args: str) -> None:
-    """Display token usage for the current session."""
-    render_usage_payload(console, build_usage_payload(ctx))
-
-
-def handle_model(ctx: "Context", console: "LeapConsole", args: str) -> None:
-    """Show or switch the active model."""
-    render_model_payload(console, build_model_payload(ctx, args))
-
-
-def handle_config(ctx: "Context", console: "LeapConsole", args: str) -> None:
-    """View or update runtime configuration."""
-    render_config_payload(console, build_config_payload(ctx, args))
-
-
-def handle_gateway(ctx: "Context", console: "LeapConsole", args: str) -> None:
-    """Display gateway status: connected platforms, available integrations."""
-    from rich.panel import Panel
-    from rich.text import Text
-
-    gw = getattr(ctx, "gateway_server", None)
-    if gw is None:
-        console.warning("Gateway not initialised.")
-        return
-
-    statuses = gw.platform_status()
-    if not statuses:
-        console.system("No platform manifests discovered.")
-        return
-
-    info = Text()
-    connected = [s for s in statuses if s.connected]
-    configured = [s for s in statuses if not s.connected and s.error == "configured but not connected"]
-    available = [s for s in statuses if not s.connected and not s.error]
-
-    import time
-
-    if connected:
-        info.append("Connected\n", style="bold green")
-        for s in connected:
-            m = gw.manifests.get(s.platform_id)
-            name = m.display_name if m else s.platform_id
-            uptime = ""
-            if s.connected_since > 0:
-                secs = int(time.time() - s.connected_since)
-                if secs < 60:
-                    uptime = f" ({secs}s)"
-                elif secs < 3600:
-                    uptime = f" ({secs // 60}m)"
-                else:
-                    uptime = f" ({secs // 3600}h {(secs % 3600) // 60}m)"
-            info.append(f"  ● {name}{uptime}\n", style="green")
-
-    if configured:
-        info.append("Configured (not connected)\n", style="bold yellow")
-        for s in configured:
-            m = gw.manifests.get(s.platform_id)
-            name = m.display_name if m else s.platform_id
-            info.append(f"  ○ {name}\n", style="yellow")
-
-    if available:
-        info.append("Available\n", style="bold dim")
-        names = [gw.manifests[s.platform_id].display_name for s in available if s.platform_id in gw.manifests]
-        info.append(f"  {', '.join(names)}\n", style="dim")
-
-    info.append("\n", style="dim")
-    info.append('Say "connect to <platform>" to set up a new integration.', style="dim italic")
-
-    console.print(Panel(
-        info,
-        title="[bold cyan]Gateway[/]",
-        border_style="bright_black",
-        padding=(0, 2),
-    ))
-
-
-def _app_usage() -> dict[str, Any]:
-    return {
-        "ok": False,
-        "error": "Usage: /app [platform] | /app status [platform] | /app connect <platform> [--option value] | /app disconnect <platform> | /app remove <platform> | /app events [status|start|stop] <platform> | /app actions <platform>",
-        "next_actions": ("/app", "/app <platform>", "/app status <platform>"),
-    }
-
-
-def _parse_app_options(tokens: list[str]) -> tuple[dict[str, str], str]:
-    options: dict[str, str] = {}
-    index = 0
-    while index < len(tokens):
-        token = tokens[index]
-        if not token.startswith("--") or token == "--":
-            return {}, f"Unexpected argument: {token}"
-        key_value = token[2:]
-        if "=" in key_value:
-            key, value = key_value.split("=", 1)
-            if not key:
-                return {}, f"Invalid option: {token}"
-            options[key] = value
-            index += 1
-            continue
-        if index + 1 >= len(tokens):
-            return {}, f"Missing value for option: {token}"
-        key = key_value
-        if not key:
-            return {}, f"Invalid option: {token}"
-        options[key] = tokens[index + 1]
-        index += 2
-    return options, ""
-
-
-def _parse_app_params(args: str) -> dict[str, Any]:
-    try:
-        from leapflow.utils.shell_lex import split_args
-
-        tokens = split_args(args)
-    except ValueError as exc:
-        return {"ok": False, "error": f"Invalid /app arguments: {exc}"}
-
-    if not tokens or tokens[0].lower() == "list":
-        if len(tokens) > 1:
-            return _app_usage()
-        return {"ok": True, "params": {"action": "list"}, "view": "list"}
-
-    head = tokens[0].lower()
-    if head == "status":
-        if len(tokens) > 2:
-            return _app_usage()
-        params: dict[str, Any] = {"action": "status"}
-        if len(tokens) == 2:
-            params["platform"] = tokens[1].lower()
-        return {"ok": True, "params": params, "view": "status"}
-
-    if head == "connect":
-        if len(tokens) < 2:
-            return _app_usage()
-        options, error = _parse_app_options(tokens[2:])
-        if error:
-            return {
-                "ok": False,
-                "error": error,
-                "next_actions": ("/app connect <platform> --<option> <value>",),
-            }
-        params = {"action": "connect", "platform": tokens[1].lower()}
-        if options:
-            params["options"] = options
-        return {"ok": True, "params": params, "view": "connect"}
-
-    if head in {"disconnect", "remove"}:
-        if len(tokens) != 2:
-            return _app_usage()
-        return {
-            "ok": True,
-            "params": {"action": head, "platform": tokens[1].lower()},
-            "view": head,
-        }
-
-    if head == "events":
-        if len(tokens) == 2:
-            return {
-                "ok": True,
-                "params": {"action": "events_status", "platform": tokens[1].lower()},
-                "view": "events",
-            }
-        if len(tokens) == 3 and tokens[1].lower() in {"status", "start", "stop"}:
-            event_action = tokens[1].lower()
-            action = "events_status" if event_action == "status" else f"events_{event_action}"
-            return {
-                "ok": True,
-                "params": {"action": action, "platform": tokens[2].lower()},
-                "view": "events",
-            }
-        return _app_usage()
-
-    if head == "actions":
-        if len(tokens) != 2:
-            return _app_usage()
-        return {"ok": True, "platform": tokens[1].lower(), "view": "actions"}
-
-    if len(tokens) == 1:
-        return {
-            "ok": True,
-            "params": {"action": "guide", "platform": tokens[0].lower()},
-            "view": "guide",
-        }
-
-    return _app_usage()
-
-
-def _resolve_app_platform(gw: Any, platform: str) -> tuple[str, str]:
-    if not platform:
-        return "", ""
-    manifests = getattr(gw, "manifests", {}) or {}
-    if platform in manifests:
-        return platform, ""
-    folded = platform.casefold()
-    matches = [pid for pid in manifests if str(pid).casefold() == folded]
-    if len(matches) == 1:
-        return matches[0], ""
-    return "", f"Unknown platform: {platform}"
-
-
-def _available_app_ids(gw: Any) -> list[str]:
-    manifests = getattr(gw, "manifests", {}) or {}
-    return sorted(str(platform_id) for platform_id in manifests)
-
-
-def _coerce_app_option(field: Any, value: str) -> tuple[Any, str]:
-    choices = tuple(getattr(field, "choices", ()) or ())
-    if choices and value not in choices:
-        return None, f"Invalid value for --{field.key}: {value}. Choices: {', '.join(map(str, choices))}"
-
-    field_type = str(getattr(field, "field_type", "string") or "string").lower()
-    if field_type in {"string", "choice"}:
-        return value, ""
-    if field_type in {"integer", "int"}:
-        try:
-            return int(value), ""
-        except ValueError:
-            return None, f"Invalid integer for --{field.key}: {value}"
-    if field_type in {"number", "float"}:
-        try:
-            return float(value), ""
-        except ValueError:
-            return None, f"Invalid number for --{field.key}: {value}"
-    if field_type in {"boolean", "bool"}:
-        lowered = value.casefold()
-        if lowered in {"1", "true", "yes", "on"}:
-            return True, ""
-        if lowered in {"0", "false", "no", "off"}:
-            return False, ""
-        return None, f"Invalid boolean for --{field.key}: {value}"
-    return value, ""
-
-
-def _validate_app_options(manifest: Any, options: dict[str, str]) -> tuple[dict[str, Any], str]:
-    if not options:
-        return {}, ""
-    fields = {str(field.key): field for field in getattr(manifest, "options", ())}
-    unknown = sorted(key for key in options if key not in fields)
-    if unknown:
-        available = ", ".join(sorted(fields)) or "no options"
-        return {}, f"Unknown option(s): {', '.join(unknown)}. Available options: {available}"
-
-    coerced: dict[str, Any] = {}
-    for key, value in options.items():
-        converted, error = _coerce_app_option(fields[key], value)
-        if error:
-            return {}, error
-        coerced[key] = converted
-    return coerced, ""
-
-
-async def build_app_payload(ctx: "Context", args: str = "") -> dict[str, Any]:
-    """Build a serializable App Connector slash-command payload."""
-    gw = getattr(ctx, "gateway_server", None)
-    if gw is None:
-        return {
-            "ok": False,
-            "error": "Gateway is not initialised in this session.",
-            "next_actions": ("Start an in-process LeapFlow session", "Use /help to inspect runtime support"),
-        }
-
-    parsed = _parse_app_params(args)
-    if not parsed.get("ok"):
-        parsed.setdefault("available", _available_app_ids(gw))
-        return parsed
-
-    from leapflow.tools.gateway_tool import platform_action_capability_summary, platform_connect_handler, set_gateway_server
-
-    set_gateway_server(gw)
-    if parsed.get("view") == "actions":
-        platform, error = _resolve_app_platform(gw, str(parsed.get("platform") or ""))
-        if error:
-            return {"ok": False, "error": error, "available": _available_app_ids(gw)}
-        manifest = gw.manifests.get(platform)
-        if manifest is None:
-            return {"ok": False, "error": f"Unknown platform: {platform}", "available": _available_app_ids(gw)}
-        actions = dict(getattr(manifest, "actions", {}) or {})
-        action_summaries = platform_action_capability_summary(platform)
-        return {
-            "ok": True,
-            "view": "actions",
-            "platform": platform,
-            "name": getattr(manifest, "display_name", platform),
-            "action_pack": str(actions.get("pack") or ""),
-            "actions": [item["name"] for item in action_summaries if item.get("name")],
-            "action_details": action_summaries,
-        }
-
-    params = dict(parsed.get("params") or {})
-    platform = str(params.get("platform") or "")
-    if platform:
-        resolved, error = _resolve_app_platform(gw, platform)
-        if error:
-            return {"ok": False, "error": error, "available": _available_app_ids(gw)}
-        params["platform"] = resolved
-        manifest = gw.manifests.get(resolved)
-        if manifest is not None and params.get("action") == "connect":
-            options, option_error = _validate_app_options(
-                manifest,
-                dict(params.get("options") or {}),
-            )
-            if option_error:
-                return {
-                    "ok": False,
-                    "error": option_error,
-                    "available": _available_app_ids(gw),
-                    "next_actions": (f"/app {resolved}", f"/app connect {resolved}"),
-                }
-            if options:
-                params["options"] = options
-
-    result = await platform_connect_handler(params)
-    view = str(parsed.get("view") or "")
-    if params.get("action") == "connect" and result.get("setup_guide"):
-        view = "guide"
-    return {
-        "ok": bool(result.get("ok")),
-        "view": view,
-        "params": params,
-        "result": result,
-    }
-
-
-def _append_result_metadata(lines: list[str], result: dict[str, Any]) -> None:
-    diagnostics = result.get("diagnostics") or result.get("metadata")
-    if isinstance(diagnostics, dict) and diagnostics:
-        for key in ("backend_kind", "profile", "identity", "auth_status", "configured", "current_mode"):
-            if diagnostics.get(key) is not None:
-                lines.append(f"  {key}: {diagnostics[key]}")
-    recovery_hint = result.get("recovery_hint")
-    if recovery_hint:
-        lines.append(f"  recovery: {recovery_hint}")
-    next_steps = result.get("next_steps")
-    if isinstance(next_steps, list) and next_steps:
-        lines.append("  next steps:")
-        lines.extend(f"    - {step}" for step in next_steps)
-
-
-def render_app_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    """Render a serializable App Connector slash-command payload."""
-    from rich.panel import Panel
-    from rich.table import Table
-    from rich.text import Text
-
-    if not payload.get("ok"):
-        result = dict(payload.get("result") or {})
-        message = (
-            payload.get("error")
-            or result.get("error")
-            or result.get("detail")
-            or "App command failed."
-        )
-        console.warning(str(message))
-        lines: list[str] = []
-        _append_result_metadata(lines, result)
-        for line in lines:
-            console.system(line)
-        available = payload.get("available")
-        if isinstance(available, list) and available:
-            console.system("Available: " + ", ".join(str(item) for item in available))
-        for action in payload.get("next_actions") or ():
-            console.system(f"  → {action}")
-        return
-
-    result = dict(payload.get("result") or {})
-    view = str(payload.get("view") or "")
-    if view == "list":
-        platforms = list(result.get("platforms") or [])
-        table = Table(title="App Connector", show_header=True, header_style="bold", border_style="bright_black")
-        table.add_column("App", style="cyan")
-        table.add_column("ID", style="bold")
-        table.add_column("State")
-        table.add_column("Category")
-        table.add_column("Next")
-        for entry in platforms:
-            platform_id = str(entry.get("id") or "")
-            state = str(entry.get("state") or "available")
-            style = "green" if state == "connected" else ("yellow" if state == "configured" else "dim")
-            table.add_row(
-                str(entry.get("name") or platform_id),
-                platform_id,
-                f"[{style}]{state}[/]",
-                str(entry.get("category") or ""),
-                f"/app {platform_id}",
-            )
-        console.print(table)
-        console.system("Next: /app <platform> · /app status <platform> · /app connect <platform>")
-        return
-
-    if view == "guide":
-        info = Text()
-        info.append(str(result.get("setup_guide") or "No setup guide available.") + "\n")
-        steps = result.get("setup_steps") or []
-        if steps:
-            info.append("\nSteps\n", style="bold")
-            for index, step in enumerate(steps, start=1):
-                info.append(f"  {index}. {step}\n")
-        preflight = result.get("preflight_checks") or []
-        if preflight:
-            info.append("\nPreflight\n", style="bold")
-            for check in preflight:
-                command = check.get("command") or ""
-                label = check.get("label") or check.get("key") or "check"
-                info.append(f"  - {label}: {command}\n")
-        fields = result.get("required_fields") or []
-        if fields:
-            info.append("\nRequired fields\n", style="bold")
-            for field in fields:
-                required = "required" if field.get("required") else "optional"
-                info.append(f"  - {field.get('key')}: {field.get('label')} ({required})\n")
-        console_url = result.get("console_url")
-        if console_url:
-            info.append(f"\nConsole: {console_url}\n", style="dim")
-        platform = str(result.get("platform") or payload.get("params", {}).get("platform") or "App")
-        console.print(Panel(info, title=f"[bold cyan]{platform} setup[/]", border_style="bright_black", padding=(0, 2)))
-        platform_id = str(payload.get("params", {}).get("platform") or "<platform>")
-        if fields:
-            console.system(
-                "Next: provide required credentials through the guided chat flow, "
-                f"then run /app connect {platform_id}"
-            )
-        else:
-            console.system(f"Next: /app connect {platform_id}")
-        return
-
-    if view == "status":
-        platforms = result.get("platforms")
-        if isinstance(platforms, list):
-            table = Table(title="App Status", show_header=True, header_style="bold", border_style="bright_black")
-            table.add_column("ID", style="bold")
-            table.add_column("Connected")
-            table.add_column("Detail")
-            for entry in platforms:
-                detail = str(entry.get("error") or entry.get("uptime") or "available")
-                table.add_row(str(entry.get("id") or ""), "yes" if entry.get("connected") else "no", detail)
-            console.print(table)
-            return
-        lines = [f"platform: {result.get('platform')}", f"connected: {bool(result.get('connected'))}"]
-        if result.get("error"):
-            lines.append(f"detail: {result['error']}")
-        if result.get("uptime"):
-            lines.append(f"uptime: {result['uptime']}")
-        _append_result_metadata(lines, result)
-        console.print(Panel("\n".join(lines), title="[bold cyan]App Status[/]", border_style="bright_black", padding=(0, 2)))
-        return
-
-    if view == "actions":
-        action_names = list(payload.get("actions") or [])
-        action_details = list(payload.get("action_details") or [])
-        lines = [f"platform: {payload.get('name')}"]
-        if payload.get("action_pack"):
-            lines.append(f"action pack: {payload['action_pack']}")
-        if action_names:
-            lines.append("registered actions:")
-            details_by_name = {str(item.get("name")): item for item in action_details}
-            for name in action_names:
-                detail = details_by_name.get(name, {})
-                description = str(detail.get("description") or "").strip()
-                suffix = f" — {description}" if description else ""
-                lines.append(f"  - {name}{suffix}")
-        else:
-            lines.append("registered actions: none")
-        console.print(Panel("\n".join(lines), title="[bold cyan]App Actions[/]", border_style="bright_black", padding=(0, 2)))
-        return
-
-    if result.get("ok"):
-        platform = result.get("platform") or payload.get("params", {}).get("platform") or "App"
-        status = result.get("status") or result.get("detail") or "ok"
-        lines = [f"{platform}: {status}"]
-        _append_result_metadata(lines, result)
-        console.success("App command completed")
-        console.system("\n".join(lines))
-        return
-
-    message = result.get("error") or result.get("detail") or "App command failed."
-    console.warning(str(message))
-    lines: list[str] = []
-    _append_result_metadata(lines, result)
-    for line in lines:
-        console.system(line)
-
-
-async def handle_app(ctx: "Context", console: "LeapConsole", args: str) -> None:
-    """Manage external App Connector integrations from slash commands."""
-    render_app_payload(console, await build_app_payload(ctx, args))
-
-
-# NOTE: screen clearing is owned by ``LeapApp.clear_screen()``. It must go
-# through the prompt_toolkit renderer that owns the TTY — a shell ``clear``
-# leaves the renderer's cursor cache stale and misplaces the next redraw — so
-# there is deliberately no clear handler here.
-
-
-# ══════════════════════════════════════════════════════════════════════
-# Unified command_execute: dispatches any engine-routed slash command
-# ══════════════════════════════════════════════════════════════════════
-
-
-def build_orient_payload(ctx: "Context") -> dict[str, Any]:
-    """Read-only unified orientation view (S4-D1) + pending re-entry status.
-
-    Surfaces what the agent is currently oriented on (immediate / working /
-    long-term layers, weight-ranked) plus any armed/due re-entry triggers.
-    Observe-only; changes no state.
-    """
-    engine = ctx.engine
-    if engine is None:
-        return {"ok": False, "error": "No active engine — send a message first."}
-    view_fn = getattr(engine, "orientation_view", None)
-    if view_fn is None:
-        return {"ok": False, "error": "Orientation view not available."}
-    orientation = view_fn()
-    lines = ["Orientation (immediate / working / long-term):"]
-    items = orientation.top(12)
-    if not items:
-        lines.append("  (empty — no active findings or open questions yet)")
-    else:
-        lines.extend(f"  - ({it.layer}) {it.text}" for it in items)
-    store = getattr(ctx, "_reentry_store", None)
-    if store is not None:
-        try:
-            import time as _time
-            armed = store.list_armed_events()
-            due = store.list_due(_time.time())
-            lines.append(f"Re-entry: {len(armed)} armed event trigger(s), {len(due)} due now.")
-        except Exception:
-            pass
-    return {
-        "ok": True,
-        "message": "\n".join(lines),
-        "orientation": orientation.summary(),
-    }
-
-
-async def command_execute(
-    ctx: "Context", name: str, args: str = "", session_id: str = "",
-) -> dict[str, Any]:
-    """Execute a slash command and return a serializable result payload.
-
-    This is the unified entry point for daemon-mode command execution.
-    Returns a dict with at minimum ``ok`` and ``message`` keys, plus
-    optional structured data for rich TUI rendering. ``session_id`` identifies
-    the calling client's session for commands that observe it (e.g. ``/board``).
-    """
-    if name == "status":
-        return build_status_payload(ctx)
-    if name == "orient":
-        return build_orient_payload(ctx)
-    if name == "tool":
-        return build_tool_payload(ctx)
-    if name == "usage":
-        return build_usage_payload(ctx)
-    if name == "model":
-        return build_model_payload(ctx, args)
-    if name == "config":
-        return build_config_payload(ctx, args)
-    if name == "gateway":
-        return build_gateway_payload(ctx)
-    if name == "host":
-        return await _execute_host(ctx, args)
-    if _is_app_command_name(name):
-        app_args = name[len("app"):].strip()
-        if app_args:
-            app_args = app_args + (" " + args if args else "")
-        else:
-            app_args = args
-        return await build_app_payload(ctx, app_args)
-    if name.startswith("teach") or name == "annotate":
-        return await _execute_teach(ctx, name, args)
-    if name == "skill" or name.startswith("skill "):
-        return _execute_skill(ctx, name, args)
-    if name.startswith("hub"):
-        return await _execute_hub(ctx, name, args)
-    if name == "run":
-        return {"ok": True, "stream": True, "prompt": args}
-    if name == "arm":
-        return await _execute_scheduler_arm(ctx, args)
-    if name == "task":
-        return _execute_scheduler_task(ctx)
-    if name == "board" or name.startswith("board "):
-        return await _execute_dashboard(ctx, name, args, session_id=session_id)
-    return {"ok": False, "message": f"Unknown command: /{name}"}
-
-
-async def _ensure_session_watch_refresh(
-    ctx: "Context", monitors: Any, session_id: str = "",
-) -> str:
-    """Ensure an active session watch exists and trigger one analysis cycle.
-
-    The analysis producer is LLM-backed and can take tens of seconds, so it is
-    scheduled in the background: arming the watch and opening the board must be
-    instant and must never block the command RPC past its timeout. The board
-    receives the resulting finding over WebSocket when the cycle completes.
-    ``session_id`` binds the watch to the caller's session so the analysis reads
-    that conversation rather than whichever session was last active.
-    Returns the session watch id.
-    """
-    from leapflow.monitor.session_producer import ensure_session_watch, session_watch_params
-
-    params = session_watch_params(getattr(ctx, "settings", None))
-    if session_id:
-        params["session_id"] = session_id
-    watch_id = await ensure_session_watch(monitors, params=params)
-    monitors.schedule_watch_once(watch_id, force=True)
-    return watch_id
-
-
-_BOARD_VERBS = frozenset({"templates", "refresh", "pause", "resume", "stop", "status"})
-
-# States in which a watch can still be paused/resumed/stopped (i.e. not terminal).
-_BOARD_CONTROLLABLE_STATES = frozenset(
-    {"armed", "watching", "due", "confirming", "executing", "suspended"}
-)
-
-
-async def _execute_dashboard(
-    ctx: "Context", name: str, args: str = "", session_id: str = "",
-) -> dict[str, Any]:
-    """Analyze the current session and render it through a template.
-
-    LeapBoard has a single analysis target — the current session. ``/board``
-    opens the default (``generic``) lens; ``/board <template>`` opens a known
-    lens. Reserved verbs manage templates and the session observation. Any other
-    token is an unknown command and is rejected (never silently coerced).
-    """
-    monitors = getattr(ctx, "monitors", None)
-    sub = name.split(" ", 1)[1].strip() if " " in name else ""
-    rest = (sub + ((" " + args) if args else "")).strip() if sub else args.strip()
-    try:
-        from leapflow.utils.shell_lex import split_args
-
-        tokens = split_args(rest) if rest else []
-    except ValueError:
-        tokens = rest.split()
-    verb = tokens[0].lower() if tokens else ""
-    rest_tokens = tokens[1:]
-
-    if verb == "templates":
-        return _execute_board_templates(ctx, rest_tokens)
-    if verb == "status":
-        return _execute_board_status(ctx, monitors)
-    if verb in ("refresh", "pause", "resume", "stop"):
-        return await _execute_board_control(
-            ctx, monitors, verb, target=rest_tokens[0] if rest_tokens else "",
-        )
-    if not verb:
-        return await _execute_board_open(ctx, monitors, template="", session_id=session_id)
-    # A non-empty, non-verb token must name a known template lens; otherwise it
-    # is an unknown command and is rejected rather than coerced to generic.
-    if verb in set(_template_library(ctx).names()):
-        return await _execute_board_open(ctx, monitors, template=verb, session_id=session_id)
-    return {
-        "ok": False,
-        "message": (
-            f"Unknown board command: '{verb}'. Use /board for the session board, "
-            "/board <template> for a lens (see /board templates), or "
-            "/board templates|refresh|pause|resume|stop|status."
-        ),
-    }
-
-
-async def _execute_board_open(
-    ctx: "Context", monitors: Any, *, template: str, session_id: str = "",
-) -> dict[str, Any]:
-    """Open the current-session board rendered with the requested template.
-
-    ``template`` is guaranteed to be empty (default) or a known lens by the
-    dispatcher, so there is no silent fallback here.
-    """
-    session_watch_id = ""
-    if monitors is not None:
-        try:
-            session_watch_id = await _ensure_session_watch_refresh(ctx, monitors, session_id)
-        except Exception:
-            logger.debug("dashboard: session watch refresh failed", exc_info=True)
-    # The client owns the dashboard server lifecycle (it spawns/validates it off
-    # the event loop), so the daemon only conveys the chosen lens here.
-    payload: dict[str, Any] = {
-        "ok": True, "view": "dashboard", "mode": "open", "template": template or "generic",
-    }
-    if session_watch_id:
-        payload["watch_id"] = session_watch_id
-    return payload
-
-
-async def _execute_board_control(
-    ctx: "Context", monitors: Any, verb: str, *, target: str = "",
-) -> dict[str, Any]:
-    """Control a board observation: refresh / pause / resume / stop.
-
-    Without ``target`` the verb applies to the current session watch (``refresh``
-    starts it if absent; the others require an existing one). With ``target`` it
-    applies to the watch whose id — a full id or a unique prefix, as shown by
-    ``/board status`` — matches, so ``/board stop <id>`` stops that watch.
-    """
-    if monitors is None:
-        return {"ok": False, "message": "Monitor runtime is unavailable (scheduler disabled)."}
-
-    if target:
-        watch_id = _resolve_watch_id(monitors, target)
-        if not watch_id:
-            return {"ok": False,
-                    "message": f"No board watch matches '{target}'. Run /board status to see ids."}
-    elif verb == "refresh":
-        from leapflow.monitor.session_producer import ensure_session_watch, session_watch_params
-        watch_id = await ensure_session_watch(
-            monitors, params=session_watch_params(getattr(ctx, "settings", None))
-        )
-    else:
-        watch_id = _find_session_watch_id(monitors)
-        if not watch_id:
-            return {"ok": False,
-                    "message": f"No active session board to {verb}. Run /board to start one."}
-
-    if verb == "refresh":
-        monitors.schedule_watch_once(watch_id, force=True)
-        return {"ok": True, "view": "dashboard", "mode": "control", "action": "refresh",
-                "watch_id": watch_id,
-                "message": "Re-analyzing the current session; the board updates when it completes."}
-
-    method = {"pause": monitors.pause_watch, "resume": monitors.resume_watch,
-              "stop": monitors.stop_watch}[verb]
-    view = method(watch_id)
-    if view is None:
-        return {"ok": False, "message": f"Watch not found: {watch_id[:8]}."}
-    label = view.name or watch_id[:8]
-    messages = {
-        "pause": f"Paused {label}; use /board resume to continue.",
-        "resume": f"Resumed {label}.",
-        "stop": f"Stopped {label}; run /board to start again.",
-    }
-    return {"ok": True, "view": "dashboard", "mode": "control", "action": verb,
-            "watch": view.to_dict(), "message": messages[verb]}
-
-
-def _resolve_watch_id(monitors: Any, target: str) -> str:
-    """Resolve a watch id from an exact id or a unique prefix (as /board status shows)."""
-    target = target.strip()
-    if not target:
-        return ""
-    try:
-        views = list(monitors.list_watches())
-    except Exception:
-        return ""
-    for view in views:
-        if view.watch_id == target:
-            return view.watch_id
-    prefix_matches = [view.watch_id for view in views if view.watch_id.startswith(target)]
-    return prefix_matches[0] if len(prefix_matches) == 1 else ""
-
-
-def _find_session_watch_id(monitors: Any) -> str:
-    """Return the current controllable session watch id, or empty when none is active."""
-    try:
-        views = list(monitors.list_watches())
-    except Exception:
-        return ""
-    for view in views:
-        if view.domain == "session" and view.state in _BOARD_CONTROLLABLE_STATES:
-            return view.watch_id
-    return ""
-
-
-def _execute_board_status(ctx: "Context", monitors: Any) -> dict[str, Any]:
-    """Return session-observation status: watch detail + recent findings + lenses.
-
-    Fields:
-      - ``templates`` / ``default``: available lenses and the default.
-      - ``watches``: every watch with state, run/finding counts, and last-run age.
-      - ``findings``: recent findings (severity, title, summary, age) across watches.
-    """
-    library = _template_library(ctx)
-    data: dict[str, Any] = {
-        "ok": True, "view": "dashboard", "mode": "status",
-        "templates": library.names(), "default": "generic",
-        "watches": [], "findings": [],
-    }
-    if monitors is None:
-        return data
-    try:
-        data["watches"] = [v.to_dict() for v in monitors.list_watches()]
-    except Exception:
-        logger.debug("dashboard: watch list unavailable", exc_info=True)
-    try:
-        data["findings"] = [f.to_dict() for f in monitors.list_findings(limit=20)]
-    except Exception:
-        logger.debug("dashboard: finding list unavailable", exc_info=True)
-    return data
-
-
-def _execute_board_templates(ctx: "Context", rest_tokens: list[str]) -> dict[str, Any]:
-    """Template hub: list / add / remove / show board templates."""
-    from leapflow.dashboard.templates import sanitize_template_id
-
-    library = _template_library(ctx)
-    op = rest_tokens[0].lower() if rest_tokens else "list"
-    args = rest_tokens[1:]
-
-    if op == "list":
-        items = [library.describe(name) or {"name": name} for name in library.names()]
-        return {"ok": True, "view": "dashboard", "mode": "templates",
-                "templates": items, "default": "generic"}
-
-    if op == "add":
-        positional = [t for t in args if not t.startswith("--")]
-        if not positional:
-            return {"ok": False, "message": "Usage: /board templates add <path.yaml> [--name id] [--force]"}
-        requested = _flag_value(args, "--name")
-        candidate = sanitize_template_id(requested or Path(positional[0]).stem)
-        if candidate in _BOARD_VERBS:
-            return {"ok": False, "message": f"'{candidate}' is a reserved board command; choose another --name."}
-        try:
-            installed = library.install(Path(positional[0]), name=requested, force="--force" in args)
-        except ValueError as exc:
-            return {"ok": False, "message": f"Could not add template: {exc}"}
-        return {"ok": True, "view": "dashboard", "mode": "templates", "action": "add",
-                "template": installed,
-                "message": f"Registered template '{installed}'. Open it with /board {installed}."}
-
-    if op == "remove":
-        if not args:
-            return {"ok": False, "message": "Usage: /board templates remove <id>"}
-        if library.source_of(args[0]) == "builtin":
-            return {"ok": False, "message": f"'{args[0]}' is a builtin template and cannot be removed."}
-        removed = library.uninstall(args[0])
-        return {"ok": bool(removed), "view": "dashboard", "mode": "templates", "action": "remove",
-                "message": f"Removed template '{args[0]}'." if removed else f"No custom template '{args[0]}'."}
-
-    if op == "show":
-        if not args:
-            return {"ok": False, "message": "Usage: /board templates show <id>"}
-        info = library.describe(args[0])
-        if info is None:
-            return {"ok": False, "message": f"Template not found: {args[0]}"}
-        return {"ok": True, "view": "dashboard", "mode": "templates", "action": "show", "detail": info}
-
-    return {"ok": False, "message": "Usage: /board templates [list|add|remove|show] ..."}
-
-
-def _template_library(ctx: "Context") -> Any:
-    """Build a TemplateLibrary bound to the profile's custom-template override dir."""
-    from leapflow.dashboard.templates import TemplateLibrary
-
-    override_dir = None
-    settings = getattr(ctx, "settings", None)
-    profile_layout = getattr(settings, "profile_layout", None) if settings is not None else None
-    if profile_layout is not None:
-        try:
-            override_dir = profile_layout.dashboard.templates_dir
-        except Exception:
-            override_dir = None
-    return TemplateLibrary(override_dir=override_dir)
-
-
-def _flag_value(tokens: list[str], flag: str) -> str:
-    """Return the value following ``flag`` in tokens, or '' when absent."""
-    if flag in tokens:
-        idx = tokens.index(flag)
-        if idx + 1 < len(tokens) and not tokens[idx + 1].startswith("--"):
-            return tokens[idx + 1]
-    return ""
-
-
-def _is_app_command_name(name: str) -> bool:
-    return name == "app" or name.startswith("app ")
-
-
-def build_status_payload(ctx: "Context") -> dict[str, Any]:
-    """Build a serializable status summary."""
-    engine = ctx.engine
-    context_length = 0
-    context_used = 0
-    turn_count = 0
-    if engine is not None:
-        cap_registry = getattr(engine, "model_capabilities", None)
-        if cap_registry is not None:
-            caps = cap_registry.resolve(ctx.settings.llm_model)
-            context_length = int(caps.context_length)
-        context_used = int(getattr(engine, "context_token_count", 0))
-        turn_count = int(getattr(engine, "turn_count", 0))
-
-    platform_status = "connected" if (hasattr(ctx.rpc, "connected") and ctx.rpc.connected) else "mock"
-    cwd = os.getcwd().replace(os.path.expanduser("~"), "~")
-
-    from leapflow.engine.session import SessionMode
-    mode = "idle"
-    if ctx.session:
-        if ctx.session.mode == SessionMode.LEARNING:
-            mode = "learning"
-        elif ctx.session.mode == SessionMode.EXECUTING:
-            mode = "executing"
-
-    gateway_connected: list[str] = []
-    gw = getattr(ctx, "gateway_server", None)
-    if gw is not None:
-        statuses = gw.platform_status()
-        for s in statuses:
-            if s.connected:
-                m = gw.manifests.get(s.platform_id)
-                gateway_connected.append(m.display_name if m else s.platform_id)
-
-    return {
-        "ok": True,
-        "view": "status",
-        "model": ctx.settings.llm_model,
-        "context_length": context_length,
-        "context_used": context_used,
-        "turn_count": turn_count,
-        "platform": platform_status,
-        "cwd": cwd,
-        "config_path": str(ctx.settings.profile_layout.config_dir).replace(os.path.expanduser("~"), "~"),
-        "user_config_path": str(ctx.settings.layout.user_config_path).replace(os.path.expanduser("~"), "~"),
-        "workspace_config_path": str(ctx.settings.workspace_root / ".leapflow" / "config.yaml").replace(os.path.expanduser("~"), "~"),
-        "session_id": getattr(ctx.session, "session_id", "") if ctx.session else "",
-        "mode": mode,
-        "gateway_connected": gateway_connected,
-    }
-
-
-def build_gateway_payload(ctx: "Context") -> dict[str, Any]:
-    """Build a serializable gateway status payload."""
-    import time as _time
-
-    gw = getattr(ctx, "gateway_server", None)
-    if gw is None:
-        return {"ok": False, "message": "Gateway not initialised."}
-
-    statuses = gw.platform_status()
-    if not statuses:
-        return {"ok": True, "view": "gateway", "connected": [], "configured": [], "available": []}
-
-    connected = []
-    configured = []
-    available = []
-    for s in statuses:
-        m = gw.manifests.get(s.platform_id)
-        name = m.display_name if m else s.platform_id
-        if s.connected:
-            uptime = ""
-            if s.connected_since > 0:
-                secs = int(_time.time() - s.connected_since)
-                if secs < 60:
-                    uptime = f"{secs}s"
-                elif secs < 3600:
-                    uptime = f"{secs // 60}m"
-                else:
-                    uptime = f"{secs // 3600}h {(secs % 3600) // 60}m"
-            connected.append({"name": name, "id": s.platform_id, "uptime": uptime})
-        elif s.error:
-            configured.append({"name": name, "id": s.platform_id})
-        else:
-            available.append({"name": name, "id": s.platform_id})
-    return {"ok": True, "view": "gateway", "connected": connected, "configured": configured, "available": available}
-
-
-async def _execute_host(ctx: "Context", args: str) -> dict[str, Any]:
-    """Execute /host command."""
-    action = args.strip().lower() if args.strip() else "status"
-    if action not in {"status", "start", "stop", "restart"}:
-        return {"ok": False, "message": "Usage: /host [status|start|stop|restart]"}
-    if action == "status":
-        result = await ctx.host_backend_status()
-    elif action == "start":
-        result = await ctx.host_backend_start()
-    elif action == "stop":
-        result = await ctx.host_backend_stop()
-    else:
-        result = await ctx.host_backend_restart()
-    return {"ok": True, "view": "host", "action": action, "result": result}
-
-
-async def _distill_background(session) -> None:
-    """Run distillation in background without blocking the RPC response."""
-    import logging
-    _log = logging.getLogger(__name__)
-    try:
-        final = await session.await_learning()
-        if final and final.candidates:
-            _log.info(
-                "background_distill: %d candidates, activated=%s",
-                len(final.candidates),
-                final.activated_skill_names or [],
-            )
-        else:
-            _log.info("background_distill: no candidates produced")
-    except Exception:
-        _log.warning("background_distill failed", exc_info=True)
-
-
-async def _execute_teach(ctx: "Context", name: str, args: str) -> dict[str, Any]:
-    """Execute teach commands.
-
-    Returns ``session_mode`` in the payload so the TUI client can track
-    whether it should route subsequent inputs as annotations.
-    """
-    from leapflow.engine.session import SessionMode
-
-    full_cmd = name + (" " + args if args else "")
-    if full_cmd in ("teach start", "teach") or full_cmd.startswith("teach start "):
-        if ctx.session is None:
-            return {"ok": False, "message": "No active session.", "session_mode": "idle"}
-        if ctx.session.mode == SessionMode.LEARNING:
-            return {"ok": False, "message": "Already in teaching mode. Say '/teach stop' to end.", "session_mode": "learning"}
-        goal = args if name == "teach start" else ""
-        try:
-            session = await ctx.session.enter_learning(goal=goal)
-            msg = f"Teaching started — session {session.session_id}"
-            if goal:
-                msg += f"\nGoal: {goal}"
-            msg += "\nCommands: /teach stop │ /teach discard │ /teach pause │ /teach resume │ /teach skip [n] │ /annotate <text>"
-            return {"ok": True, "message": msg, "session_mode": "learning"}
-        except Exception as e:
-            return {"ok": False, "message": str(e)}
-
-    if name == "teach stop":
-        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
-            return {"ok": False, "message": "Not in teaching mode.", "session_mode": "idle"}
-        try:
-            result = await ctx.session.exit_learning()
-            msg = f"Recording stopped — {result.step_count} steps, {result.duration:.1f}s"
-            if result.step_count == 0:
-                msg += "\nNo steps recorded — nothing to distill."
-            elif not getattr(ctx.settings, "has_llm_credentials", False):
-                msg += "\nNo LLM credentials — distillation skipped."
-            elif ctx.session.has_pending_distillation:
-                import asyncio
-                asyncio.create_task(_distill_background(ctx.session))
-                msg += "\nDistillation started in background."
-            else:
-                report = getattr(result, "learnability_report", None)
-                reason = getattr(report, "reason", "assessment decided to skip") if report else "auto-learn disabled"
-                msg += f"\nDistillation skipped: {reason}"
-            return {
-                "ok": True,
-                "message": msg,
-                "step_count": result.step_count,
-                "duration": result.duration,
-                "session_mode": "idle",
-            }
-        except Exception as e:
-            return {"ok": False, "message": str(e), "session_mode": "idle"}
-
-    if name == "teach pause":
-        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
-            return {"ok": False, "message": "Not in teaching mode."}
-        ctx.session.pause_learning()
-        return {"ok": True, "message": "Teaching paused.", "session_mode": "paused"}
-
-    if name == "teach resume":
-        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
-            return {"ok": False, "message": "Not in teaching mode."}
-        ctx.session.resume_learning()
-        return {"ok": True, "message": "Teaching resumed.", "session_mode": "learning"}
-
-    if name == "teach discard":
-        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
-            return {"ok": False, "message": "Not in teaching mode."}
-        ctx.session.discard_learning()
-        return {"ok": True, "message": "Recording discarded.", "session_mode": "idle"}
-
-    if name == "teach skip":
-        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
-            return {"ok": False, "message": "Not in teaching mode."}
-        n = 1
-        if args.strip().isdigit():
-            n = int(args.strip())
-        ctx.session.skip_steps(n)
-        return {"ok": True, "message": f"Marked last {n} step(s) as noise.", "session_mode": "learning"}
-
-    if name == "annotate":
-        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
-            return {"ok": False, "message": "Not in teaching mode."}
-        if not args.strip():
-            return {"ok": False, "message": "Usage: /annotate <text>"}
-        ctx.session.annotate(args.strip())
-        return {"ok": True, "message": f"Annotation recorded: {args.strip()}", "session_mode": "learning"}
-
-    if name == "teach status":
-        if not ctx.session:
-            return {"ok": True, "message": "No active session.", "session_mode": "idle"}
-        mode = ctx.session.mode.value
-        result_payload: dict[str, Any] = {"ok": True, "session_mode": mode}
-        if mode == "evolving" or ctx.session.is_distilling:
-            result_payload["message"] = "Distillation in progress…"
-            result_payload["distilling"] = True
-        elif mode == "learning":
-            step_count = ctx.session.recording_step_count
-            result_payload["message"] = f"Recording — {step_count} steps captured."
-            result_payload["step_count"] = step_count
-        else:
-            last = ctx.session.last_result
-            if last:
-                candidates = getattr(last, "candidates", None) or []
-                new_skills = getattr(last, "new_skills", None) or []
-                result_payload["message"] = (
-                    f"Idle. Last result: {last.step_count} steps, "
-                    f"{len(candidates)} candidates, "
-                    f"{len(new_skills)} activated."
-                )
-            else:
-                result_payload["message"] = "Idle. No previous distillation results."
-        return result_payload
-
-    return {"ok": False, "message": f"Unknown teach command: /{full_cmd}"}
-
-
-def _execute_skill(ctx: "Context", name: str, args: str) -> dict[str, Any]:
-    """Execute skill commands."""
-    full_cmd = name + (" " + args if args else "")
-    if full_cmd in ("skill", "skill list"):
-        skills = ctx.registry.list_all() if ctx.registry else []
-        if not skills:
-            return {"ok": True, "view": "skill_list", "skills": []}
-        entries = []
-        for s in skills:
-            m = s.metadata
-            entries.append({
-                "name": s.name,
-                "version": m.version,
-                "confidence": m.confidence,
-                "description": s.description[:80],
-            })
-        return {"ok": True, "view": "skill_list", "skills": entries}
-
-    if name == "skill show":
-        skill_name = args.strip()
-        if not skill_name:
-            return {"ok": False, "message": "Usage: /skill show <name>"}
-        skill = ctx.registry.get(skill_name) if ctx.registry else None
-        if skill is None:
-            return {"ok": False, "message": f"Skill '{skill_name}' not found."}
-        m = skill.metadata
-        return {
-            "ok": True,
-            "view": "skill_show",
-            "name": skill.name,
-            "description": skill.description,
-            "version": m.version,
-            "confidence": m.confidence,
-            "triggers": list(skill.triggers) if skill.triggers else [],
-        }
-
-    if name == "skill disable":
-        skill_name = args.strip()
-        if not skill_name:
-            return {"ok": False, "message": "Usage: /skill disable <name>"}
-        found = False
-        if ctx.skill_lib and ctx.skill_lib.deactivate_parameterized(skill_name):
-            found = True
-        if ctx.registry and ctx.registry.unregister(skill_name):
-            found = True
-        if found:
-            return {"ok": True, "message": f"Skill '{skill_name}' disabled."}
-        return {"ok": False, "message": f"Skill '{skill_name}' not found."}
-
-    if name == "skill delete":
-        skill_name = args.strip()
-        if not skill_name:
-            return {"ok": False, "message": "Usage: /skill delete <name>"}
-        found = False
-        if ctx.skill_lib:
-            stored = ctx.skill_lib.load_skill_by_title(skill_name)
-            if stored:
-                stored.status = "deleted"
-                ctx.skill_lib.update_skill(stored)
-                found = True
-        if ctx.registry and ctx.registry.unregister(skill_name):
-            found = True
-        if found:
-            return {"ok": True, "message": f"Skill '{skill_name}' deleted."}
-        return {"ok": False, "message": f"Skill '{skill_name}' not found."}
-
-    return {"ok": False, "message": f"Unknown skill command: /{full_cmd}"}
-
-
-async def _execute_hub(ctx: "Context", name: str, args: str) -> dict[str, Any]:
-    """Execute hub commands."""
-    try:
-        from leapflow.cli.commands.hub import cmd_hub_payload
-        return await cmd_hub_payload(ctx, name, args)
-    except ImportError:
-        pass
-    # Fallback: basic hub dispatch
-    sub = name[len("hub"):].strip() if name.startswith("hub") else ""
-    if not sub:
-        sub = args.split()[0] if args.split() else ""
-        args = " ".join(args.split()[1:])
-    command_parts = ["/hub"]
-    if sub:
-        command_parts.append(sub)
-    if args:
-        command_parts.append(args)
-    command = " ".join(command_parts)
-    return {"ok": False, "message": f"Hub command '{command}' is not yet implemented in this runtime."}
-
-
-def _execute_scheduler_task(ctx: "Context") -> dict[str, Any]:
-    """Execute /task command."""
-    scheduler = getattr(ctx, "scheduler", None)
-    if scheduler is None:
-        return {"ok": True, "view": "task", "tasks": [], "message": "No scheduler active."}
-    tasks = scheduler.list_tasks() if hasattr(scheduler, "list_tasks") else []
-    entries = [
-        {"name": t.name, "schedule": t.schedule, "next_run": str(getattr(t, "next_run", ""))}
-        for t in tasks
-    ]
-    return {"ok": True, "view": "task", "tasks": entries}
-
-
-async def _execute_scheduler_arm(ctx: "Context", args: str) -> dict[str, Any]:
-    """Execute /arm command."""
-    scheduler = getattr(ctx, "scheduler", None)
-    if scheduler is None:
-        return {"ok": False, "message": "Scheduler not active in this session."}
-    tokens = args.strip().split(None, 1)
-    if len(tokens) < 2:
-        return {"ok": False, "message": "Usage: /arm <skill> <cron>"}
-    skill_name, cron_expr = tokens
-    try:
-        task_id = await scheduler.arm(skill_name, cron_expr)
-        return {"ok": True, "message": f"Armed: {skill_name} → {cron_expr} (id={task_id})"}
-    except Exception as e:
-        return {"ok": False, "message": str(e)}
-
-
-def render_command_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    """Render a generic command_execute result payload in the TUI."""
-    if not payload.get("ok"):
-        console.warning(str(payload.get("message") or payload.get("error") or "Command failed."))
-        return
-
-    view = str(payload.get("view") or "")
-
-    if view == "status":
-        _render_status_view(console, payload)
-        return
-    if view == "model":
-        render_model_payload(console, payload)
-        return
-    if view == "config":
-        render_config_payload(console, payload)
-        return
-    if view == "gateway":
-        _render_gateway_view(console, payload)
-        return
-    if view == "host":
-        _render_host_view(console, payload)
-        return
-    if view == "skill_list":
-        _render_skill_list_view(console, payload)
-        return
-    if view == "skill_show":
-        _render_skill_show_view(console, payload)
-        return
-    if view == "task":
-        _render_task_view(console, payload)
-        return
-    if view == "dashboard":
-        _render_dashboard_view(console, payload)
-        return
-
-    msg = payload.get("message")
-    if msg:
-        console.success(str(msg))
-
-
-def _ago(ts: Any) -> str:
-    """Format an epoch timestamp as a compact relative age (e.g. '2m ago')."""
-    import time
-
-    try:
-        value = float(ts or 0)
-    except (TypeError, ValueError):
-        return ""
-    if value <= 0:
-        return "never"
-    delta = max(0, int(time.time() - value))
-    if delta < 60:
-        return f"{delta}s ago"
-    if delta < 3600:
-        return f"{delta // 60}m ago"
-    if delta < 86400:
-        return f"{delta // 3600}h ago"
-    return f"{delta // 86400}d ago"
-
-
-def _board_page_url() -> str:
-    """Best-effort token-scoped URL of the running board page, or '' when none.
-
-    The client owns the dashboard server, so the status renderer resolves the
-    live URL here (from discovery state) for users to copy; any failure or a
-    not-running server yields an empty string rather than raising.
-    """
-    try:
-        from leapflow.config import get_settings
-        from leapflow.dashboard import launcher
-
-        state = launcher.server_running(get_settings())
-        if not state:
-            return ""
-        return launcher.build_view_url(state["bind"], state["port"], state["token"])
-    except Exception:
-        logger.debug("dashboard: board page url lookup failed", exc_info=True)
-        return ""
-
-
-def _render_dashboard_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    from rich.table import Table
-
-    mode = str(payload.get("mode") or "")
-
-    if mode == "open":
-        # In the REPLs the browser is launched separately; this is a defensive
-        # text fallback for non-interactive callers.
-        url = payload.get("url")
-        if url:
-            console.system(f"Opening board: {url}")
-        elif payload.get("running"):
-            console.system("Dashboard is running.")
-        else:
-            console.system(str(payload.get("hint") or "Run `leap board` to open the web view."))
-        return
-
-    if mode == "control":
-        console.success(str(payload.get("message") or payload.get("action") or "done"))
-        return
-
-    if mode == "status":
-        templates = payload.get("templates") or []
-        console.system(
-            f"Templates: {', '.join(templates) or '-'} (default: {payload.get('default', 'generic')})"
-        )
-        watches = payload.get("watches") or []
-        if watches:
-            board_url = _board_page_url()
-            table = Table(title="Watches", title_style="bold cyan", border_style="bright_black")
-            for col in ("id", "name", "domain", "state", "runs", "findings", "last run"):
-                table.add_column(col)
-            # Full token URL of the board page, kept whole (folded, never cropped)
-            # so users can copy it straight from the table.
-            table.add_column("url", overflow="fold")
-            for w in watches:
-                table.add_row(
-                    str(w.get("watch_id", ""))[:8],
-                    str(w.get("name", "")),
-                    str(w.get("domain", "")),
-                    str(w.get("state", "")),
-                    str(w.get("run_count", 0)),
-                    str(w.get("finding_count", 0)),
-                    _ago(w.get("last_run_at", 0)),
-                    board_url,
-                )
-            console.print(table)
-        else:
-            console.system("Watches: none active — run /board to start session analysis.")
-        findings = payload.get("findings") or []
-        if findings:
-            console.system(f"Recent findings ({len(findings)}):")
-            markers = {"alert": "!!", "notable": " *", "info": " -"}
-            for f in findings[:20]:
-                sev = str(f.get("severity", "info"))
-                line = f"  {markers.get(sev, ' -')} [{sev}] {str(f.get('title', ''))}"
-                summary = str(f.get("summary", ""))
-                if summary:
-                    line += f" \u2014 {summary}"
-                age = _ago(f.get("ts", 0))
-                if age:
-                    line += f"  ({age})"
-                console.system(line)
-        else:
-            console.system("Findings: none yet.")
-        return
-
-    if mode == "templates":
-        action = str(payload.get("action") or "list")
-        if action == "list":
-            items = payload.get("templates") or []
-            if not items:
-                console.system("No templates available.")
-                return
-            table = Table(title="Templates", title_style="bold cyan", border_style="bright_black")
-            for col in ("name", "source", "title"):
-                table.add_column(col)
-            for item in items:
-                table.add_row(
-                    str(item.get("name", "")),
-                    str(item.get("source", "")),
-                    str(item.get("title", "")),
-                )
-            console.print(table)
-            return
-        if action == "show":
-            detail = payload.get("detail") or {}
-            console.system(
-                f"{detail.get('name')} [{detail.get('source')}] — {detail.get('title')}"
-            )
-            if detail.get("description"):
-                console.system(str(detail["description"]))
-            return
-        # add / remove success
-        console.success(str(payload.get("message") or "done"))
-        return
-
-    message = payload.get("message")
-    if message:
-        console.system(str(message))
-
-
-def _render_status_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    from rich.panel import Panel
-    from rich.text import Text
-
-    info = Text()
-    info.append("Model:     ", style="dim")
-    info.append(f"{payload.get('model')}\n", style="bold")
-
-    ctx_len = int(payload.get("context_length") or 0)
-    ctx_used = int(payload.get("context_used") or 0)
-    turn_count = int(payload.get("turn_count") or 0)
-    if ctx_len:
-        pct = int(ctx_used * 100 / ctx_len) if ctx_len else 0
-        info.append("Context:   ", style="dim")
-        pct_style = "bold red" if pct >= 90 else ("yellow" if pct >= 75 else "")
-        info.append(f"{ctx_used:,} / {ctx_len:,} ({pct}%)\n", style=pct_style)
-    info.append("Turns:     ", style="dim")
-    info.append(f"{turn_count}\n")
-    info.append("Platform:  ", style="dim")
-    p_status = str(payload.get("platform") or "")
-    p_style = "green" if p_status == "connected" else "dim"
-    info.append(f"{p_status}\n", style=p_style)
-    info.append("CWD:       ", style="dim")
-    info.append(f"{payload.get('cwd')}\n")
-    info.append("Config:    ", style="dim")
-    info.append(f"{payload.get('config_path')}\n")
-    session_id = payload.get("session_id")
-    if session_id:
-        info.append("Session:   ", style="dim")
-        info.append(f"{session_id}\n")
-    info.append("Mode:      ", style="dim")
-    info.append(f"{payload.get('mode')}\n")
-    gw = payload.get("gateway_connected") or []
-    if gw:
-        info.append("Gateway:   ", style="dim")
-        info.append(f"{', '.join(gw)}\n", style="green")
-
-    console.print(Panel(info, title="[bold cyan]LeapFlow Status[/]", border_style="bright_black", padding=(0, 2)))
-
-
-def _render_gateway_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    from rich.panel import Panel
-    from rich.text import Text
-
-    info = Text()
-    connected = payload.get("connected") or []
-    configured = payload.get("configured") or []
-    available = payload.get("available") or []
-
-    if connected:
-        info.append("Connected\n", style="bold green")
-        for entry in connected:
-            uptime = f" ({entry['uptime']})" if entry.get("uptime") else ""
-            info.append(f"  ● {entry['name']}{uptime}\n", style="green")
-    if configured:
-        info.append("Configured (not connected)\n", style="bold yellow")
-        for entry in configured:
-            info.append(f"  ○ {entry['name']}\n", style="yellow")
-    if available:
-        info.append("Available\n", style="bold dim")
-        names = [entry["name"] for entry in available]
-        info.append(f"  {', '.join(names)}\n", style="dim")
-    info.append("\n", style="dim")
-    info.append('Say "connect to <platform>" to set up a new integration.', style="dim italic")
-    console.print(Panel(info, title="[bold cyan]Gateway[/]", border_style="bright_black", padding=(0, 2)))
-
-
-def _render_host_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    result = payload.get("result") or {}
-    action = payload.get("action") or "status"
-    if action != "status":
-        console.success(f"Host {action} completed.")
-    lines = []
-    for key in ("status", "backend", "pid", "session_id"):
-        if key in result:
-            lines.append(f"  {key}: {result[key]}")
-    if lines:
-        console.system("\n".join(lines))
-
-
-def _render_skill_list_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    from rich.table import Table
-
-    skills = payload.get("skills") or []
-    if not skills:
-        console.system("No skills registered.")
-        return
-    table = Table(show_header=True, header_style="bold", border_style="dim")
-    table.add_column("Name", style="cyan", max_width=30)
-    table.add_column("Version", justify="center")
-    table.add_column("Confidence", justify="center")
-    table.add_column("Description", max_width=40)
-    for s in skills:
-        table.add_row(
-            str(s.get("name") or ""),
-            f"v{s.get('version', 0)}",
-            f"{float(s.get('confidence') or 0):.0%}",
-            str(s.get("description") or "")[:40],
-        )
-    console.print(table)
-
-
-def _render_skill_show_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    from rich.panel import Panel
-    from rich.text import Text
-
-    info = Text()
-    info.append(f"Name:        {payload.get('name')}\n")
-    info.append(f"Description: {payload.get('description')}\n")
-    info.append(f"Version:     v{payload.get('version', 0)}\n")
-    info.append(f"Confidence:  {float(payload.get('confidence') or 0):.0%}\n")
-    triggers = payload.get("triggers") or []
-    if triggers:
-        info.append(f"Triggers:    {', '.join(triggers)}")
-    console.print(Panel(info, title=str(payload.get("name") or "Skill"), border_style="cyan"))
-
-
-def _render_task_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
-    tasks = payload.get("tasks") or []
-    msg = payload.get("message")
-    if msg:
-        console.system(str(msg))
-        return
-    if not tasks:
-        console.system("No scheduled tasks.")
-        return
-    from rich.table import Table
-    table = Table(show_header=True, header_style="bold", border_style="dim")
-    table.add_column("Name", style="cyan")
-    table.add_column("Schedule")
-    table.add_column("Next Run")
-    for t in tasks:
-        table.add_row(str(t.get("name") or ""), str(t.get("schedule") or ""), str(t.get("next_run") or ""))
-    console.print(table)
+"""Slash-command handler implementations.
+
+Each handler follows the signature ``(ctx, console, args) -> None``.
+All display logic uses ``LeapConsole`` for consistent theming.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import shlex
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from leapflow.cli.context import Context
+    from leapflow.cli.tui_app.console import LeapConsole
+
+
+logger = logging.getLogger(__name__)
+
+
+def build_tool_payload(ctx: "Context") -> dict[str, Any]:
+    """Build a serializable tool summary for local or daemon rendering."""
+    from leapflow.cli.banner import _categorize_tools
+    from leapflow.tools.registry_bootstrap import TOOL_DEFINITIONS
+
+    tool_groups = _categorize_tools(TOOL_DEFINITIONS)
+    groups = {category: sorted(names) for category, names in tool_groups.items()}
+    mcp_count = 0
+    if hasattr(ctx.rpc, "connected") and ctx.rpc.connected:
+        mcp_count = len(getattr(ctx, "platform_tools", []))
+    return {
+        "ok": True,
+        "groups": groups,
+        "total": sum(len(names) for names in groups.values()),
+        "mcp_count": mcp_count,
+    }
+
+
+def render_tool_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    """Render a serializable tool summary."""
+    from rich.table import Table
+
+    if not payload.get("ok", True):
+        console.warning(str(payload.get("error") or "Tools are not available."))
+        return
+
+    groups = dict(payload.get("groups") or {})
+    table = Table(
+        title="Available Tools",
+        show_header=True,
+        header_style="bold",
+        border_style="bright_black",
+        title_style="bold cyan",
+        padding=(0, 1),
+    )
+    table.add_column("Category", style="cyan", no_wrap=True)
+    table.add_column("Tools")
+
+    for category, names in groups.items():
+        table.add_row(str(category), ", ".join(sorted(str(name) for name in names)))
+
+    mcp_count = int(payload.get("mcp_count") or 0)
+    if mcp_count > 0:
+        table.add_row("mcp", f"{mcp_count} platform tools")
+
+    console.print(table)
+    console.system(f"{int(payload.get('total') or 0)} tools available")
+
+
+def build_usage_payload(ctx: "Context") -> dict[str, Any]:
+    """Build a serializable token usage summary."""
+    engine = ctx.engine
+    if engine is None:
+        return {"ok": False, "error": "No active engine — send a message first."}
+
+    tracker = getattr(engine, "usage_tracker", None)
+    if tracker is None:
+        return {"ok": False, "error": "Usage tracking not available."}
+
+    summary = tracker.summary()
+    cap_registry = getattr(engine, "model_capabilities", None)
+    context_length = 0
+    if cap_registry is not None:
+        caps = cap_registry.resolve(ctx.settings.llm_model)
+        context_length = int(caps.context_length)
+
+    return {
+        "ok": True,
+        "model": ctx.settings.llm_model,
+        "prompt_tokens": int(summary.prompt_tokens),
+        "completion_tokens": int(summary.completion_tokens),
+        "total_tokens": int(summary.total_tokens),
+        "turn_count": int(getattr(engine, "turn_count", 0)),
+        "context_used": int(getattr(engine, "context_token_count", 0)),
+        "context_length": context_length,
+    }
+
+
+def render_usage_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    """Render a serializable token usage summary."""
+    from leapflow.cli.tui_app.status import _compact_tokens
+
+    if not payload.get("ok", True):
+        console.warning(str(payload.get("error") or "Usage tracking not available."))
+        return
+
+    console.print()
+    prompt_tokens = int(payload.get("prompt_tokens") or 0)
+    completion_tokens = int(payload.get("completion_tokens") or 0)
+    total_tokens = int(payload.get("total_tokens") or 0)
+    turn_count = int(payload.get("turn_count") or 0)
+    context_used = int(payload.get("context_used") or 0)
+    context_length = int(payload.get("context_length") or 0)
+    lines = [
+        f"  Model:           {payload.get('model') or ''}",
+        f"  Input tokens:    {_compact_tokens(prompt_tokens):>8}  ({prompt_tokens:,})",
+        f"  Output tokens:   {_compact_tokens(completion_tokens):>8}  ({completion_tokens:,})",
+        f"  Total tokens:    {_compact_tokens(total_tokens):>8}  ({total_tokens:,})",
+        f"  Turns:           {turn_count}",
+    ]
+    if context_length > 0:
+        pct = int(context_used * 100 / context_length)
+        lines.append(
+            f"  Context:         {_compact_tokens(context_used)}/{_compact_tokens(context_length)} ({pct}%)"
+        )
+    for line in lines:
+        console.system(line)
+    console.print()
+
+
+def build_model_payload(ctx: "Context", args: str = "") -> dict[str, Any]:
+    """Build a serializable model summary or update the active model."""
+    model_arg = args.strip()
+    if model_arg:
+        payload = build_config_payload(ctx, f"llm set --model {shlex.quote(model_arg)}")
+        payload["view"] = "model"
+        payload["requested_model"] = model_arg
+        return payload
+
+    engine = ctx.engine
+    context_length = 0
+    if engine is not None:
+        cap_registry = getattr(engine, "model_capabilities", None)
+        if cap_registry is not None:
+            caps = cap_registry.resolve(ctx.settings.llm_model)
+            context_length = int(caps.context_length)
+    return {
+        "ok": True,
+        "view": "model",
+        "model": ctx.settings.llm_model,
+        "context_length": context_length,
+        "requested_model": "",
+    }
+
+
+def render_model_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    """Render a serializable model summary."""
+    if not payload.get("ok", True):
+        console.warning(str(payload.get("error") or payload.get("message") or "Model information is not available."))
+        return
+    requested = str(payload.get("requested_model") or "")
+    model = str(payload.get("model") or "")
+    if requested:
+        console.success(f"Model updated: {model}")
+        if payload.get("reloaded"):
+            console.system("Configuration reloaded for this session.")
+        return
+
+    console.system(f"Current model: {model}")
+    context_length = int(payload.get("context_length") or 0)
+    if context_length > 0:
+        console.system(f"Context length: {context_length:,}")
+
+
+def build_config_payload(ctx: "Context", args: str = "") -> dict[str, Any]:
+    """Execute a config command and return a serializable payload."""
+    from leapflow.config_service import ConfigService
+
+    service = ConfigService(ctx.settings)
+    try:
+        from leapflow.utils.shell_lex import split_args
+
+        tokens = split_args(args)
+    except ValueError as exc:
+        return {"ok": False, "message": f"Invalid /config syntax: {exc}"}
+    if not tokens:
+        tokens = ["show"]
+    action = tokens[0]
+    try:
+        if action == "show":
+            if len(tokens) > 1:
+                return {
+                    "ok": True,
+                    "view": "config",
+                    "mode": "show_detail",
+                    "field": _config_field_to_dict(service.describe(tokens[1])),
+                }
+            return _config_snapshot_payload(service)
+        if action == "keys":
+            return {"ok": True, "view": "config", "mode": "keys", "sources": list(service.writable_keys())}
+        if action == "list":
+            category = tokens[1] if len(tokens) > 1 and not tokens[1].startswith("--") else None
+            return {"ok": True, "view": "config", "mode": "list", "fields": [_config_field_to_dict(item) for item in service.list_fields(category)]}
+        if action == "sources":
+            return {"ok": True, "view": "config", "mode": "sources", "sources": list(service.sources())}
+        if action == "get" and len(tokens) == 2:
+            value = service.get(tokens[1])
+            return {"ok": True, "view": "config", "mode": "get", "values": [_config_value_to_dict(value)]}
+        if action == "set" and len(tokens) >= 3:
+            scope = _option_value(tokens[3:], "--scope", "profile")
+            result = service.set(tokens[1], tokens[2], scope=scope)  # type: ignore[arg-type]
+            return _config_mutation_payload(ctx, service, result)
+        if action == "unset" and len(tokens) >= 2:
+            scope = _option_value(tokens[2:], "--scope", "profile")
+            result = service.unset(tokens[1], scope=scope)  # type: ignore[arg-type]
+            return _config_mutation_payload(ctx, service, result)
+        if action == "llm":
+            return _build_llm_config_payload(ctx, service, tokens[1:])
+        if action == "secret":
+            return _build_secret_config_payload(ctx, service, tokens[1:])
+    except (KeyError, ValueError, RuntimeError) as exc:
+        return {"ok": False, "message": f"Config error: {exc}"}
+    return {"ok": False, "message": "Usage: /config [show|list|keys|sources|get|set|unset|llm|secret] ..."}
+
+
+_CONFIG_LIST_COMPACT_WIDTH = 92
+_CONFIG_LIST_FULL_WIDTH = 118
+
+
+def _display_width(console: object, default: int = 100) -> int:
+    """Return the active Rich console width with a safe fallback for tests."""
+    width = getattr(console, "width", None)
+    if isinstance(width, int) and width > 0:
+        return width
+    raw = getattr(console, "raw", None)
+    raw_width = getattr(raw, "width", None)
+    if isinstance(raw_width, int) and raw_width > 0:
+        return raw_width
+    return default
+
+
+def _shorten(text: object, limit: int) -> str:
+    """Shorten a cell value before Rich allocates table columns."""
+    value = str(text) if text is not None else ""
+    if limit <= 0:
+        return ""
+    if len(value) <= limit:
+        return value
+    return value[: max(1, limit - 1)] + "…"
+
+
+def _config_scope_text(item: dict[str, Any], *, limit: int) -> str:
+    scopes = ",".join(str(scope) for scope in item.get("scopes") or [])
+    return _shorten(scopes, limit)
+
+
+def _config_reload_text(item: dict[str, Any]) -> str:
+    value = item.get("hot_reload")
+    if isinstance(value, bool):
+        return "yes" if value else "no"
+    return str(value) if value is not None and str(value) else "no"
+
+
+def _config_meta_text(item: dict[str, Any], *, scope_limit: int) -> str:
+    parts = [str(item.get("type") or "?")]
+    scope = _config_scope_text(item, limit=scope_limit)
+    if scope:
+        parts.append(scope)
+    parts.append(f"reload:{_config_reload_text(item)}")
+    return " · ".join(parts)
+
+
+def _build_config_list_table(console: object, fields: list[dict[str, Any]]) -> object:
+    """Build a width-aware config list table for TUI rendering."""
+    from rich.table import Table
+
+    width = _display_width(console)
+    table = Table(title="Writable config fields", show_lines=False, expand=True)
+    if width < _CONFIG_LIST_COMPACT_WIDTH:
+        table.add_column("Key", no_wrap=True, overflow="ellipsis", max_width=32, ratio=2)
+        table.add_column("Value", overflow="fold", max_width=24, ratio=1)
+        table.add_column("Meta", overflow="fold", max_width=24, ratio=1)
+        for item in fields:
+            table.add_row(
+                _shorten(item.get("key"), 36),
+                _shorten(item.get("value"), 32),
+                _config_meta_text(item, scope_limit=14),
+            )
+        return table
+
+    if width < _CONFIG_LIST_FULL_WIDTH:
+        table.add_column("Key", no_wrap=True, overflow="ellipsis", max_width=34, ratio=2)
+        table.add_column("Value", overflow="fold", max_width=30, ratio=1)
+        table.add_column("Type", no_wrap=True, max_width=8)
+        table.add_column("Scope", no_wrap=True, overflow="ellipsis", max_width=18)
+        table.add_column("Reload", no_wrap=True, max_width=6)
+        for item in fields:
+            table.add_row(
+                _shorten(item.get("key"), 38),
+                _shorten(item.get("value"), 40),
+                str(item.get("type") or ""),
+                _config_scope_text(item, limit=18),
+                _config_reload_text(item),
+            )
+        return table
+
+    table.add_column("Key", no_wrap=True, overflow="ellipsis", max_width=36, ratio=2)
+    table.add_column("Value", overflow="fold", max_width=36, ratio=1)
+    table.add_column("Type", no_wrap=True, max_width=10)
+    table.add_column("Scope", no_wrap=True, overflow="ellipsis", max_width=22)
+    table.add_column("Reload", no_wrap=True, max_width=6)
+    table.add_column("Description", overflow="fold", ratio=2)
+    for item in fields:
+        table.add_row(
+            _shorten(item.get("key"), 42),
+            _shorten(item.get("value"), 48),
+            str(item.get("type") or ""),
+            _config_scope_text(item, limit=22),
+            _config_reload_text(item),
+            str(item.get("description") or ""),
+        )
+    return table
+
+
+def render_config_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    """Render config command output."""
+    if not payload.get("ok", True):
+        console.warning(str(payload.get("message") or "Config command failed."))
+        return
+    mode = str(payload.get("mode") or "show")
+    if mode in {"sources", "keys"}:
+        label = "Writable config keys" if mode == "keys" else "Config sources"
+        sources = [str(source) for source in payload.get("sources") or []]
+        if not sources:
+            console.system(f"No {label.lower()} found.")
+            return
+        console.system(f"{label}:")
+        for source in sources:
+            console.system(f"  {source}")
+        return
+    if mode == "list":
+        fields = [dict(item) for item in payload.get("fields") or []]
+        if not fields:
+            console.system("No writable config fields found.")
+            return
+        console.print(_build_config_list_table(console, fields))
+        console.system("Use /config show <key>, /config get <key>, /config set <key> <value>, or /config keys for compact output.")
+        return
+    if mode == "show_detail":
+        field = dict(payload.get("field") or {})
+        if not field:
+            console.warning("No config field details found.")
+            return
+        from rich.panel import Panel
+        from rich.text import Text
+
+        details = Text()
+        details.append(f"value: {field.get('value') or ''}\n")
+        details.append(f"type: {field.get('type') or ''}\n")
+        details.append(f"category: {field.get('category') or ''}\n")
+        details.append(f"scope: {','.join(str(scope) for scope in field.get('scopes') or [])}\n")
+        details.append(f"reload: {field.get('hot_reload') or ''}\n")
+        details.append(f"secret: {'true' if field.get('secret') else 'false'}\n")
+        value_hint = str(field.get("value_hint") or "")
+        if value_hint:
+            details.append(f"value hint: {value_hint}\n")
+        details.append(f"description: {field.get('description') or ''}")
+        examples = [str(example) for example in field.get("examples") or []]
+        if examples:
+            details.append(f"\nexample: {examples[0]}")
+        console.print(Panel(details, title=str(field.get("key") or "Config field"), border_style="cyan"))
+        return
+    if mode == "mutation":
+        console.success(str(payload.get("message") or "Config updated."))
+        for key in payload.get("changed_keys") or []:
+            console.system(f"  {key}")
+        warnings = payload.get("warnings") or []
+        for warning in warnings:
+            console.warning(str(warning))
+        if payload.get("reloaded"):
+            console.system("Configuration reloaded for this session.")
+        return
+    values = payload.get("values") or []
+    if values:
+        for item in values:
+            console.system(f"{item.get('key')}={item.get('value')}")
+    warnings = payload.get("warnings") or []
+    for warning in warnings:
+        console.warning(str(warning))
+
+
+def _config_snapshot_payload(service: Any) -> dict[str, Any]:
+    snapshot = service.snapshot()
+    return {
+        "ok": True,
+        "view": "config",
+        "mode": "show",
+        "values": [_config_value_to_dict(value) for value in snapshot.values],
+        "sources": list(snapshot.sources),
+        "warnings": list(snapshot.warnings),
+    }
+
+
+def _config_value_to_dict(value: Any) -> dict[str, Any]:
+    return {"key": value.key, "value": value.value, "source": value.source, "secret": value.secret}
+
+
+def _config_field_to_dict(value: Any) -> dict[str, Any]:
+    return {
+        "key": value.key,
+        "value": value.value,
+        "type": value.value_type,
+        "category": value.category,
+        "scopes": list(value.scopes),
+        "hot_reload": value.hot_reload,
+        "secret": value.secret,
+        "description": value.description,
+        "value_hint": value.value_hint,
+        "examples": list(value.examples),
+    }
+
+
+def _build_llm_config_payload(ctx: "Context", service: Any, tokens: list[str]) -> dict[str, Any]:
+    action = tokens[0] if tokens else "show"
+    if action == "show":
+        payload = _config_snapshot_payload(service)
+        payload["values"] = [item for item in payload["values"] if str(item.get("key") or "").startswith("llm.")]
+        return payload
+    if action != "set":
+        return {"ok": False, "message": "Usage: /config llm [show|set --model NAME --base-url URL --api-key KEY]"}
+    options = tokens[1:]
+    if "--ask-api-key" in options:
+        return {"ok": False, "message": "Use `leap config llm key` in a terminal for secure API key prompts."}
+    result = service.configure_llm(
+        api_key=_option_value(options, "--api-key"),
+        base_url=_option_value(options, "--base-url"),
+        model=_option_value(options, "--model"),
+        context_length=_option_int(options, "--context-length"),
+        max_retries=_option_int(options, "--max-retries"),
+        scope=_option_value(options, "--scope", "profile"),
+    )
+    return _config_mutation_payload(ctx, service, result)
+
+
+def _build_secret_config_payload(ctx: "Context", service: Any, tokens: list[str]) -> dict[str, Any]:
+    action = tokens[0] if tokens else "list"
+    if action == "list":
+        return {"ok": True, "view": "config", "mode": "sources", "sources": list(service.list_secrets())}
+    if action == "set" and len(tokens) >= 3:
+        scope = _option_value(tokens[3:], "--scope", "profile")
+        result = service.set_secret(tokens[1], tokens[2], scope=scope)  # type: ignore[arg-type]
+        return _config_mutation_payload(ctx, service, result)
+    if action == "get" and len(tokens) >= 2:
+        scope = _option_value(tokens[2:], "--scope", "profile")
+        reveal = "--reveal" in tokens[2:]
+        value = service.get_secret(tokens[1], scope=scope, reveal=reveal)  # type: ignore[arg-type]
+        return {"ok": True, "view": "config", "mode": "get", "values": [{"key": tokens[1], "value": value, "secret": not reveal}]}
+    if action == "delete" and len(tokens) >= 2:
+        scope = _option_value(tokens[2:], "--scope", "profile")
+        result = service.delete_secret(tokens[1], scope=scope)  # type: ignore[arg-type]
+        return _config_mutation_payload(ctx, service, result)
+    return {"ok": False, "message": "Usage: /config secret [list|set|get|delete] ..."}
+
+
+def _config_mutation_payload(ctx: "Context", service: Any, result: Any) -> dict[str, Any]:
+    reloaded = False
+    if result.changed_keys:
+        reloaded = bool(ctx.reload_runtime_config_if_changed(force=True))
+    return {
+        "ok": bool(result.ok),
+        "view": "config",
+        "mode": "mutation",
+        "message": result.message,
+        "changed_keys": list(result.changed_keys),
+        "warnings": list(getattr(result, "warnings", ()) or ()),
+        "reloaded": reloaded,
+        # Runtime values the status bar renders. A daemon-mode TUI is a separate
+        # process and cannot see the reload, so it needs them echoed back here;
+        # context length travels with the model because switching models usually
+        # changes it too.
+        "model": ctx.settings.llm_model,
+        "llm_context_length": int(getattr(ctx.settings, "llm_context_length", 0) or 0),
+    }
+
+
+def _option_value(tokens: list[str], option: str, default: str | None = None) -> str | None:
+    if option not in tokens:
+        return default
+    index = tokens.index(option)
+    if index + 1 >= len(tokens):
+        raise ValueError(f"Missing value for {option}")
+    return tokens[index + 1]
+
+
+def _option_int(tokens: list[str], option: str) -> int | None:
+    value = _option_value(tokens, option)
+    return int(value) if value is not None else None
+
+
+def handle_status(ctx: "Context", console: "LeapConsole", args: str) -> None:
+    """Display session status: model, context, platform, session info."""
+    from rich.panel import Panel
+    from rich.text import Text
+
+    info = Text()
+
+    info.append("Model:     ", style="dim")
+    info.append(f"{ctx.settings.llm_model}\n", style="bold")
+
+    engine = ctx.engine
+    if engine is not None:
+        cap_registry = getattr(engine, "model_capabilities", None)
+        ctx_len = 0
+        if cap_registry is not None:
+            caps = cap_registry.resolve(ctx.settings.llm_model)
+            ctx_len = caps.context_length
+        ctx_used = getattr(engine, "context_token_count", 0)
+        turn_count = getattr(engine, "turn_count", 0)
+
+        if ctx_len:
+            pct = int(ctx_used * 100 / ctx_len) if ctx_len else 0
+            info.append("Context:   ", style="dim")
+            pct_style = "bold red" if pct >= 90 else ("yellow" if pct >= 75 else "")
+            info.append(f"{ctx_used:,} / {ctx_len:,} ({pct}%)\n", style=pct_style)
+
+        info.append("Turns:     ", style="dim")
+        info.append(f"{turn_count}\n")
+
+    platform_status = "connected" if (hasattr(ctx.rpc, "connected") and ctx.rpc.connected) else "mock"
+    info.append("Platform:  ", style="dim")
+    p_style = "green" if platform_status == "connected" else "dim"
+    info.append(f"{platform_status}\n", style=p_style)
+
+    cwd = os.getcwd().replace(os.path.expanduser("~"), "~")
+    info.append("CWD:       ", style="dim")
+    info.append(f"{cwd}\n")
+
+    info.append("Profile:   ", style="dim")
+    info.append(f"{ctx.settings.profile}\n")
+
+    info.append("Config:    ", style="dim")
+    info.append(f"{str(ctx.settings.profile_layout.config_dir).replace(os.path.expanduser('~'), '~')}\n")
+
+    user_config = str(ctx.settings.layout.user_config_path).replace(os.path.expanduser("~"), "~")
+    info.append("User cfg:  ", style="dim")
+    info.append(f"{user_config}\n")
+
+    workspace_config = str(ctx.settings.workspace_root / ".leapflow" / "config.yaml")
+    info.append("Workspace: ", style="dim")
+    info.append(f"{workspace_config.replace(os.path.expanduser('~'), '~')}\n")
+
+    session_id = getattr(ctx.session, "session_id", "")
+    if session_id:
+        info.append("Session:   ", style="dim")
+        info.append(f"{session_id}\n")
+
+    from leapflow.engine.session import SessionMode
+    mode = "idle"
+    if ctx.session:
+        if ctx.session.mode == SessionMode.LEARNING:
+            mode = "learning"
+        elif ctx.session.mode == SessionMode.EXECUTING:
+            mode = "executing"
+    info.append("Mode:      ", style="dim")
+    info.append(f"{mode}\n")
+
+    gw = getattr(ctx, "gateway_server", None)
+    if gw is not None:
+        statuses = gw.platform_status()
+        connected = [s for s in statuses if s.connected]
+        info.append("Gateway:   ", style="dim")
+        if connected:
+            names = []
+            for s in connected:
+                m = gw.manifests.get(s.platform_id)
+                names.append(m.display_name if m else s.platform_id)
+            info.append(f"{', '.join(names)}\n", style="green")
+        else:
+            info.append("no connections\n", style="dim")
+
+    console.print(Panel(
+        info,
+        title="[bold cyan]LeapFlow Status[/]",
+        border_style="bright_black",
+        padding=(0, 2),
+    ))
+
+
+def handle_tool(ctx: "Context", console: "LeapConsole", args: str) -> None:
+    """Display available tools grouped by category."""
+    render_tool_payload(console, build_tool_payload(ctx))
+
+
+def handle_usage(ctx: "Context", console: "LeapConsole", args: str) -> None:
+    """Display token usage for the current session."""
+    render_usage_payload(console, build_usage_payload(ctx))
+
+
+def handle_model(ctx: "Context", console: "LeapConsole", args: str) -> None:
+    """Show or switch the active model."""
+    render_model_payload(console, build_model_payload(ctx, args))
+
+
+def handle_config(ctx: "Context", console: "LeapConsole", args: str) -> None:
+    """View or update runtime configuration."""
+    render_config_payload(console, build_config_payload(ctx, args))
+
+
+def handle_gateway(ctx: "Context", console: "LeapConsole", args: str) -> None:
+    """Display gateway status: connected platforms, available integrations."""
+    from rich.panel import Panel
+    from rich.text import Text
+
+    gw = getattr(ctx, "gateway_server", None)
+    if gw is None:
+        console.warning("Gateway not initialised.")
+        return
+
+    statuses = gw.platform_status()
+    if not statuses:
+        console.system("No platform manifests discovered.")
+        return
+
+    info = Text()
+    connected = [s for s in statuses if s.connected]
+    configured = [s for s in statuses if not s.connected and s.error == "configured but not connected"]
+    available = [s for s in statuses if not s.connected and not s.error]
+
+    import time
+
+    if connected:
+        info.append("Connected\n", style="bold green")
+        for s in connected:
+            m = gw.manifests.get(s.platform_id)
+            name = m.display_name if m else s.platform_id
+            uptime = ""
+            if s.connected_since > 0:
+                secs = int(time.time() - s.connected_since)
+                if secs < 60:
+                    uptime = f" ({secs}s)"
+                elif secs < 3600:
+                    uptime = f" ({secs // 60}m)"
+                else:
+                    uptime = f" ({secs // 3600}h {(secs % 3600) // 60}m)"
+            info.append(f"  ● {name}{uptime}\n", style="green")
+
+    if configured:
+        info.append("Configured (not connected)\n", style="bold yellow")
+        for s in configured:
+            m = gw.manifests.get(s.platform_id)
+            name = m.display_name if m else s.platform_id
+            info.append(f"  ○ {name}\n", style="yellow")
+
+    if available:
+        info.append("Available\n", style="bold dim")
+        names = [gw.manifests[s.platform_id].display_name for s in available if s.platform_id in gw.manifests]
+        info.append(f"  {', '.join(names)}\n", style="dim")
+
+    info.append("\n", style="dim")
+    info.append('Say "connect to <platform>" to set up a new integration.', style="dim italic")
+
+    console.print(Panel(
+        info,
+        title="[bold cyan]Gateway[/]",
+        border_style="bright_black",
+        padding=(0, 2),
+    ))
+
+
+def _app_usage() -> dict[str, Any]:
+    return {
+        "ok": False,
+        "error": "Usage: /app [platform] | /app status [platform] | /app connect <platform> [--option value] | /app disconnect <platform> | /app remove <platform> | /app events [status|start|stop] <platform> | /app actions <platform>",
+        "next_actions": ("/app", "/app <platform>", "/app status <platform>"),
+    }
+
+
+def _parse_app_options(tokens: list[str]) -> tuple[dict[str, str], str]:
+    options: dict[str, str] = {}
+    index = 0
+    while index < len(tokens):
+        token = tokens[index]
+        if not token.startswith("--") or token == "--":
+            return {}, f"Unexpected argument: {token}"
+        key_value = token[2:]
+        if "=" in key_value:
+            key, value = key_value.split("=", 1)
+            if not key:
+                return {}, f"Invalid option: {token}"
+            options[key] = value
+            index += 1
+            continue
+        if index + 1 >= len(tokens):
+            return {}, f"Missing value for option: {token}"
+        key = key_value
+        if not key:
+            return {}, f"Invalid option: {token}"
+        options[key] = tokens[index + 1]
+        index += 2
+    return options, ""
+
+
+def _parse_app_params(args: str) -> dict[str, Any]:
+    try:
+        from leapflow.utils.shell_lex import split_args
+
+        tokens = split_args(args)
+    except ValueError as exc:
+        return {"ok": False, "error": f"Invalid /app arguments: {exc}"}
+
+    if not tokens or tokens[0].lower() == "list":
+        if len(tokens) > 1:
+            return _app_usage()
+        return {"ok": True, "params": {"action": "list"}, "view": "list"}
+
+    head = tokens[0].lower()
+    if head == "status":
+        if len(tokens) > 2:
+            return _app_usage()
+        params: dict[str, Any] = {"action": "status"}
+        if len(tokens) == 2:
+            params["platform"] = tokens[1].lower()
+        return {"ok": True, "params": params, "view": "status"}
+
+    if head == "connect":
+        if len(tokens) < 2:
+            return _app_usage()
+        options, error = _parse_app_options(tokens[2:])
+        if error:
+            return {
+                "ok": False,
+                "error": error,
+                "next_actions": ("/app connect <platform> --<option> <value>",),
+            }
+        params = {"action": "connect", "platform": tokens[1].lower()}
+        if options:
+            params["options"] = options
+        return {"ok": True, "params": params, "view": "connect"}
+
+    if head in {"disconnect", "remove"}:
+        if len(tokens) != 2:
+            return _app_usage()
+        return {
+            "ok": True,
+            "params": {"action": head, "platform": tokens[1].lower()},
+            "view": head,
+        }
+
+    if head == "events":
+        if len(tokens) == 2:
+            return {
+                "ok": True,
+                "params": {"action": "events_status", "platform": tokens[1].lower()},
+                "view": "events",
+            }
+        if len(tokens) == 3 and tokens[1].lower() in {"status", "start", "stop"}:
+            event_action = tokens[1].lower()
+            action = "events_status" if event_action == "status" else f"events_{event_action}"
+            return {
+                "ok": True,
+                "params": {"action": action, "platform": tokens[2].lower()},
+                "view": "events",
+            }
+        return _app_usage()
+
+    if head == "actions":
+        if len(tokens) != 2:
+            return _app_usage()
+        return {"ok": True, "platform": tokens[1].lower(), "view": "actions"}
+
+    if len(tokens) == 1:
+        return {
+            "ok": True,
+            "params": {"action": "guide", "platform": tokens[0].lower()},
+            "view": "guide",
+        }
+
+    return _app_usage()
+
+
+def _resolve_app_platform(gw: Any, platform: str) -> tuple[str, str]:
+    if not platform:
+        return "", ""
+    manifests = getattr(gw, "manifests", {}) or {}
+    if platform in manifests:
+        return platform, ""
+    folded = platform.casefold()
+    matches = [pid for pid in manifests if str(pid).casefold() == folded]
+    if len(matches) == 1:
+        return matches[0], ""
+    return "", f"Unknown platform: {platform}"
+
+
+def _available_app_ids(gw: Any) -> list[str]:
+    manifests = getattr(gw, "manifests", {}) or {}
+    return sorted(str(platform_id) for platform_id in manifests)
+
+
+def _coerce_app_option(field: Any, value: str) -> tuple[Any, str]:
+    choices = tuple(getattr(field, "choices", ()) or ())
+    if choices and value not in choices:
+        return None, f"Invalid value for --{field.key}: {value}. Choices: {', '.join(map(str, choices))}"
+
+    field_type = str(getattr(field, "field_type", "string") or "string").lower()
+    if field_type in {"string", "choice"}:
+        return value, ""
+    if field_type in {"integer", "int"}:
+        try:
+            return int(value), ""
+        except ValueError:
+            return None, f"Invalid integer for --{field.key}: {value}"
+    if field_type in {"number", "float"}:
+        try:
+            return float(value), ""
+        except ValueError:
+            return None, f"Invalid number for --{field.key}: {value}"
+    if field_type in {"boolean", "bool"}:
+        lowered = value.casefold()
+        if lowered in {"1", "true", "yes", "on"}:
+            return True, ""
+        if lowered in {"0", "false", "no", "off"}:
+            return False, ""
+        return None, f"Invalid boolean for --{field.key}: {value}"
+    return value, ""
+
+
+def _validate_app_options(manifest: Any, options: dict[str, str]) -> tuple[dict[str, Any], str]:
+    if not options:
+        return {}, ""
+    fields = {str(field.key): field for field in getattr(manifest, "options", ())}
+    unknown = sorted(key for key in options if key not in fields)
+    if unknown:
+        available = ", ".join(sorted(fields)) or "no options"
+        return {}, f"Unknown option(s): {', '.join(unknown)}. Available options: {available}"
+
+    coerced: dict[str, Any] = {}
+    for key, value in options.items():
+        converted, error = _coerce_app_option(fields[key], value)
+        if error:
+            return {}, error
+        coerced[key] = converted
+    return coerced, ""
+
+
+async def build_app_payload(ctx: "Context", args: str = "") -> dict[str, Any]:
+    """Build a serializable App Connector slash-command payload."""
+    gw = getattr(ctx, "gateway_server", None)
+    if gw is None:
+        return {
+            "ok": False,
+            "error": "Gateway is not initialised in this session.",
+            "next_actions": ("Start an in-process LeapFlow session", "Use /help to inspect runtime support"),
+        }
+
+    parsed = _parse_app_params(args)
+    if not parsed.get("ok"):
+        parsed.setdefault("available", _available_app_ids(gw))
+        return parsed
+
+    from leapflow.tools.gateway_tool import platform_action_capability_summary, platform_connect_handler, set_gateway_server
+
+    set_gateway_server(gw)
+    if parsed.get("view") == "actions":
+        platform, error = _resolve_app_platform(gw, str(parsed.get("platform") or ""))
+        if error:
+            return {"ok": False, "error": error, "available": _available_app_ids(gw)}
+        manifest = gw.manifests.get(platform)
+        if manifest is None:
+            return {"ok": False, "error": f"Unknown platform: {platform}", "available": _available_app_ids(gw)}
+        actions = dict(getattr(manifest, "actions", {}) or {})
+        action_summaries = platform_action_capability_summary(platform)
+        return {
+            "ok": True,
+            "view": "actions",
+            "platform": platform,
+            "name": getattr(manifest, "display_name", platform),
+            "action_pack": str(actions.get("pack") or ""),
+            "actions": [item["name"] for item in action_summaries if item.get("name")],
+            "action_details": action_summaries,
+        }
+
+    params = dict(parsed.get("params") or {})
+    platform = str(params.get("platform") or "")
+    if platform:
+        resolved, error = _resolve_app_platform(gw, platform)
+        if error:
+            return {"ok": False, "error": error, "available": _available_app_ids(gw)}
+        params["platform"] = resolved
+        manifest = gw.manifests.get(resolved)
+        if manifest is not None and params.get("action") == "connect":
+            options, option_error = _validate_app_options(
+                manifest,
+                dict(params.get("options") or {}),
+            )
+            if option_error:
+                return {
+                    "ok": False,
+                    "error": option_error,
+                    "available": _available_app_ids(gw),
+                    "next_actions": (f"/app {resolved}", f"/app connect {resolved}"),
+                }
+            if options:
+                params["options"] = options
+
+    result = await platform_connect_handler(params)
+    view = str(parsed.get("view") or "")
+    if params.get("action") == "connect" and result.get("setup_guide"):
+        view = "guide"
+    return {
+        "ok": bool(result.get("ok")),
+        "view": view,
+        "params": params,
+        "result": result,
+    }
+
+
+def _append_result_metadata(lines: list[str], result: dict[str, Any]) -> None:
+    diagnostics = result.get("diagnostics") or result.get("metadata")
+    if isinstance(diagnostics, dict) and diagnostics:
+        for key in ("backend_kind", "profile", "identity", "auth_status", "configured", "current_mode"):
+            if diagnostics.get(key) is not None:
+                lines.append(f"  {key}: {diagnostics[key]}")
+    recovery_hint = result.get("recovery_hint")
+    if recovery_hint:
+        lines.append(f"  recovery: {recovery_hint}")
+    next_steps = result.get("next_steps")
+    if isinstance(next_steps, list) and next_steps:
+        lines.append("  next steps:")
+        lines.extend(f"    - {step}" for step in next_steps)
+
+
+def render_app_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    """Render a serializable App Connector slash-command payload."""
+    from rich.panel import Panel
+    from rich.table import Table
+    from rich.text import Text
+
+    if not payload.get("ok"):
+        result = dict(payload.get("result") or {})
+        message = (
+            payload.get("error")
+            or result.get("error")
+            or result.get("detail")
+            or "App command failed."
+        )
+        console.warning(str(message))
+        lines: list[str] = []
+        _append_result_metadata(lines, result)
+        for line in lines:
+            console.system(line)
+        available = payload.get("available")
+        if isinstance(available, list) and available:
+            console.system("Available: " + ", ".join(str(item) for item in available))
+        for action in payload.get("next_actions") or ():
+            console.system(f"  → {action}")
+        return
+
+    result = dict(payload.get("result") or {})
+    view = str(payload.get("view") or "")
+    if view == "list":
+        platforms = list(result.get("platforms") or [])
+        table = Table(title="App Connector", show_header=True, header_style="bold", border_style="bright_black")
+        table.add_column("App", style="cyan")
+        table.add_column("ID", style="bold")
+        table.add_column("State")
+        table.add_column("Category")
+        table.add_column("Next")
+        for entry in platforms:
+            platform_id = str(entry.get("id") or "")
+            state = str(entry.get("state") or "available")
+            style = "green" if state == "connected" else ("yellow" if state == "configured" else "dim")
+            table.add_row(
+                str(entry.get("name") or platform_id),
+                platform_id,
+                f"[{style}]{state}[/]",
+                str(entry.get("category") or ""),
+                f"/app {platform_id}",
+            )
+        console.print(table)
+        console.system("Next: /app <platform> · /app status <platform> · /app connect <platform>")
+        return
+
+    if view == "guide":
+        info = Text()
+        info.append(str(result.get("setup_guide") or "No setup guide available.") + "\n")
+        steps = result.get("setup_steps") or []
+        if steps:
+            info.append("\nSteps\n", style="bold")
+            for index, step in enumerate(steps, start=1):
+                info.append(f"  {index}. {step}\n")
+        preflight = result.get("preflight_checks") or []
+        if preflight:
+            info.append("\nPreflight\n", style="bold")
+            for check in preflight:
+                command = check.get("command") or ""
+                label = check.get("label") or check.get("key") or "check"
+                info.append(f"  - {label}: {command}\n")
+        fields = result.get("required_fields") or []
+        if fields:
+            info.append("\nRequired fields\n", style="bold")
+            for field in fields:
+                required = "required" if field.get("required") else "optional"
+                info.append(f"  - {field.get('key')}: {field.get('label')} ({required})\n")
+        console_url = result.get("console_url")
+        if console_url:
+            info.append(f"\nConsole: {console_url}\n", style="dim")
+        platform = str(result.get("platform") or payload.get("params", {}).get("platform") or "App")
+        console.print(Panel(info, title=f"[bold cyan]{platform} setup[/]", border_style="bright_black", padding=(0, 2)))
+        platform_id = str(payload.get("params", {}).get("platform") or "<platform>")
+        if fields:
+            console.system(
+                "Next: provide required credentials through the guided chat flow, "
+                f"then run /app connect {platform_id}"
+            )
+        else:
+            console.system(f"Next: /app connect {platform_id}")
+        return
+
+    if view == "status":
+        platforms = result.get("platforms")
+        if isinstance(platforms, list):
+            table = Table(title="App Status", show_header=True, header_style="bold", border_style="bright_black")
+            table.add_column("ID", style="bold")
+            table.add_column("Connected")
+            table.add_column("Detail")
+            for entry in platforms:
+                detail = str(entry.get("error") or entry.get("uptime") or "available")
+                table.add_row(str(entry.get("id") or ""), "yes" if entry.get("connected") else "no", detail)
+            console.print(table)
+            return
+        lines = [f"platform: {result.get('platform')}", f"connected: {bool(result.get('connected'))}"]
+        if result.get("error"):
+            lines.append(f"detail: {result['error']}")
+        if result.get("uptime"):
+            lines.append(f"uptime: {result['uptime']}")
+        _append_result_metadata(lines, result)
+        console.print(Panel("\n".join(lines), title="[bold cyan]App Status[/]", border_style="bright_black", padding=(0, 2)))
+        return
+
+    if view == "actions":
+        action_names = list(payload.get("actions") or [])
+        action_details = list(payload.get("action_details") or [])
+        lines = [f"platform: {payload.get('name')}"]
+        if payload.get("action_pack"):
+            lines.append(f"action pack: {payload['action_pack']}")
+        if action_names:
+            lines.append("registered actions:")
+            details_by_name = {str(item.get("name")): item for item in action_details}
+            for name in action_names:
+                detail = details_by_name.get(name, {})
+                description = str(detail.get("description") or "").strip()
+                suffix = f" — {description}" if description else ""
+                lines.append(f"  - {name}{suffix}")
+        else:
+            lines.append("registered actions: none")
+        console.print(Panel("\n".join(lines), title="[bold cyan]App Actions[/]", border_style="bright_black", padding=(0, 2)))
+        return
+
+    if result.get("ok"):
+        platform = result.get("platform") or payload.get("params", {}).get("platform") or "App"
+        status = result.get("status") or result.get("detail") or "ok"
+        lines = [f"{platform}: {status}"]
+        _append_result_metadata(lines, result)
+        console.success("App command completed")
+        console.system("\n".join(lines))
+        return
+
+    message = result.get("error") or result.get("detail") or "App command failed."
+    console.warning(str(message))
+    lines: list[str] = []
+    _append_result_metadata(lines, result)
+    for line in lines:
+        console.system(line)
+
+
+async def handle_app(ctx: "Context", console: "LeapConsole", args: str) -> None:
+    """Manage external App Connector integrations from slash commands."""
+    render_app_payload(console, await build_app_payload(ctx, args))
+
+
+# NOTE: screen clearing is owned by ``LeapApp.clear_screen()``. It must go
+# through the prompt_toolkit renderer that owns the TTY — a shell ``clear``
+# leaves the renderer's cursor cache stale and misplaces the next redraw — so
+# there is deliberately no clear handler here.
+
+
+# ══════════════════════════════════════════════════════════════════════
+# Unified command_execute: dispatches any engine-routed slash command
+# ══════════════════════════════════════════════════════════════════════
+
+
+def build_orient_payload(ctx: "Context") -> dict[str, Any]:
+    """Read-only unified orientation view (S4-D1) + pending re-entry status.
+
+    Surfaces what the agent is currently oriented on (immediate / working /
+    long-term layers, weight-ranked) plus any armed/due re-entry triggers.
+    Observe-only; changes no state.
+    """
+    engine = ctx.engine
+    if engine is None:
+        return {"ok": False, "error": "No active engine — send a message first."}
+    view_fn = getattr(engine, "orientation_view", None)
+    if view_fn is None:
+        return {"ok": False, "error": "Orientation view not available."}
+    orientation = view_fn()
+    lines = ["Orientation (immediate / working / long-term):"]
+    items = orientation.top(12)
+    if not items:
+        lines.append("  (empty — no active findings or open questions yet)")
+    else:
+        lines.extend(f"  - ({it.layer}) {it.text}" for it in items)
+    store = getattr(ctx, "_reentry_store", None)
+    if store is not None:
+        try:
+            import time as _time
+            armed = store.list_armed_events()
+            due = store.list_due(_time.time())
+            lines.append(f"Re-entry: {len(armed)} armed event trigger(s), {len(due)} due now.")
+        except Exception:
+            pass
+    return {
+        "ok": True,
+        "message": "\n".join(lines),
+        "orientation": orientation.summary(),
+    }
+
+
+async def command_execute(
+    ctx: "Context", name: str, args: str = "", session_id: str = "",
+) -> dict[str, Any]:
+    """Execute a slash command and return a serializable result payload.
+
+    This is the unified entry point for daemon-mode command execution.
+    Returns a dict with at minimum ``ok`` and ``message`` keys, plus
+    optional structured data for rich TUI rendering. ``session_id`` identifies
+    the calling client's session for commands that observe it (e.g. ``/board``).
+    """
+    if name == "status":
+        return build_status_payload(ctx)
+    if name == "orient":
+        return build_orient_payload(ctx)
+    if name == "tool":
+        return build_tool_payload(ctx)
+    if name == "usage":
+        return build_usage_payload(ctx)
+    if name == "model":
+        return build_model_payload(ctx, args)
+    if name == "config":
+        return build_config_payload(ctx, args)
+    if name == "gateway":
+        return build_gateway_payload(ctx)
+    if name == "host":
+        return await _execute_host(ctx, args)
+    if _is_app_command_name(name):
+        app_args = name[len("app"):].strip()
+        if app_args:
+            app_args = app_args + (" " + args if args else "")
+        else:
+            app_args = args
+        return await build_app_payload(ctx, app_args)
+    if name.startswith("teach") or name == "annotate":
+        return await _execute_teach(ctx, name, args)
+    if name == "skill" or name.startswith("skill "):
+        return _execute_skill(ctx, name, args)
+    if name.startswith("hub"):
+        return await _execute_hub(ctx, name, args)
+    if name == "run":
+        return {"ok": True, "stream": True, "prompt": args}
+    if name == "arm":
+        return await _execute_scheduler_arm(ctx, args)
+    if name == "task":
+        return _execute_scheduler_task(ctx)
+    if name == "board" or name.startswith("board "):
+        return await _execute_dashboard(ctx, name, args, session_id=session_id)
+    return {"ok": False, "message": f"Unknown command: /{name}"}
+
+
+async def _ensure_session_watch_refresh(
+    ctx: "Context", monitors: Any, session_id: str = "",
+) -> str:
+    """Ensure an active session watch exists and trigger one analysis cycle.
+
+    The analysis producer is LLM-backed and can take tens of seconds, so it is
+    scheduled in the background: arming the watch and opening the board must be
+    instant and must never block the command RPC past its timeout. The board
+    receives the resulting finding over WebSocket when the cycle completes.
+    ``session_id`` binds the watch to the caller's session so the analysis reads
+    that conversation rather than whichever session was last active.
+    Returns the session watch id.
+    """
+    from leapflow.monitor.session_producer import ensure_session_watch, session_watch_params
+
+    params = session_watch_params(getattr(ctx, "settings", None))
+    if session_id:
+        params["session_id"] = session_id
+    watch_id = await ensure_session_watch(monitors, params=params)
+    monitors.schedule_watch_once(watch_id, force=True)
+    return watch_id
+
+
+_BOARD_VERBS = frozenset({"templates", "refresh", "pause", "resume", "stop", "status"})
+
+# States in which a watch can still be paused/resumed/stopped (i.e. not terminal).
+_BOARD_CONTROLLABLE_STATES = frozenset(
+    {"armed", "watching", "due", "confirming", "executing", "suspended"}
+)
+
+
+async def _execute_dashboard(
+    ctx: "Context", name: str, args: str = "", session_id: str = "",
+) -> dict[str, Any]:
+    """Analyze the current session and render it through a template.
+
+    LeapBoard has a single analysis target — the current session. ``/board``
+    opens the default (``generic``) lens; ``/board <template>`` opens a known
+    lens. Reserved verbs manage templates and the session observation. Any other
+    token is an unknown command and is rejected (never silently coerced).
+    """
+    monitors = getattr(ctx, "monitors", None)
+    sub = name.split(" ", 1)[1].strip() if " " in name else ""
+    rest = (sub + ((" " + args) if args else "")).strip() if sub else args.strip()
+    try:
+        from leapflow.utils.shell_lex import split_args
+
+        tokens = split_args(rest) if rest else []
+    except ValueError:
+        tokens = rest.split()
+    verb = tokens[0].lower() if tokens else ""
+    rest_tokens = tokens[1:]
+
+    if verb == "templates":
+        return _execute_board_templates(ctx, rest_tokens)
+    if verb == "status":
+        return _execute_board_status(ctx, monitors)
+    if verb in ("refresh", "pause", "resume", "stop"):
+        return await _execute_board_control(
+            ctx, monitors, verb, target=rest_tokens[0] if rest_tokens else "",
+        )
+    if not verb:
+        return await _execute_board_open(ctx, monitors, template="", session_id=session_id)
+    # A non-empty, non-verb token must name a known template lens; otherwise it
+    # is an unknown command and is rejected rather than coerced to generic.
+    if verb in set(_template_library(ctx).names()):
+        return await _execute_board_open(ctx, monitors, template=verb, session_id=session_id)
+    return {
+        "ok": False,
+        "message": (
+            f"Unknown board command: '{verb}'. Use /board for the session board, "
+            "/board <template> for a lens (see /board templates), or "
+            "/board templates|refresh|pause|resume|stop|status."
+        ),
+    }
+
+
+async def _execute_board_open(
+    ctx: "Context", monitors: Any, *, template: str, session_id: str = "",
+) -> dict[str, Any]:
+    """Open the current-session board rendered with the requested template.
+
+    ``template`` is guaranteed to be empty (default) or a known lens by the
+    dispatcher, so there is no silent fallback here.
+    """
+    session_watch_id = ""
+    if monitors is not None:
+        try:
+            session_watch_id = await _ensure_session_watch_refresh(ctx, monitors, session_id)
+        except Exception:
+            logger.debug("dashboard: session watch refresh failed", exc_info=True)
+    # The client owns the dashboard server lifecycle (it spawns/validates it off
+    # the event loop), so the daemon only conveys the chosen lens here.
+    payload: dict[str, Any] = {
+        "ok": True, "view": "dashboard", "mode": "open", "template": template or "generic",
+    }
+    if session_watch_id:
+        payload["watch_id"] = session_watch_id
+    return payload
+
+
+async def _execute_board_control(
+    ctx: "Context", monitors: Any, verb: str, *, target: str = "",
+) -> dict[str, Any]:
+    """Control a board observation: refresh / pause / resume / stop.
+
+    Without ``target`` the verb applies to the current session watch (``refresh``
+    starts it if absent; the others require an existing one). With ``target`` it
+    applies to the watch whose id — a full id or a unique prefix, as shown by
+    ``/board status`` — matches, so ``/board stop <id>`` stops that watch.
+    """
+    if monitors is None:
+        return {"ok": False, "message": "Monitor runtime is unavailable (scheduler disabled)."}
+
+    if target:
+        watch_id = _resolve_watch_id(monitors, target)
+        if not watch_id:
+            return {"ok": False,
+                    "message": f"No board watch matches '{target}'. Run /board status to see ids."}
+    elif verb == "refresh":
+        from leapflow.monitor.session_producer import ensure_session_watch, session_watch_params
+        watch_id = await ensure_session_watch(
+            monitors, params=session_watch_params(getattr(ctx, "settings", None))
+        )
+    else:
+        watch_id = _find_session_watch_id(monitors)
+        if not watch_id:
+            return {"ok": False,
+                    "message": f"No active session board to {verb}. Run /board to start one."}
+
+    if verb == "refresh":
+        monitors.schedule_watch_once(watch_id, force=True)
+        return {"ok": True, "view": "dashboard", "mode": "control", "action": "refresh",
+                "watch_id": watch_id,
+                "message": "Re-analyzing the current session; the board updates when it completes."}
+
+    method = {"pause": monitors.pause_watch, "resume": monitors.resume_watch,
+              "stop": monitors.stop_watch}[verb]
+    view = method(watch_id)
+    if view is None:
+        return {"ok": False, "message": f"Watch not found: {watch_id[:8]}."}
+    label = view.name or watch_id[:8]
+    messages = {
+        "pause": f"Paused {label}; use /board resume to continue.",
+        "resume": f"Resumed {label}.",
+        "stop": f"Stopped {label}; run /board to start again.",
+    }
+    return {"ok": True, "view": "dashboard", "mode": "control", "action": verb,
+            "watch": view.to_dict(), "message": messages[verb]}
+
+
+def _resolve_watch_id(monitors: Any, target: str) -> str:
+    """Resolve a watch id from an exact id or a unique prefix (as /board status shows)."""
+    target = target.strip()
+    if not target:
+        return ""
+    try:
+        views = list(monitors.list_watches())
+    except Exception:
+        return ""
+    for view in views:
+        if view.watch_id == target:
+            return view.watch_id
+    prefix_matches = [view.watch_id for view in views if view.watch_id.startswith(target)]
+    return prefix_matches[0] if len(prefix_matches) == 1 else ""
+
+
+def _find_session_watch_id(monitors: Any) -> str:
+    """Return the current controllable session watch id, or empty when none is active."""
+    try:
+        views = list(monitors.list_watches())
+    except Exception:
+        return ""
+    for view in views:
+        if view.domain == "session" and view.state in _BOARD_CONTROLLABLE_STATES:
+            return view.watch_id
+    return ""
+
+
+def _execute_board_status(ctx: "Context", monitors: Any) -> dict[str, Any]:
+    """Return session-observation status: watch detail + recent findings + lenses.
+
+    Fields:
+      - ``templates`` / ``default``: available lenses and the default.
+      - ``watches``: every watch with state, run/finding counts, and last-run age.
+      - ``findings``: recent findings (severity, title, summary, age) across watches.
+    """
+    library = _template_library(ctx)
+    data: dict[str, Any] = {
+        "ok": True, "view": "dashboard", "mode": "status",
+        "templates": library.names(), "default": "generic",
+        "watches": [], "findings": [],
+    }
+    if monitors is None:
+        return data
+    try:
+        data["watches"] = [v.to_dict() for v in monitors.list_watches()]
+    except Exception:
+        logger.debug("dashboard: watch list unavailable", exc_info=True)
+    try:
+        data["findings"] = [f.to_dict() for f in monitors.list_findings(limit=20)]
+    except Exception:
+        logger.debug("dashboard: finding list unavailable", exc_info=True)
+    return data
+
+
+def _execute_board_templates(ctx: "Context", rest_tokens: list[str]) -> dict[str, Any]:
+    """Template hub: list / add / remove / show board templates."""
+    from leapflow.dashboard.templates import sanitize_template_id
+
+    library = _template_library(ctx)
+    op = rest_tokens[0].lower() if rest_tokens else "list"
+    args = rest_tokens[1:]
+
+    if op == "list":
+        items = [library.describe(name) or {"name": name} for name in library.names()]
+        return {"ok": True, "view": "dashboard", "mode": "templates",
+                "templates": items, "default": "generic"}
+
+    if op == "add":
+        positional = [t for t in args if not t.startswith("--")]
+        if not positional:
+            return {"ok": False, "message": "Usage: /board templates add <path.yaml> [--name id] [--force]"}
+        requested = _flag_value(args, "--name")
+        candidate = sanitize_template_id(requested or Path(positional[0]).stem)
+        if candidate in _BOARD_VERBS:
+            return {"ok": False, "message": f"'{candidate}' is a reserved board command; choose another --name."}
+        try:
+            installed = library.install(Path(positional[0]), name=requested, force="--force" in args)
+        except ValueError as exc:
+            return {"ok": False, "message": f"Could not add template: {exc}"}
+        return {"ok": True, "view": "dashboard", "mode": "templates", "action": "add",
+                "template": installed,
+                "message": f"Registered template '{installed}'. Open it with /board {installed}."}
+
+    if op == "remove":
+        if not args:
+            return {"ok": False, "message": "Usage: /board templates remove <id>"}
+        if library.source_of(args[0]) == "builtin":
+            return {"ok": False, "message": f"'{args[0]}' is a builtin template and cannot be removed."}
+        removed = library.uninstall(args[0])
+        return {"ok": bool(removed), "view": "dashboard", "mode": "templates", "action": "remove",
+                "message": f"Removed template '{args[0]}'." if removed else f"No custom template '{args[0]}'."}
+
+    if op == "show":
+        if not args:
+            return {"ok": False, "message": "Usage: /board templates show <id>"}
+        info = library.describe(args[0])
+        if info is None:
+            return {"ok": False, "message": f"Template not found: {args[0]}"}
+        return {"ok": True, "view": "dashboard", "mode": "templates", "action": "show", "detail": info}
+
+    return {"ok": False, "message": "Usage: /board templates [list|add|remove|show] ..."}
+
+
+def _template_library(ctx: "Context") -> Any:
+    """Build a TemplateLibrary bound to the profile's custom-template override dir."""
+    from leapflow.dashboard.templates import TemplateLibrary
+
+    override_dir = None
+    settings = getattr(ctx, "settings", None)
+    profile_layout = getattr(settings, "profile_layout", None) if settings is not None else None
+    if profile_layout is not None:
+        try:
+            override_dir = profile_layout.dashboard.templates_dir
+        except Exception:
+            override_dir = None
+    return TemplateLibrary(override_dir=override_dir)
+
+
+def _flag_value(tokens: list[str], flag: str) -> str:
+    """Return the value following ``flag`` in tokens, or '' when absent."""
+    if flag in tokens:
+        idx = tokens.index(flag)
+        if idx + 1 < len(tokens) and not tokens[idx + 1].startswith("--"):
+            return tokens[idx + 1]
+    return ""
+
+
+def _is_app_command_name(name: str) -> bool:
+    return name == "app" or name.startswith("app ")
+
+
+def build_status_payload(ctx: "Context") -> dict[str, Any]:
+    """Build a serializable status summary."""
+    engine = ctx.engine
+    context_length = 0
+    context_used = 0
+    turn_count = 0
+    if engine is not None:
+        cap_registry = getattr(engine, "model_capabilities", None)
+        if cap_registry is not None:
+            caps = cap_registry.resolve(ctx.settings.llm_model)
+            context_length = int(caps.context_length)
+        context_used = int(getattr(engine, "context_token_count", 0))
+        turn_count = int(getattr(engine, "turn_count", 0))
+
+    platform_status = "connected" if (hasattr(ctx.rpc, "connected") and ctx.rpc.connected) else "mock"
+    cwd = os.getcwd().replace(os.path.expanduser("~"), "~")
+
+    from leapflow.engine.session import SessionMode
+    mode = "idle"
+    if ctx.session:
+        if ctx.session.mode == SessionMode.LEARNING:
+            mode = "learning"
+        elif ctx.session.mode == SessionMode.EXECUTING:
+            mode = "executing"
+
+    gateway_connected: list[str] = []
+    gw = getattr(ctx, "gateway_server", None)
+    if gw is not None:
+        statuses = gw.platform_status()
+        for s in statuses:
+            if s.connected:
+                m = gw.manifests.get(s.platform_id)
+                gateway_connected.append(m.display_name if m else s.platform_id)
+
+    return {
+        "ok": True,
+        "view": "status",
+        "model": ctx.settings.llm_model,
+        "context_length": context_length,
+        "context_used": context_used,
+        "turn_count": turn_count,
+        "platform": platform_status,
+        "cwd": cwd,
+        "config_path": str(ctx.settings.profile_layout.config_dir).replace(os.path.expanduser("~"), "~"),
+        "user_config_path": str(ctx.settings.layout.user_config_path).replace(os.path.expanduser("~"), "~"),
+        "workspace_config_path": str(ctx.settings.workspace_root / ".leapflow" / "config.yaml").replace(os.path.expanduser("~"), "~"),
+        "session_id": getattr(ctx.session, "session_id", "") if ctx.session else "",
+        "mode": mode,
+        "gateway_connected": gateway_connected,
+    }
+
+
+def build_gateway_payload(ctx: "Context") -> dict[str, Any]:
+    """Build a serializable gateway status payload."""
+    import time as _time
+
+    gw = getattr(ctx, "gateway_server", None)
+    if gw is None:
+        return {"ok": False, "message": "Gateway not initialised."}
+
+    statuses = gw.platform_status()
+    if not statuses:
+        return {"ok": True, "view": "gateway", "connected": [], "configured": [], "available": []}
+
+    connected = []
+    configured = []
+    available = []
+    for s in statuses:
+        m = gw.manifests.get(s.platform_id)
+        name = m.display_name if m else s.platform_id
+        if s.connected:
+            uptime = ""
+            if s.connected_since > 0:
+                secs = int(_time.time() - s.connected_since)
+                if secs < 60:
+                    uptime = f"{secs}s"
+                elif secs < 3600:
+                    uptime = f"{secs // 60}m"
+                else:
+                    uptime = f"{secs // 3600}h {(secs % 3600) // 60}m"
+            connected.append({"name": name, "id": s.platform_id, "uptime": uptime})
+        elif s.error:
+            configured.append({"name": name, "id": s.platform_id})
+        else:
+            available.append({"name": name, "id": s.platform_id})
+    return {"ok": True, "view": "gateway", "connected": connected, "configured": configured, "available": available}
+
+
+async def _execute_host(ctx: "Context", args: str) -> dict[str, Any]:
+    """Execute /host command."""
+    action = args.strip().lower() if args.strip() else "status"
+    if action not in {"status", "start", "stop", "restart"}:
+        return {"ok": False, "message": "Usage: /host [status|start|stop|restart]"}
+    if action == "status":
+        result = await ctx.host_backend_status()
+    elif action == "start":
+        result = await ctx.host_backend_start()
+    elif action == "stop":
+        result = await ctx.host_backend_stop()
+    else:
+        result = await ctx.host_backend_restart()
+    return {"ok": True, "view": "host", "action": action, "result": result}
+
+
+async def _distill_background(session) -> None:
+    """Run distillation in background without blocking the RPC response."""
+    import logging
+    _log = logging.getLogger(__name__)
+    try:
+        final = await session.await_learning()
+        if final and final.candidates:
+            _log.info(
+                "background_distill: %d candidates, activated=%s",
+                len(final.candidates),
+                final.activated_skill_names or [],
+            )
+        else:
+            _log.info("background_distill: no candidates produced")
+    except Exception:
+        _log.warning("background_distill failed", exc_info=True)
+
+
+async def _execute_teach(ctx: "Context", name: str, args: str) -> dict[str, Any]:
+    """Execute teach commands.
+
+    Returns ``session_mode`` in the payload so the TUI client can track
+    whether it should route subsequent inputs as annotations.
+    """
+    from leapflow.engine.session import SessionMode
+
+    full_cmd = name + (" " + args if args else "")
+    if full_cmd in ("teach start", "teach") or full_cmd.startswith("teach start "):
+        if ctx.session is None:
+            return {"ok": False, "message": "No active session.", "session_mode": "idle"}
+        if ctx.session.mode == SessionMode.LEARNING:
+            return {"ok": False, "message": "Already in teaching mode. Say '/teach stop' to end.", "session_mode": "learning"}
+        goal = args if name == "teach start" else ""
+        try:
+            session = await ctx.session.enter_learning(goal=goal)
+            msg = f"Teaching started — session {session.session_id}"
+            if goal:
+                msg += f"\nGoal: {goal}"
+            msg += "\nCommands: /teach stop │ /teach discard │ /teach pause │ /teach resume │ /teach skip [n] │ /annotate <text>"
+            return {"ok": True, "message": msg, "session_mode": "learning"}
+        except Exception as e:
+            return {"ok": False, "message": str(e)}
+
+    if name == "teach stop":
+        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
+            return {"ok": False, "message": "Not in teaching mode.", "session_mode": "idle"}
+        try:
+            result = await ctx.session.exit_learning()
+            msg = f"Recording stopped — {result.step_count} steps, {result.duration:.1f}s"
+            if result.step_count == 0:
+                msg += "\nNo steps recorded — nothing to distill."
+            elif not getattr(ctx.settings, "has_llm_credentials", False):
+                msg += "\nNo LLM credentials — distillation skipped."
+            elif ctx.session.has_pending_distillation:
+                import asyncio
+                asyncio.create_task(_distill_background(ctx.session))
+                msg += "\nDistillation started in background."
+            else:
+                report = getattr(result, "learnability_report", None)
+                reason = getattr(report, "reason", "assessment decided to skip") if report else "auto-learn disabled"
+                msg += f"\nDistillation skipped: {reason}"
+            return {
+                "ok": True,
+                "message": msg,
+                "step_count": result.step_count,
+                "duration": result.duration,
+                "session_mode": "idle",
+            }
+        except Exception as e:
+            return {"ok": False, "message": str(e), "session_mode": "idle"}
+
+    if name == "teach pause":
+        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
+            return {"ok": False, "message": "Not in teaching mode."}
+        ctx.session.pause_learning()
+        return {"ok": True, "message": "Teaching paused.", "session_mode": "paused"}
+
+    if name == "teach resume":
+        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
+            return {"ok": False, "message": "Not in teaching mode."}
+        ctx.session.resume_learning()
+        return {"ok": True, "message": "Teaching resumed.", "session_mode": "learning"}
+
+    if name == "teach discard":
+        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
+            return {"ok": False, "message": "Not in teaching mode."}
+        ctx.session.discard_learning()
+        return {"ok": True, "message": "Recording discarded.", "session_mode": "idle"}
+
+    if name == "teach skip":
+        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
+            return {"ok": False, "message": "Not in teaching mode."}
+        n = 1
+        if args.strip().isdigit():
+            n = int(args.strip())
+        ctx.session.skip_steps(n)
+        return {"ok": True, "message": f"Marked last {n} step(s) as noise.", "session_mode": "learning"}
+
+    if name == "annotate":
+        if not ctx.session or ctx.session.mode != SessionMode.LEARNING:
+            return {"ok": False, "message": "Not in teaching mode."}
+        if not args.strip():
+            return {"ok": False, "message": "Usage: /annotate <text>"}
+        ctx.session.annotate(args.strip())
+        return {"ok": True, "message": f"Annotation recorded: {args.strip()}", "session_mode": "learning"}
+
+    if name == "teach status":
+        if not ctx.session:
+            return {"ok": True, "message": "No active session.", "session_mode": "idle"}
+        mode = ctx.session.mode.value
+        result_payload: dict[str, Any] = {"ok": True, "session_mode": mode}
+        if mode == "evolving" or ctx.session.is_distilling:
+            result_payload["message"] = "Distillation in progress…"
+            result_payload["distilling"] = True
+        elif mode == "learning":
+            step_count = ctx.session.recording_step_count
+            result_payload["message"] = f"Recording — {step_count} steps captured."
+            result_payload["step_count"] = step_count
+        else:
+            last = ctx.session.last_result
+            if last:
+                candidates = getattr(last, "candidates", None) or []
+                new_skills = getattr(last, "new_skills", None) or []
+                result_payload["message"] = (
+                    f"Idle. Last result: {last.step_count} steps, "
+                    f"{len(candidates)} candidates, "
+                    f"{len(new_skills)} activated."
+                )
+            else:
+                result_payload["message"] = "Idle. No previous distillation results."
+        return result_payload
+
+    return {"ok": False, "message": f"Unknown teach command: /{full_cmd}"}
+
+
+def _execute_skill(ctx: "Context", name: str, args: str) -> dict[str, Any]:
+    """Execute skill commands."""
+    full_cmd = name + (" " + args if args else "")
+    if full_cmd in ("skill", "skill list"):
+        skills = ctx.registry.list_all() if ctx.registry else []
+        if not skills:
+            return {"ok": True, "view": "skill_list", "skills": []}
+        entries = []
+        for s in skills:
+            m = s.metadata
+            entries.append({
+                "name": s.name,
+                "version": m.version,
+                "confidence": m.confidence,
+                "description": s.description[:80],
+            })
+        return {"ok": True, "view": "skill_list", "skills": entries}
+
+    if name == "skill show":
+        skill_name = args.strip()
+        if not skill_name:
+            return {"ok": False, "message": "Usage: /skill show <name>"}
+        skill = ctx.registry.get(skill_name) if ctx.registry else None
+        if skill is None:
+            return {"ok": False, "message": f"Skill '{skill_name}' not found."}
+        m = skill.metadata
+        return {
+            "ok": True,
+            "view": "skill_show",
+            "name": skill.name,
+            "description": skill.description,
+            "version": m.version,
+            "confidence": m.confidence,
+            "triggers": list(skill.triggers) if skill.triggers else [],
+        }
+
+    if name == "skill disable":
+        skill_name = args.strip()
+        if not skill_name:
+            return {"ok": False, "message": "Usage: /skill disable <name>"}
+        found = False
+        if ctx.skill_lib and ctx.skill_lib.deactivate_parameterized(skill_name):
+            found = True
+        if ctx.registry and ctx.registry.unregister(skill_name):
+            found = True
+        if found:
+            return {"ok": True, "message": f"Skill '{skill_name}' disabled."}
+        return {"ok": False, "message": f"Skill '{skill_name}' not found."}
+
+    if name == "skill delete":
+        skill_name = args.strip()
+        if not skill_name:
+            return {"ok": False, "message": "Usage: /skill delete <name>"}
+        found = False
+        if ctx.skill_lib:
+            stored = ctx.skill_lib.load_skill_by_title(skill_name)
+            if stored:
+                stored.status = "deleted"
+                ctx.skill_lib.update_skill(stored)
+                found = True
+        if ctx.registry and ctx.registry.unregister(skill_name):
+            found = True
+        if found:
+            return {"ok": True, "message": f"Skill '{skill_name}' deleted."}
+        return {"ok": False, "message": f"Skill '{skill_name}' not found."}
+
+    return {"ok": False, "message": f"Unknown skill command: /{full_cmd}"}
+
+
+async def _execute_hub(ctx: "Context", name: str, args: str) -> dict[str, Any]:
+    """Execute hub commands."""
+    try:
+        from leapflow.cli.commands.hub import cmd_hub_payload
+        return await cmd_hub_payload(ctx, name, args)
+    except ImportError:
+        pass
+    # Fallback: basic hub dispatch
+    sub = name[len("hub"):].strip() if name.startswith("hub") else ""
+    if not sub:
+        sub = args.split()[0] if args.split() else ""
+        args = " ".join(args.split()[1:])
+    command_parts = ["/hub"]
+    if sub:
+        command_parts.append(sub)
+    if args:
+        command_parts.append(args)
+    command = " ".join(command_parts)
+    return {"ok": False, "message": f"Hub command '{command}' is not yet implemented in this runtime."}
+
+
+def _execute_scheduler_task(ctx: "Context") -> dict[str, Any]:
+    """Execute /task command."""
+    scheduler = getattr(ctx, "scheduler", None)
+    if scheduler is None:
+        return {"ok": True, "view": "task", "tasks": [], "message": "No scheduler active."}
+    tasks = scheduler.list_tasks() if hasattr(scheduler, "list_tasks") else []
+    entries = [
+        {"name": t.name, "schedule": t.schedule, "next_run": str(getattr(t, "next_run", ""))}
+        for t in tasks
+    ]
+    return {"ok": True, "view": "task", "tasks": entries}
+
+
+async def _execute_scheduler_arm(ctx: "Context", args: str) -> dict[str, Any]:
+    """Execute /arm command."""
+    scheduler = getattr(ctx, "scheduler", None)
+    if scheduler is None:
+        return {"ok": False, "message": "Scheduler not active in this session."}
+    tokens = args.strip().split(None, 1)
+    if len(tokens) < 2:
+        return {"ok": False, "message": "Usage: /arm <skill> <cron>"}
+    skill_name, cron_expr = tokens
+    try:
+        task_id = await scheduler.arm(skill_name, cron_expr)
+        return {"ok": True, "message": f"Armed: {skill_name} → {cron_expr} (id={task_id})"}
+    except Exception as e:
+        return {"ok": False, "message": str(e)}
+
+
+def render_command_payload(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    """Render a generic command_execute result payload in the TUI."""
+    if not payload.get("ok"):
+        console.warning(str(payload.get("message") or payload.get("error") or "Command failed."))
+        return
+
+    view = str(payload.get("view") or "")
+
+    if view == "status":
+        _render_status_view(console, payload)
+        return
+    if view == "model":
+        render_model_payload(console, payload)
+        return
+    if view == "config":
+        render_config_payload(console, payload)
+        return
+    if view == "gateway":
+        _render_gateway_view(console, payload)
+        return
+    if view == "host":
+        _render_host_view(console, payload)
+        return
+    if view == "skill_list":
+        _render_skill_list_view(console, payload)
+        return
+    if view == "skill_show":
+        _render_skill_show_view(console, payload)
+        return
+    if view == "task":
+        _render_task_view(console, payload)
+        return
+    if view == "dashboard":
+        _render_dashboard_view(console, payload)
+        return
+
+    msg = payload.get("message")
+    if msg:
+        console.success(str(msg))
+
+
+def _ago(ts: Any) -> str:
+    """Format an epoch timestamp as a compact relative age (e.g. '2m ago')."""
+    import time
+
+    try:
+        value = float(ts or 0)
+    except (TypeError, ValueError):
+        return ""
+    if value <= 0:
+        return "never"
+    delta = max(0, int(time.time() - value))
+    if delta < 60:
+        return f"{delta}s ago"
+    if delta < 3600:
+        return f"{delta // 60}m ago"
+    if delta < 86400:
+        return f"{delta // 3600}h ago"
+    return f"{delta // 86400}d ago"
+
+
+def _board_page_url() -> str:
+    """Best-effort token-scoped URL of the running board page, or '' when none.
+
+    The client owns the dashboard server, so the status renderer resolves the
+    live URL here (from discovery state) for users to copy; any failure or a
+    not-running server yields an empty string rather than raising.
+    """
+    try:
+        from leapflow.config import get_settings
+        from leapflow.dashboard import launcher
+
+        state = launcher.server_running(get_settings())
+        if not state:
+            return ""
+        return launcher.build_view_url(state["bind"], state["port"], state["token"])
+    except Exception:
+        logger.debug("dashboard: board page url lookup failed", exc_info=True)
+        return ""
+
+
+def _render_dashboard_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    from rich.table import Table
+
+    mode = str(payload.get("mode") or "")
+
+    if mode == "open":
+        # In the REPLs the browser is launched separately; this is a defensive
+        # text fallback for non-interactive callers.
+        url = payload.get("url")
+        if url:
+            console.system(f"Opening board: {url}")
+        elif payload.get("running"):
+            console.system("Dashboard is running.")
+        else:
+            console.system(str(payload.get("hint") or "Run `leap board` to open the web view."))
+        return
+
+    if mode == "control":
+        console.success(str(payload.get("message") or payload.get("action") or "done"))
+        return
+
+    if mode == "status":
+        templates = payload.get("templates") or []
+        console.system(
+            f"Templates: {', '.join(templates) or '-'} (default: {payload.get('default', 'generic')})"
+        )
+        watches = payload.get("watches") or []
+        if watches:
+            board_url = _board_page_url()
+            table = Table(title="Watches", title_style="bold cyan", border_style="bright_black")
+            for col in ("id", "name", "domain", "state", "runs", "findings", "last run"):
+                table.add_column(col)
+            # Full token URL of the board page, kept whole (folded, never cropped)
+            # so users can copy it straight from the table.
+            table.add_column("url", overflow="fold")
+            for w in watches:
+                table.add_row(
+                    str(w.get("watch_id", ""))[:8],
+                    str(w.get("name", "")),
+                    str(w.get("domain", "")),
+                    str(w.get("state", "")),
+                    str(w.get("run_count", 0)),
+                    str(w.get("finding_count", 0)),
+                    _ago(w.get("last_run_at", 0)),
+                    board_url,
+                )
+            console.print(table)
+        else:
+            console.system("Watches: none active — run /board to start session analysis.")
+        findings = payload.get("findings") or []
+        if findings:
+            console.system(f"Recent findings ({len(findings)}):")
+            markers = {"alert": "!!", "notable": " *", "info": " -"}
+            for f in findings[:20]:
+                sev = str(f.get("severity", "info"))
+                line = f"  {markers.get(sev, ' -')} [{sev}] {str(f.get('title', ''))}"
+                summary = str(f.get("summary", ""))
+                if summary:
+                    line += f" \u2014 {summary}"
+                age = _ago(f.get("ts", 0))
+                if age:
+                    line += f"  ({age})"
+                console.system(line)
+        else:
+            console.system("Findings: none yet.")
+        return
+
+    if mode == "templates":
+        action = str(payload.get("action") or "list")
+        if action == "list":
+            items = payload.get("templates") or []
+            if not items:
+                console.system("No templates available.")
+                return
+            table = Table(title="Templates", title_style="bold cyan", border_style="bright_black")
+            for col in ("name", "source", "title"):
+                table.add_column(col)
+            for item in items:
+                table.add_row(
+                    str(item.get("name", "")),
+                    str(item.get("source", "")),
+                    str(item.get("title", "")),
+                )
+            console.print(table)
+            return
+        if action == "show":
+            detail = payload.get("detail") or {}
+            console.system(
+                f"{detail.get('name')} [{detail.get('source')}] — {detail.get('title')}"
+            )
+            if detail.get("description"):
+                console.system(str(detail["description"]))
+            return
+        # add / remove success
+        console.success(str(payload.get("message") or "done"))
+        return
+
+    message = payload.get("message")
+    if message:
+        console.system(str(message))
+
+
+def _render_status_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    from rich.panel import Panel
+    from rich.text import Text
+
+    info = Text()
+    info.append("Model:     ", style="dim")
+    info.append(f"{payload.get('model')}\n", style="bold")
+
+    ctx_len = int(payload.get("context_length") or 0)
+    ctx_used = int(payload.get("context_used") or 0)
+    turn_count = int(payload.get("turn_count") or 0)
+    if ctx_len:
+        pct = int(ctx_used * 100 / ctx_len) if ctx_len else 0
+        info.append("Context:   ", style="dim")
+        pct_style = "bold red" if pct >= 90 else ("yellow" if pct >= 75 else "")
+        info.append(f"{ctx_used:,} / {ctx_len:,} ({pct}%)\n", style=pct_style)
+    info.append("Turns:     ", style="dim")
+    info.append(f"{turn_count}\n")
+    info.append("Platform:  ", style="dim")
+    p_status = str(payload.get("platform") or "")
+    p_style = "green" if p_status == "connected" else "dim"
+    info.append(f"{p_status}\n", style=p_style)
+    info.append("CWD:       ", style="dim")
+    info.append(f"{payload.get('cwd')}\n")
+    info.append("Config:    ", style="dim")
+    info.append(f"{payload.get('config_path')}\n")
+    session_id = payload.get("session_id")
+    if session_id:
+        info.append("Session:   ", style="dim")
+        info.append(f"{session_id}\n")
+    info.append("Mode:      ", style="dim")
+    info.append(f"{payload.get('mode')}\n")
+    gw = payload.get("gateway_connected") or []
+    if gw:
+        info.append("Gateway:   ", style="dim")
+        info.append(f"{', '.join(gw)}\n", style="green")
+
+    console.print(Panel(info, title="[bold cyan]LeapFlow Status[/]", border_style="bright_black", padding=(0, 2)))
+
+
+def _render_gateway_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    from rich.panel import Panel
+    from rich.text import Text
+
+    info = Text()
+    connected = payload.get("connected") or []
+    configured = payload.get("configured") or []
+    available = payload.get("available") or []
+
+    if connected:
+        info.append("Connected\n", style="bold green")
+        for entry in connected:
+            uptime = f" ({entry['uptime']})" if entry.get("uptime") else ""
+            info.append(f"  ● {entry['name']}{uptime}\n", style="green")
+    if configured:
+        info.append("Configured (not connected)\n", style="bold yellow")
+        for entry in configured:
+            info.append(f"  ○ {entry['name']}\n", style="yellow")
+    if available:
+        info.append("Available\n", style="bold dim")
+        names = [entry["name"] for entry in available]
+        info.append(f"  {', '.join(names)}\n", style="dim")
+    info.append("\n", style="dim")
+    info.append('Say "connect to <platform>" to set up a new integration.', style="dim italic")
+    console.print(Panel(info, title="[bold cyan]Gateway[/]", border_style="bright_black", padding=(0, 2)))
+
+
+def _render_host_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    result = payload.get("result") or {}
+    action = payload.get("action") or "status"
+    if action != "status":
+        console.success(f"Host {action} completed.")
+    lines = []
+    for key in ("status", "backend", "pid", "session_id"):
+        if key in result:
+            lines.append(f"  {key}: {result[key]}")
+    if lines:
+        console.system("\n".join(lines))
+
+
+def _render_skill_list_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    from rich.table import Table
+
+    skills = payload.get("skills") or []
+    if not skills:
+        console.system("No skills registered.")
+        return
+    table = Table(show_header=True, header_style="bold", border_style="dim")
+    table.add_column("Name", style="cyan", max_width=30)
+    table.add_column("Version", justify="center")
+    table.add_column("Confidence", justify="center")
+    table.add_column("Description", max_width=40)
+    for s in skills:
+        table.add_row(
+            str(s.get("name") or ""),
+            f"v{s.get('version', 0)}",
+            f"{float(s.get('confidence') or 0):.0%}",
+            str(s.get("description") or "")[:40],
+        )
+    console.print(table)
+
+
+def _render_skill_show_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    from rich.panel import Panel
+    from rich.text import Text
+
+    info = Text()
+    info.append(f"Name:        {payload.get('name')}\n")
+    info.append(f"Description: {payload.get('description')}\n")
+    info.append(f"Version:     v{payload.get('version', 0)}\n")
+    info.append(f"Confidence:  {float(payload.get('confidence') or 0):.0%}\n")
+    triggers = payload.get("triggers") or []
+    if triggers:
+        info.append(f"Triggers:    {', '.join(triggers)}")
+    console.print(Panel(info, title=str(payload.get("name") or "Skill"), border_style="cyan"))
+
+
+def _render_task_view(console: "LeapConsole", payload: dict[str, Any]) -> None:
+    tasks = payload.get("tasks") or []
+    msg = payload.get("message")
+    if msg:
+        console.system(str(msg))
+        return
+    if not tasks:
+        console.system("No scheduled tasks.")
+        return
+    from rich.table import Table
+    table = Table(show_header=True, header_style="bold", border_style="dim")
+    table.add_column("Name", style="cyan")
+    table.add_column("Schedule")
+    table.add_column("Next Run")
+    for t in tasks:
+        table.add_row(str(t.get("name") or ""), str(t.get("schedule") or ""), str(t.get("next_run") or ""))
+    console.print(table)
diff --git a/src/leapflow/dashboard/intent.py b/src/leapflow/dashboard/intent.py
index 44a13a0..11fa12f 100644
--- a/src/leapflow/dashboard/intent.py
+++ b/src/leapflow/dashboard/intent.py
@@ -1,43 +1,43 @@
-"""DashboardIntent: the single normalized request behind ``/board`` and the tool.
-
-LeapBoard always analyzes the *current session*; the only view dimension is the
-**template** (a rendering lens). Control verbs
-(``templates``/``refresh``/``pause``/``resume``/``stop``/``status``) are handled
-at the command layer, so the intent that reaches the view builder is simply a
-template name — empty means the default (``generic``).
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any, Mapping
-
-from leapflow.utils.shell_lex import split_args
-
-
-@dataclass(frozen=True)
-class DashboardIntent:
-    """A normalized dashboard request: which template to render the session with."""
-
-    template: str = ""
-
-    def to_dict(self) -> dict[str, Any]:
-        return {"template": self.template}
-
-    @classmethod
-    def from_params(cls, data: Mapping[str, Any]) -> "DashboardIntent":
-        """Build an intent from structured params (e.g. web ``?template=``)."""
-        data = data if isinstance(data, Mapping) else {}
-        return cls(template=str(data.get("template", "") or "").strip())
-
-    @classmethod
-    def from_args(cls, args: str) -> "DashboardIntent":
-        """Parse a slash argument string; the first token is the template name."""
-        try:
-            tokens = split_args(args or "")
-        except ValueError:
-            tokens = (args or "").split()
-        return cls(template=tokens[0].strip() if tokens else "")
-
-
-__all__ = ["DashboardIntent"]
+"""DashboardIntent: the single normalized request behind ``/board`` and the tool.
+
+LeapBoard always analyzes the *current session*; the only view dimension is the
+**template** (a rendering lens). Control verbs
+(``templates``/``refresh``/``pause``/``resume``/``stop``/``status``) are handled
+at the command layer, so the intent that reaches the view builder is simply a
+template name — empty means the default (``generic``).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Mapping
+
+from leapflow.utils.shell_lex import split_args
+
+
+@dataclass(frozen=True)
+class DashboardIntent:
+    """A normalized dashboard request: which template to render the session with."""
+
+    template: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"template": self.template}
+
+    @classmethod
+    def from_params(cls, data: Mapping[str, Any]) -> "DashboardIntent":
+        """Build an intent from structured params (e.g. web ``?template=``)."""
+        data = data if isinstance(data, Mapping) else {}
+        return cls(template=str(data.get("template", "") or "").strip())
+
+    @classmethod
+    def from_args(cls, args: str) -> "DashboardIntent":
+        """Parse a slash argument string; the first token is the template name."""
+        try:
+            tokens = split_args(args or "")
+        except ValueError:
+            tokens = (args or "").split()
+        return cls(template=tokens[0].strip() if tokens else "")
+
+
+__all__ = ["DashboardIntent"]
diff --git a/tests/test_code_tools.py b/tests/test_code_tools.py
index 3661a4b..6b753a6 100644
--- a/tests/test_code_tools.py
+++ b/tests/test_code_tools.py
@@ -1,487 +1,487 @@
-"""Tests for the P0 coding built-in tools: code_search, file_find, edit_file.
-
-Handlers are pure async functions (params dict -> result dict); exercised
-directly. Governance (read-only vs mutating classification) is verified against
-the tool registry so a failed read-only search never trips the batch-stop gate.
-"""
-from __future__ import annotations
-
-import asyncio
-from pathlib import PurePath
-
-from leapflow.tools import file_operations as fo
-from leapflow.tools.file_operations import code_search, edit_file, file_find, file_write
-from leapflow.tools.code_intel import code_intel
-
-
-def _run(coro):
-    return asyncio.run(coro)
-
-
-# ── code_search ──────────────────────────────────────────────────────
-
-def test_code_search_finds_matches_with_location(tmp_path) -> None:
-    (tmp_path / "a.py").write_text("import os\nprint('hello world')\nx = 1\n")
-    (tmp_path / "b.py").write_text("def hello():\n    return 'world'\n")
-
-    result = _run(code_search({"pattern": r"hello", "path": str(tmp_path)}))
-
-    assert result["ok"] is True
-    assert result["match_count"] >= 2
-    hits = {(PurePath(m["path"]).name, m["line"]) for m in result["matches"]}
-    assert ("a.py", 2) in hits and ("b.py", 1) in hits
-    assert all("text" in m and m["line"] for m in result["matches"])
-
-
-def test_code_search_glob_filter(tmp_path) -> None:
-    (tmp_path / "a.py").write_text("needle\n")
-    (tmp_path / "a.txt").write_text("needle\n")
-
-    result = _run(code_search({"pattern": "needle", "path": str(tmp_path), "glob": "*.py"}))
-
-    assert result["ok"] is True
-    assert result["match_count"] == 1
-    assert result["matches"][0]["path"].endswith("a.py")
-
-
-def test_code_search_skips_vcs_and_dep_dirs(tmp_path) -> None:
-    (tmp_path / "src.py").write_text("token = 1\n")
-    for skip in (".git", "node_modules", "__pycache__"):
-        d = tmp_path / skip
-        d.mkdir()
-        (d / "junk.py").write_text("token = 2\n")
-
-    result = _run(code_search({"pattern": "token", "path": str(tmp_path)}))
-
-    assert result["ok"] is True
-    assert result["match_count"] == 1              # only src.py, dep/vcs dirs skipped
-    assert result["matches"][0]["path"].endswith("src.py")
-
-
-def test_code_search_no_match_is_ok_empty(tmp_path) -> None:
-    (tmp_path / "a.py").write_text("nothing here\n")
-    result = _run(code_search({"pattern": "zzz-not-present", "path": str(tmp_path)}))
-    assert result["ok"] is True and result["match_count"] == 0
-
-
-def test_code_search_invalid_regex_is_structured_error(tmp_path) -> None:
-    # Force the Python backend so an invalid pattern surfaces as re.error uniformly.
-    import leapflow.tools.file_operations as mod
-    orig = mod.shutil.which
-    mod.shutil.which = lambda _name: None
-    try:
-        result = _run(code_search({"pattern": "([unclosed", "path": str(tmp_path)}))
-    finally:
-        mod.shutil.which = orig
-    assert result["ok"] is False and result.get("error_type") == "invalid_regex"
-
-
-def test_code_search_python_backend_matches(tmp_path, monkeypatch) -> None:
-    monkeypatch.setattr(fo.shutil, "which", lambda _name: None)  # force fallback
-    (tmp_path / "a.py").write_text("alpha\nbeta needle gamma\n")
-    result = _run(code_search({"pattern": "needle", "path": str(tmp_path)}))
-    assert result["ok"] is True and result["backend"] == "python"
-    assert result["match_count"] == 1 and result["matches"][0]["line"] == 2
-
-
-def test_code_search_multiple_patterns_or_combined_single_pass(tmp_path, monkeypatch) -> None:
-    """P1-B2: batched patterns run as ONE search (one potential process spawn)."""
-    monkeypatch.setattr(fo.shutil, "which", lambda _name: None)  # force fallback
-    (tmp_path / "a.py").write_text("alpha_token\n")
-    (tmp_path / "b.py").write_text("beta_token\n")
-    (tmp_path / "c.py").write_text("unrelated\n")
-
-    result = _run(code_search({
-        "pattern": "alpha_token",
-        "patterns": ["beta_token"],
-        "path": str(tmp_path),
-    }))
-
-    assert result["ok"] is True
-    assert result["match_count"] == 2
-    hit_paths = {m["path"] for m in result["matches"]}
-    assert any(p.endswith("a.py") for p in hit_paths)
-    assert any(p.endswith("b.py") for p in hit_paths)
-
-
-def test_code_search_patterns_only_without_primary_pattern(tmp_path, monkeypatch) -> None:
-    monkeypatch.setattr(fo.shutil, "which", lambda _name: None)
-    (tmp_path / "a.py").write_text("needle\n")
-    result = _run(code_search({"patterns": ["needle"], "path": str(tmp_path)}))
-    assert result["ok"] is True and result["match_count"] == 1
-
-
-# ── ripgrep provisioning persistence (P0-B1) ───────────────────────
-
-
-def test_ripgrep_provision_marker_blocks_reinstall_across_restarts(tmp_path, monkeypatch) -> None:
-    """A failed install attempt persisted on disk must stop later daemon starts
-    from re-spawning the installer's process storm."""
-    marker = tmp_path / "cache" / "ripgrep_provision.json"
-    monkeypatch.setattr(fo.shutil, "which", lambda _name: "/usr/local/bin/brew" if _name == "brew" else None)
-    monkeypatch.setattr(fo.sys, "platform", "darwin")
-
-    install_calls: list[list[str]] = []
-
-    def fake_run(args, **kwargs):
-        install_calls.append(list(args))
-        class _R:  # noqa: N801 - minimal stub
-            returncode = 1
-        return _R()
-
-    monkeypatch.setattr(fo.subprocess, "run", fake_run)
-
-    # First process lifetime: attempts the install once and persists the marker.
-    monkeypatch.setitem(fo._RG_PROVISION, "done", False)
-    monkeypatch.setitem(fo._RG_PROVISION, "available", False)
-    assert fo.ensure_ripgrep_available(autoinstall=True, marker_path=marker) is False
-    assert len(install_calls) == 1
-    assert marker.exists()
-
-    # Simulated restart (fresh in-process cache): marker must block a re-attempt.
-    monkeypatch.setitem(fo._RG_PROVISION, "done", False)
-    monkeypatch.setitem(fo._RG_PROVISION, "available", False)
-    assert fo.ensure_ripgrep_available(autoinstall=True, marker_path=marker) is False
-    assert len(install_calls) == 1  # no second installer spawn
-
-
-def test_ripgrep_provision_marker_ignored_when_rg_present(tmp_path, monkeypatch) -> None:
-    marker = tmp_path / "ripgrep_provision.json"
-    marker.write_text('{"attempted": true, "available": false}')
-    monkeypatch.setattr(fo.shutil, "which", lambda _name: "/opt/homebrew/bin/rg" if _name == "rg" else None)
-    monkeypatch.setitem(fo._RG_PROVISION, "done", False)
-    monkeypatch.setitem(fo._RG_PROVISION, "available", False)
-
-    assert fo.ensure_ripgrep_available(autoinstall=True, marker_path=marker) is True
-
-
-# ── file_find ────────────────────────────────────────────────────────
-
-def test_file_find_recursive_glob(tmp_path) -> None:
-    (tmp_path / "pkg").mkdir()
-    (tmp_path / "pkg" / "mod.py").write_text("x\n")
-    (tmp_path / "top.py").write_text("y\n")
-    (tmp_path / "note.md").write_text("z\n")
-
-    result = _run(file_find({"glob": "*.py", "path": str(tmp_path)}))
-
-    assert result["ok"] is True
-    found = {PurePath(p).name for p in result["files"]}
-    assert found == {"mod.py", "top.py"}
-
-
-def test_file_find_skips_dep_dirs(tmp_path) -> None:
-    (tmp_path / "keep.py").write_text("x\n")
-    (tmp_path / ".venv").mkdir()
-    (tmp_path / ".venv" / "lib.py").write_text("x\n")
-
-    result = _run(file_find({"glob": "*.py", "path": str(tmp_path)}))
-
-    assert [PurePath(p).name for p in result["files"]] == ["keep.py"]
-
-
-def test_file_find_truncates_at_max_results(tmp_path) -> None:
-    for i in range(10):
-        (tmp_path / f"f{i}.py").write_text("x\n")
-    result = _run(file_find({"glob": "*.py", "path": str(tmp_path), "max_results": 3}))
-    assert result["ok"] is True and result["file_count"] == 3 and result["truncated"] is True
-
-
-def test_file_find_missing_glob_errors(tmp_path) -> None:
-    result = _run(file_find({"path": str(tmp_path)}))
-    assert result["ok"] is False
-
-
-# ── edit_file ────────────────────────────────────────────────────────
-
-def test_edit_file_unique_anchor_replaces(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("a = 1\nb = 2\nc = 3\n")
-
-    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "b = 2", "new_text": "b = 20"}]}))
-
-    assert result["ok"] is True and result["changed"] is True and result["replacements"] == 1
-    assert f.read_text() == "a = 1\nb = 20\nc = 3\n"
-
-
-def test_edit_file_non_unique_anchor_is_rejected(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("x = 1\nx = 1\n")
-
-    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "x = 1", "new_text": "x = 2"}]}))
-
-    assert result["ok"] is False and result["error_type"] == "anchor_not_unique"
-    assert result["match_count"] == 2
-    assert f.read_text() == "x = 1\nx = 1\n"        # unchanged — no silent corruption
-
-
-def test_edit_file_replace_all(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("x = 1\nx = 1\n")
-    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "x = 1", "new_text": "x = 9", "replace_all": True}]}))
-    assert result["ok"] is True and result["replacements"] == 2
-    assert f.read_text() == "x = 9\nx = 9\n"
-
-
-def test_edit_file_anchor_not_found(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("hello\n")
-    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "nope", "new_text": "x"}]}))
-    assert result["ok"] is False and result["error_type"] == "anchor_not_found"
-    assert f.read_text() == "hello\n"
-
-
-def test_edit_file_dry_run_does_not_write(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("a = 1\n")
-    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "a = 1", "new_text": "a = 2"}], "dry_run": True}))
-    assert result["ok"] is True and result.get("dry_run") is True and result["changed"] is True
-    assert f.read_text() == "a = 1\n"               # not written
-
-
-def test_edit_file_sequential_multi_edits(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("one\ntwo\nthree\n")
-    result = _run(edit_file({"path": str(f), "edits": [
-        {"original_text": "one", "new_text": "1"},
-        {"original_text": "three", "new_text": "3"},
-    ]}))
-    assert result["ok"] is True and result["edits_applied"] == 2
-    assert f.read_text() == "1\ntwo\n3\n"
-
-
-def test_edit_file_missing_file_errors(tmp_path) -> None:
-    result = _run(edit_file({"path": str(tmp_path / "nope.py"), "edits": [{"original_text": "a", "new_text": "b"}]}))
-    assert result["ok"] is False and result["error_type"] == "file_not_found"
-
-
-def test_edit_file_single_edit_shorthand(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("k = 1\n")
-    result = _run(edit_file({"path": str(f), "original_text": "k = 1", "new_text": "k = 2"}))
-    assert result["ok"] is True and f.read_text() == "k = 2\n"
-
-
-# ── governance: registry classification ──────────────────────────────
-
-def test_new_tools_execution_policy_classification() -> None:
-    from leapflow.tools.registry_bootstrap import TOOL_DEFINITIONS, TOOL_HANDLERS, _BRIDGE_TOOLS
-    from leapflow.tools.name_resolver import ToolRegistry, TOOL_NAME_ALIASES
-    from leapflow.engine.tool_execution import execution_policy_for
-
-    reg = ToolRegistry.from_definitions(
-        TOOL_DEFINITIONS, TOOL_HANDLERS, bridge_tools=_BRIDGE_TOOLS, aliases=TOOL_NAME_ALIASES,
-    )
-    # Read-only search/find must NOT be side-effecting (else a failed search would
-    # trip the batch-stop gate); edit_file mutates like file_write.
-    assert execution_policy_for("code_search", reg.specs.get("code_search")) == "read_only"
-    assert execution_policy_for("file_find", reg.specs.get("file_find")) == "read_only"
-    assert execution_policy_for("edit_file", reg.specs.get("edit_file")) == "mutating_idempotent"
-
-
-# ── ripgrep provisioning: seamless fallback + best-effort auto-install ──
-
-def _reset_rg_cache() -> None:
-    fo._RG_PROVISION.update(done=False, available=False)
-
-
-def test_code_search_install_hint_when_ripgrep_missing(tmp_path, monkeypatch) -> None:
-    """With ripgrep absent, code_search still works (Python) and surfaces a
-    manual-install hint — the seamless fallback + fallback-to-manual path."""
-    monkeypatch.setattr(fo, "ripgrep_path", lambda: None)
-    (tmp_path / "a.py").write_text("needle here\n")
-    result = _run(code_search({"pattern": "needle", "path": str(tmp_path)}))
-    assert result["ok"] is True and result["backend"] == "python"
-    assert result["match_count"] == 1
-    assert "install_hint" in result and "ripgrep" in result["install_hint"]
-
-
-def test_ensure_ripgrep_present_does_not_install(monkeypatch) -> None:
-    _reset_rg_cache()
-    monkeypatch.setattr(fo, "ripgrep_path", lambda: "/usr/bin/rg")
-
-    def _no_install(*_a, **_k):
-        raise AssertionError("must not install when ripgrep is already present")
-
-    monkeypatch.setattr(fo.subprocess, "run", _no_install)
-    assert fo.ensure_ripgrep_available(autoinstall=True) is True
-
-
-def test_ensure_ripgrep_autoinstall_disabled_no_install(monkeypatch) -> None:
-    _reset_rg_cache()
-    monkeypatch.setattr(fo, "ripgrep_path", lambda: None)
-
-    def _no_install(*_a, **_k):
-        raise AssertionError("must not install when autoinstall disabled")
-
-    monkeypatch.setattr(fo.subprocess, "run", _no_install)
-    assert fo.ensure_ripgrep_available(autoinstall=False) is False
-
-
-def test_ensure_ripgrep_non_darwin_skips_install(monkeypatch) -> None:
-    _reset_rg_cache()
-    monkeypatch.setattr(fo, "ripgrep_path", lambda: None)
-    monkeypatch.setattr(fo.sys, "platform", "linux")
-
-    def _no_install(*_a, **_k):
-        raise AssertionError("no no-sudo installer on non-macOS -> Python fallback")
-
-    monkeypatch.setattr(fo.subprocess, "run", _no_install)
-    assert fo.ensure_ripgrep_available(autoinstall=True) is False
-
-
-def test_ensure_ripgrep_darwin_brew_install_succeeds(monkeypatch) -> None:
-    _reset_rg_cache()
-    monkeypatch.setattr(fo.sys, "platform", "darwin")
-    monkeypatch.setattr(fo.shutil, "which", lambda name: "/opt/homebrew/bin/brew" if name == "brew" else None)
-    # ripgrep missing before the install, present after it.
-    states = iter([None, "/opt/homebrew/bin/rg"])
-    monkeypatch.setattr(fo, "ripgrep_path", lambda: next(states))
-    captured: dict = {}
-
-    def _run_install(cmd, **_k):
-        captured["cmd"] = cmd
-        return None
-
-    monkeypatch.setattr(fo.subprocess, "run", _run_install)
-    assert fo.ensure_ripgrep_available(autoinstall=True) is True
-    assert captured["cmd"][:2] == ["brew", "install"]
-
-
-def test_ensure_ripgrep_is_cached(monkeypatch) -> None:
-    _reset_rg_cache()
-    fo._RG_PROVISION.update(done=True, available=True)
-
-    def _no_install(*_a, **_k):
-        raise AssertionError("cached result must not re-attempt install")
-
-    monkeypatch.setattr(fo.subprocess, "run", _no_install)
-    assert fo.ensure_ripgrep_available(autoinstall=True) is True
-    _reset_rg_cache()
-
-
-def test_ripgrep_install_hint_macos(monkeypatch) -> None:
-    monkeypatch.setattr(fo.sys, "platform", "darwin")
-    assert fo.ripgrep_install_hint() == "brew install ripgrep"
-
-
-# ── code_intel: precise document symbols (ast for Python, heuristic otherwise) ──
-
-def test_code_intel_python_ast_symbols(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text(
-        "import os\n"
-        "\n"
-        "class Foo:\n"
-        "    def method_a(self):\n"
-        "        return 1\n"
-        "\n"
-        "def top_level(x, y):\n"
-        "    return x + y\n"
-    )
-    result = _run(code_intel({"path": str(f)}))
-    assert result["ok"] is True and result["engine"] == "ast" and result["language"] == "py"
-    by_name = {s["name"]: s for s in result["symbols"]}
-    assert by_name["Foo"]["kind"] == "class" and by_name["Foo"]["line"] == 3
-    assert by_name["method_a"]["kind"] == "method" and by_name["method_a"]["parent"] == "Foo"
-    assert by_name["top_level"]["kind"] == "function" and by_name["top_level"]["line"] == 7
-    assert "def top_level(x, y):" in by_name["top_level"]["signature"]
-
-
-def test_code_intel_non_python_heuristic(tmp_path) -> None:
-    f = tmp_path / "m.js"
-    f.write_text("function foo() {\n  return 1;\n}\nconst bar = 2;\n")
-    result = _run(code_intel({"path": str(f)}))
-    assert result["ok"] is True and result["engine"] == "heuristic"
-    assert 1 in {s["line"] for s in result["symbols"]}   # 'function foo' line
-
-
-def test_code_intel_invalid_python_falls_back(tmp_path) -> None:
-    f = tmp_path / "bad.py"
-    f.write_text("def broken(:\n    pass\n")  # syntax error -> heuristic fallback, not failure
-    result = _run(code_intel({"path": str(f)}))
-    assert result["ok"] is True and result["engine"] == "heuristic-fallback"
-
-
-def test_code_intel_missing_path() -> None:
-    assert _run(code_intel({}))["ok"] is False
-
-
-def test_code_intel_file_not_found(tmp_path) -> None:
-    assert _run(code_intel({"path": str(tmp_path / "nope.py")}))["ok"] is False
-
-
-def test_code_intel_unsupported_operation(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("x = 1\n")
-    assert _run(code_intel({"path": str(f), "operation": "definition"}))["ok"] is False
-
-
-# ── polish: code_search context_lines + edit_file unified-diff mode ──
-
-def test_code_search_context_lines(tmp_path, monkeypatch) -> None:
-    monkeypatch.setattr(fo, "ripgrep_path", lambda: None)  # deterministic Python backend
-    (tmp_path / "a.py").write_text("line1\nline2\nNEEDLE\nline4\nline5\n")
-    result = _run(code_search({"pattern": "NEEDLE", "path": str(tmp_path), "context_lines": 2}))
-    assert result["ok"] is True and result["match_count"] == 1
-    match = result["matches"][0]
-    assert match["context_before"] == ["line1", "line2"]
-    assert match["context_after"] == ["line4", "line5"]
-
-
-def test_edit_file_apply_unified_diff(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("alpha\nbeta\ngamma\n")
-    diff = "--- a/m.py\n+++ b/m.py\n@@ -1,3 +1,3 @@\n alpha\n-beta\n+BETA\n gamma\n"
-    result = _run(edit_file({"path": str(f), "diff": diff}))
-    assert result["ok"] is True and result["changed"] is True
-    assert f.read_text() == "alpha\nBETA\ngamma\n"
-
-
-def test_edit_file_invalid_diff_is_rejected(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("x\n")
-    result = _run(edit_file({"path": str(f), "diff": "not a diff, no hunks"}))
-    assert result["ok"] is False and result["error_type"] == "invalid_diff"
-    assert f.read_text() == "x\n"
-
-
-# ── B1: advisory post-edit syntax verification ──
-
-def test_edit_file_flags_broken_python_syntax(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("x = 1\n")
-    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "x = 1", "new_text": "def broken(:"}]}))
-    assert result["ok"] is True and result["changed"] is True  # write is not blocked
-    assert result["syntax_ok"] is False and "syntax_error" in result
-
-
-def test_edit_file_valid_python_syntax_ok(tmp_path) -> None:
-    f = tmp_path / "m.py"
-    f.write_text("x = 1\n")
-    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "x = 1", "new_text": "x = 2"}]}))
-    assert result["ok"] is True and result["syntax_ok"] is True
-
-
-def test_edit_file_non_python_has_no_syntax_field(tmp_path) -> None:
-    f = tmp_path / "m.txt"
-    f.write_text("hello\n")
-    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "hello", "new_text": "world"}]}))
-    assert result["ok"] is True and "syntax_ok" not in result
-
-
-def test_file_write_python_syntax_ok(tmp_path) -> None:
-    f = tmp_path / "n.py"
-    result = _run(file_write({"path": str(f), "content": "def ok():\n    return 1\n"}))
-    assert result["ok"] is True and result["syntax_ok"] is True
-
-
-def test_verify_edits_toggle_off(tmp_path) -> None:
-    fo.set_edit_verification(False)
-    try:
-        f = tmp_path / "m.py"
-        f.write_text("x = 1\n")
-        result = _run(edit_file({"path": str(f), "edits": [{"original_text": "x = 1", "new_text": "def broken(:"}]}))
-        assert result["ok"] is True and "syntax_ok" not in result
-    finally:
-        fo.set_edit_verification(True)
+"""Tests for the P0 coding built-in tools: code_search, file_find, edit_file.
+
+Handlers are pure async functions (params dict -> result dict); exercised
+directly. Governance (read-only vs mutating classification) is verified against
+the tool registry so a failed read-only search never trips the batch-stop gate.
+"""
+from __future__ import annotations
+
+import asyncio
+from pathlib import PurePath
+
+from leapflow.tools import file_operations as fo
+from leapflow.tools.file_operations import code_search, edit_file, file_find, file_write
+from leapflow.tools.code_intel import code_intel
+
+
+def _run(coro):
+    return asyncio.run(coro)
+
+
+# ── code_search ──────────────────────────────────────────────────────
+
+def test_code_search_finds_matches_with_location(tmp_path) -> None:
+    (tmp_path / "a.py").write_text("import os\nprint('hello world')\nx = 1\n")
+    (tmp_path / "b.py").write_text("def hello():\n    return 'world'\n")
+
+    result = _run(code_search({"pattern": r"hello", "path": str(tmp_path)}))
+
+    assert result["ok"] is True
+    assert result["match_count"] >= 2
+    hits = {(PurePath(m["path"]).name, m["line"]) for m in result["matches"]}
+    assert ("a.py", 2) in hits and ("b.py", 1) in hits
+    assert all("text" in m and m["line"] for m in result["matches"])
+
+
+def test_code_search_glob_filter(tmp_path) -> None:
+    (tmp_path / "a.py").write_text("needle\n")
+    (tmp_path / "a.txt").write_text("needle\n")
+
+    result = _run(code_search({"pattern": "needle", "path": str(tmp_path), "glob": "*.py"}))
+
+    assert result["ok"] is True
+    assert result["match_count"] == 1
+    assert result["matches"][0]["path"].endswith("a.py")
+
+
+def test_code_search_skips_vcs_and_dep_dirs(tmp_path) -> None:
+    (tmp_path / "src.py").write_text("token = 1\n")
+    for skip in (".git", "node_modules", "__pycache__"):
+        d = tmp_path / skip
+        d.mkdir()
+        (d / "junk.py").write_text("token = 2\n")
+
+    result = _run(code_search({"pattern": "token", "path": str(tmp_path)}))
+
+    assert result["ok"] is True
+    assert result["match_count"] == 1              # only src.py, dep/vcs dirs skipped
+    assert result["matches"][0]["path"].endswith("src.py")
+
+
+def test_code_search_no_match_is_ok_empty(tmp_path) -> None:
+    (tmp_path / "a.py").write_text("nothing here\n")
+    result = _run(code_search({"pattern": "zzz-not-present", "path": str(tmp_path)}))
+    assert result["ok"] is True and result["match_count"] == 0
+
+
+def test_code_search_invalid_regex_is_structured_error(tmp_path) -> None:
+    # Force the Python backend so an invalid pattern surfaces as re.error uniformly.
+    import leapflow.tools.file_operations as mod
+    orig = mod.shutil.which
+    mod.shutil.which = lambda _name: None
+    try:
+        result = _run(code_search({"pattern": "([unclosed", "path": str(tmp_path)}))
+    finally:
+        mod.shutil.which = orig
+    assert result["ok"] is False and result.get("error_type") == "invalid_regex"
+
+
+def test_code_search_python_backend_matches(tmp_path, monkeypatch) -> None:
+    monkeypatch.setattr(fo.shutil, "which", lambda _name: None)  # force fallback
+    (tmp_path / "a.py").write_text("alpha\nbeta needle gamma\n")
+    result = _run(code_search({"pattern": "needle", "path": str(tmp_path)}))
+    assert result["ok"] is True and result["backend"] == "python"
+    assert result["match_count"] == 1 and result["matches"][0]["line"] == 2
+
+
+def test_code_search_multiple_patterns_or_combined_single_pass(tmp_path, monkeypatch) -> None:
+    """P1-B2: batched patterns run as ONE search (one potential process spawn)."""
+    monkeypatch.setattr(fo.shutil, "which", lambda _name: None)  # force fallback
+    (tmp_path / "a.py").write_text("alpha_token\n")
+    (tmp_path / "b.py").write_text("beta_token\n")
+    (tmp_path / "c.py").write_text("unrelated\n")
+
+    result = _run(code_search({
+        "pattern": "alpha_token",
+        "patterns": ["beta_token"],
+        "path": str(tmp_path),
+    }))
+
+    assert result["ok"] is True
+    assert result["match_count"] == 2
+    hit_paths = {m["path"] for m in result["matches"]}
+    assert any(p.endswith("a.py") for p in hit_paths)
+    assert any(p.endswith("b.py") for p in hit_paths)
+
+
+def test_code_search_patterns_only_without_primary_pattern(tmp_path, monkeypatch) -> None:
+    monkeypatch.setattr(fo.shutil, "which", lambda _name: None)
+    (tmp_path / "a.py").write_text("needle\n")
+    result = _run(code_search({"patterns": ["needle"], "path": str(tmp_path)}))
+    assert result["ok"] is True and result["match_count"] == 1
+
+
+# ── ripgrep provisioning persistence (P0-B1) ───────────────────────
+
+
+def test_ripgrep_provision_marker_blocks_reinstall_across_restarts(tmp_path, monkeypatch) -> None:
+    """A failed install attempt persisted on disk must stop later daemon starts
+    from re-spawning the installer's process storm."""
+    marker = tmp_path / "cache" / "ripgrep_provision.json"
+    monkeypatch.setattr(fo.shutil, "which", lambda _name: "/usr/local/bin/brew" if _name == "brew" else None)
+    monkeypatch.setattr(fo.sys, "platform", "darwin")
+
+    install_calls: list[list[str]] = []
+
+    def fake_run(args, **kwargs):
+        install_calls.append(list(args))
+        class _R:  # noqa: N801 - minimal stub
+            returncode = 1
+        return _R()
+
+    monkeypatch.setattr(fo.subprocess, "run", fake_run)
+
+    # First process lifetime: attempts the install once and persists the marker.
+    monkeypatch.setitem(fo._RG_PROVISION, "done", False)
+    monkeypatch.setitem(fo._RG_PROVISION, "available", False)
+    assert fo.ensure_ripgrep_available(autoinstall=True, marker_path=marker) is False
+    assert len(install_calls) == 1
+    assert marker.exists()
+
+    # Simulated restart (fresh in-process cache): marker must block a re-attempt.
+    monkeypatch.setitem(fo._RG_PROVISION, "done", False)
+    monkeypatch.setitem(fo._RG_PROVISION, "available", False)
+    assert fo.ensure_ripgrep_available(autoinstall=True, marker_path=marker) is False
+    assert len(install_calls) == 1  # no second installer spawn
+
+
+def test_ripgrep_provision_marker_ignored_when_rg_present(tmp_path, monkeypatch) -> None:
+    marker = tmp_path / "ripgrep_provision.json"
+    marker.write_text('{"attempted": true, "available": false}')
+    monkeypatch.setattr(fo.shutil, "which", lambda _name: "/opt/homebrew/bin/rg" if _name == "rg" else None)
+    monkeypatch.setitem(fo._RG_PROVISION, "done", False)
+    monkeypatch.setitem(fo._RG_PROVISION, "available", False)
+
+    assert fo.ensure_ripgrep_available(autoinstall=True, marker_path=marker) is True
+
+
+# ── file_find ────────────────────────────────────────────────────────
+
+def test_file_find_recursive_glob(tmp_path) -> None:
+    (tmp_path / "pkg").mkdir()
+    (tmp_path / "pkg" / "mod.py").write_text("x\n")
+    (tmp_path / "top.py").write_text("y\n")
+    (tmp_path / "note.md").write_text("z\n")
+
+    result = _run(file_find({"glob": "*.py", "path": str(tmp_path)}))
+
+    assert result["ok"] is True
+    found = {PurePath(p).name for p in result["files"]}
+    assert found == {"mod.py", "top.py"}
+
+
+def test_file_find_skips_dep_dirs(tmp_path) -> None:
+    (tmp_path / "keep.py").write_text("x\n")
+    (tmp_path / ".venv").mkdir()
+    (tmp_path / ".venv" / "lib.py").write_text("x\n")
+
+    result = _run(file_find({"glob": "*.py", "path": str(tmp_path)}))
+
+    assert [PurePath(p).name for p in result["files"]] == ["keep.py"]
+
+
+def test_file_find_truncates_at_max_results(tmp_path) -> None:
+    for i in range(10):
+        (tmp_path / f"f{i}.py").write_text("x\n")
+    result = _run(file_find({"glob": "*.py", "path": str(tmp_path), "max_results": 3}))
+    assert result["ok"] is True and result["file_count"] == 3 and result["truncated"] is True
+
+
+def test_file_find_missing_glob_errors(tmp_path) -> None:
+    result = _run(file_find({"path": str(tmp_path)}))
+    assert result["ok"] is False
+
+
+# ── edit_file ────────────────────────────────────────────────────────
+
+def test_edit_file_unique_anchor_replaces(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("a = 1\nb = 2\nc = 3\n")
+
+    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "b = 2", "new_text": "b = 20"}]}))
+
+    assert result["ok"] is True and result["changed"] is True and result["replacements"] == 1
+    assert f.read_text() == "a = 1\nb = 20\nc = 3\n"
+
+
+def test_edit_file_non_unique_anchor_is_rejected(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("x = 1\nx = 1\n")
+
+    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "x = 1", "new_text": "x = 2"}]}))
+
+    assert result["ok"] is False and result["error_type"] == "anchor_not_unique"
+    assert result["match_count"] == 2
+    assert f.read_text() == "x = 1\nx = 1\n"        # unchanged — no silent corruption
+
+
+def test_edit_file_replace_all(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("x = 1\nx = 1\n")
+    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "x = 1", "new_text": "x = 9", "replace_all": True}]}))
+    assert result["ok"] is True and result["replacements"] == 2
+    assert f.read_text() == "x = 9\nx = 9\n"
+
+
+def test_edit_file_anchor_not_found(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("hello\n")
+    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "nope", "new_text": "x"}]}))
+    assert result["ok"] is False and result["error_type"] == "anchor_not_found"
+    assert f.read_text() == "hello\n"
+
+
+def test_edit_file_dry_run_does_not_write(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("a = 1\n")
+    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "a = 1", "new_text": "a = 2"}], "dry_run": True}))
+    assert result["ok"] is True and result.get("dry_run") is True and result["changed"] is True
+    assert f.read_text() == "a = 1\n"               # not written
+
+
+def test_edit_file_sequential_multi_edits(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("one\ntwo\nthree\n")
+    result = _run(edit_file({"path": str(f), "edits": [
+        {"original_text": "one", "new_text": "1"},
+        {"original_text": "three", "new_text": "3"},
+    ]}))
+    assert result["ok"] is True and result["edits_applied"] == 2
+    assert f.read_text() == "1\ntwo\n3\n"
+
+
+def test_edit_file_missing_file_errors(tmp_path) -> None:
+    result = _run(edit_file({"path": str(tmp_path / "nope.py"), "edits": [{"original_text": "a", "new_text": "b"}]}))
+    assert result["ok"] is False and result["error_type"] == "file_not_found"
+
+
+def test_edit_file_single_edit_shorthand(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("k = 1\n")
+    result = _run(edit_file({"path": str(f), "original_text": "k = 1", "new_text": "k = 2"}))
+    assert result["ok"] is True and f.read_text() == "k = 2\n"
+
+
+# ── governance: registry classification ──────────────────────────────
+
+def test_new_tools_execution_policy_classification() -> None:
+    from leapflow.tools.registry_bootstrap import TOOL_DEFINITIONS, TOOL_HANDLERS, _BRIDGE_TOOLS
+    from leapflow.tools.name_resolver import ToolRegistry, TOOL_NAME_ALIASES
+    from leapflow.engine.tool_execution import execution_policy_for
+
+    reg = ToolRegistry.from_definitions(
+        TOOL_DEFINITIONS, TOOL_HANDLERS, bridge_tools=_BRIDGE_TOOLS, aliases=TOOL_NAME_ALIASES,
+    )
+    # Read-only search/find must NOT be side-effecting (else a failed search would
+    # trip the batch-stop gate); edit_file mutates like file_write.
+    assert execution_policy_for("code_search", reg.specs.get("code_search")) == "read_only"
+    assert execution_policy_for("file_find", reg.specs.get("file_find")) == "read_only"
+    assert execution_policy_for("edit_file", reg.specs.get("edit_file")) == "mutating_idempotent"
+
+
+# ── ripgrep provisioning: seamless fallback + best-effort auto-install ──
+
+def _reset_rg_cache() -> None:
+    fo._RG_PROVISION.update(done=False, available=False)
+
+
+def test_code_search_install_hint_when_ripgrep_missing(tmp_path, monkeypatch) -> None:
+    """With ripgrep absent, code_search still works (Python) and surfaces a
+    manual-install hint — the seamless fallback + fallback-to-manual path."""
+    monkeypatch.setattr(fo, "ripgrep_path", lambda: None)
+    (tmp_path / "a.py").write_text("needle here\n")
+    result = _run(code_search({"pattern": "needle", "path": str(tmp_path)}))
+    assert result["ok"] is True and result["backend"] == "python"
+    assert result["match_count"] == 1
+    assert "install_hint" in result and "ripgrep" in result["install_hint"]
+
+
+def test_ensure_ripgrep_present_does_not_install(monkeypatch) -> None:
+    _reset_rg_cache()
+    monkeypatch.setattr(fo, "ripgrep_path", lambda: "/usr/bin/rg")
+
+    def _no_install(*_a, **_k):
+        raise AssertionError("must not install when ripgrep is already present")
+
+    monkeypatch.setattr(fo.subprocess, "run", _no_install)
+    assert fo.ensure_ripgrep_available(autoinstall=True) is True
+
+
+def test_ensure_ripgrep_autoinstall_disabled_no_install(monkeypatch) -> None:
+    _reset_rg_cache()
+    monkeypatch.setattr(fo, "ripgrep_path", lambda: None)
+
+    def _no_install(*_a, **_k):
+        raise AssertionError("must not install when autoinstall disabled")
+
+    monkeypatch.setattr(fo.subprocess, "run", _no_install)
+    assert fo.ensure_ripgrep_available(autoinstall=False) is False
+
+
+def test_ensure_ripgrep_non_darwin_skips_install(monkeypatch) -> None:
+    _reset_rg_cache()
+    monkeypatch.setattr(fo, "ripgrep_path", lambda: None)
+    monkeypatch.setattr(fo.sys, "platform", "linux")
+
+    def _no_install(*_a, **_k):
+        raise AssertionError("no no-sudo installer on non-macOS -> Python fallback")
+
+    monkeypatch.setattr(fo.subprocess, "run", _no_install)
+    assert fo.ensure_ripgrep_available(autoinstall=True) is False
+
+
+def test_ensure_ripgrep_darwin_brew_install_succeeds(monkeypatch) -> None:
+    _reset_rg_cache()
+    monkeypatch.setattr(fo.sys, "platform", "darwin")
+    monkeypatch.setattr(fo.shutil, "which", lambda name: "/opt/homebrew/bin/brew" if name == "brew" else None)
+    # ripgrep missing before the install, present after it.
+    states = iter([None, "/opt/homebrew/bin/rg"])
+    monkeypatch.setattr(fo, "ripgrep_path", lambda: next(states))
+    captured: dict = {}
+
+    def _run_install(cmd, **_k):
+        captured["cmd"] = cmd
+        return None
+
+    monkeypatch.setattr(fo.subprocess, "run", _run_install)
+    assert fo.ensure_ripgrep_available(autoinstall=True) is True
+    assert captured["cmd"][:2] == ["brew", "install"]
+
+
+def test_ensure_ripgrep_is_cached(monkeypatch) -> None:
+    _reset_rg_cache()
+    fo._RG_PROVISION.update(done=True, available=True)
+
+    def _no_install(*_a, **_k):
+        raise AssertionError("cached result must not re-attempt install")
+
+    monkeypatch.setattr(fo.subprocess, "run", _no_install)
+    assert fo.ensure_ripgrep_available(autoinstall=True) is True
+    _reset_rg_cache()
+
+
+def test_ripgrep_install_hint_macos(monkeypatch) -> None:
+    monkeypatch.setattr(fo.sys, "platform", "darwin")
+    assert fo.ripgrep_install_hint() == "brew install ripgrep"
+
+
+# ── code_intel: precise document symbols (ast for Python, heuristic otherwise) ──
+
+def test_code_intel_python_ast_symbols(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text(
+        "import os\n"
+        "\n"
+        "class Foo:\n"
+        "    def method_a(self):\n"
+        "        return 1\n"
+        "\n"
+        "def top_level(x, y):\n"
+        "    return x + y\n"
+    )
+    result = _run(code_intel({"path": str(f)}))
+    assert result["ok"] is True and result["engine"] == "ast" and result["language"] == "py"
+    by_name = {s["name"]: s for s in result["symbols"]}
+    assert by_name["Foo"]["kind"] == "class" and by_name["Foo"]["line"] == 3
+    assert by_name["method_a"]["kind"] == "method" and by_name["method_a"]["parent"] == "Foo"
+    assert by_name["top_level"]["kind"] == "function" and by_name["top_level"]["line"] == 7
+    assert "def top_level(x, y):" in by_name["top_level"]["signature"]
+
+
+def test_code_intel_non_python_heuristic(tmp_path) -> None:
+    f = tmp_path / "m.js"
+    f.write_text("function foo() {\n  return 1;\n}\nconst bar = 2;\n")
+    result = _run(code_intel({"path": str(f)}))
+    assert result["ok"] is True and result["engine"] == "heuristic"
+    assert 1 in {s["line"] for s in result["symbols"]}   # 'function foo' line
+
+
+def test_code_intel_invalid_python_falls_back(tmp_path) -> None:
+    f = tmp_path / "bad.py"
+    f.write_text("def broken(:\n    pass\n")  # syntax error -> heuristic fallback, not failure
+    result = _run(code_intel({"path": str(f)}))
+    assert result["ok"] is True and result["engine"] == "heuristic-fallback"
+
+
+def test_code_intel_missing_path() -> None:
+    assert _run(code_intel({}))["ok"] is False
+
+
+def test_code_intel_file_not_found(tmp_path) -> None:
+    assert _run(code_intel({"path": str(tmp_path / "nope.py")}))["ok"] is False
+
+
+def test_code_intel_unsupported_operation(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("x = 1\n")
+    assert _run(code_intel({"path": str(f), "operation": "definition"}))["ok"] is False
+
+
+# ── polish: code_search context_lines + edit_file unified-diff mode ──
+
+def test_code_search_context_lines(tmp_path, monkeypatch) -> None:
+    monkeypatch.setattr(fo, "ripgrep_path", lambda: None)  # deterministic Python backend
+    (tmp_path / "a.py").write_text("line1\nline2\nNEEDLE\nline4\nline5\n")
+    result = _run(code_search({"pattern": "NEEDLE", "path": str(tmp_path), "context_lines": 2}))
+    assert result["ok"] is True and result["match_count"] == 1
+    match = result["matches"][0]
+    assert match["context_before"] == ["line1", "line2"]
+    assert match["context_after"] == ["line4", "line5"]
+
+
+def test_edit_file_apply_unified_diff(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("alpha\nbeta\ngamma\n")
+    diff = "--- a/m.py\n+++ b/m.py\n@@ -1,3 +1,3 @@\n alpha\n-beta\n+BETA\n gamma\n"
+    result = _run(edit_file({"path": str(f), "diff": diff}))
+    assert result["ok"] is True and result["changed"] is True
+    assert f.read_text() == "alpha\nBETA\ngamma\n"
+
+
+def test_edit_file_invalid_diff_is_rejected(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("x\n")
+    result = _run(edit_file({"path": str(f), "diff": "not a diff, no hunks"}))
+    assert result["ok"] is False and result["error_type"] == "invalid_diff"
+    assert f.read_text() == "x\n"
+
+
+# ── B1: advisory post-edit syntax verification ──
+
+def test_edit_file_flags_broken_python_syntax(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("x = 1\n")
+    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "x = 1", "new_text": "def broken(:"}]}))
+    assert result["ok"] is True and result["changed"] is True  # write is not blocked
+    assert result["syntax_ok"] is False and "syntax_error" in result
+
+
+def test_edit_file_valid_python_syntax_ok(tmp_path) -> None:
+    f = tmp_path / "m.py"
+    f.write_text("x = 1\n")
+    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "x = 1", "new_text": "x = 2"}]}))
+    assert result["ok"] is True and result["syntax_ok"] is True
+
+
+def test_edit_file_non_python_has_no_syntax_field(tmp_path) -> None:
+    f = tmp_path / "m.txt"
+    f.write_text("hello\n")
+    result = _run(edit_file({"path": str(f), "edits": [{"original_text": "hello", "new_text": "world"}]}))
+    assert result["ok"] is True and "syntax_ok" not in result
+
+
+def test_file_write_python_syntax_ok(tmp_path) -> None:
+    f = tmp_path / "n.py"
+    result = _run(file_write({"path": str(f), "content": "def ok():\n    return 1\n"}))
+    assert result["ok"] is True and result["syntax_ok"] is True
+
+
+def test_verify_edits_toggle_off(tmp_path) -> None:
+    fo.set_edit_verification(False)
+    try:
+        f = tmp_path / "m.py"
+        f.write_text("x = 1\n")
+        result = _run(edit_file({"path": str(f), "edits": [{"original_text": "x = 1", "new_text": "def broken(:"}]}))
+        assert result["ok"] is True and "syntax_ok" not in result
+    finally:
+        fo.set_edit_verification(True)
diff --git a/tests/test_daemon_event_loop_blocking.py b/tests/test_daemon_event_loop_blocking.py
index 67737a1..cc1f797 100644
--- a/tests/test_daemon_event_loop_blocking.py
+++ b/tests/test_daemon_event_loop_blocking.py
@@ -1,356 +1,356 @@
-"""Regression tests for the daemon event-loop permanent-blocking fix.
-
-Root cause chain (observed as a 43-minute daemon freeze where every RPC
-timed out):
-
-1. ``SemanticMemoryProvider._init_schema()`` created an index on
-   ``session_id`` *before* the ALTER TABLE migration that adds the column,
-   so legacy databases failed deferred init with a Binder Error.
-2. The failure made ``engine_chat`` re-enter ``_ensure_deferred()`` which
-   waited *unboundedly* on ``_deferred_lock``.
-3. ``initialize_deferred()`` ran heavy synchronous DuckDB operations
-   directly on the event-loop thread, freezing heartbeats and all RPCs.
-
-Validates:
-- legacy-schema DuckDB files migrate cleanly and end up with the session
-  index in place
-- ``engine_chat`` degrades to critical-only mode after a bounded wait
-  instead of hanging until deferred init completes
-- a foreground timeout on ``_ensure_deferred()`` never cancels the
-  background runner task (shielded wait), and the init is not re-executed
-- deferred DB work runs on the dedicated executor so concurrent tasks keep
-  running with sub-100ms scheduling gaps
-"""
-from __future__ import annotations
-
-import asyncio
-import time
-from pathlib import Path
-from typing import Any, List, Optional
-
-import duckdb
-import pytest
-
-from leapflow.cli.context import Context
-from leapflow.daemon.service import RuntimeLeapService
-from leapflow.memory.providers.semantic import SemanticMemoryProvider
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# 1. Semantic schema migration order (defect trigger)
-# ═══════════════════════════════════════════════════════════════════════════
-
-
-class TestSemanticSchemaMigrationOrder:
-    """Indexes on migrated columns must be created AFTER the migrations."""
-
-    @staticmethod
-    def _create_legacy_db(db_path: Path) -> None:
-        """Build a pre-migration leap_memory table (no domain/path/session_id)."""
-        con = duckdb.connect(str(db_path))
-        con.execute(
-            """
-            CREATE TABLE leap_memory (
-                id TEXT PRIMARY KEY,
-                kind TEXT NOT NULL,
-                content TEXT NOT NULL,
-                metadata TEXT,
-                created_at DOUBLE NOT NULL,
-                accessed_at DOUBLE NOT NULL,
-                access_count INTEGER NOT NULL DEFAULT 1
-            );
-            """
-        )
-        con.execute(
-            "INSERT INTO leap_memory (id, kind, content, created_at, accessed_at) "
-            "VALUES ('m1', 'note', 'legacy row', 1.0, 1.0)"
-        )
-        con.close()
-
-    @pytest.mark.asyncio
-    async def test_initialize_on_legacy_schema_succeeds(self, tmp_path: Path) -> None:
-        db_path = tmp_path / "legacy.duckdb"
-        self._create_legacy_db(db_path)
-
-        provider = SemanticMemoryProvider(source=db_path)
-        # Before the fix this raised a Binder Error: CREATE INDEX on
-        # session_id ran before ALTER TABLE ADD COLUMN session_id.
-        await provider.initialize()
-        try:
-            con = provider._connection()
-            cols = {
-                row[0]
-                for row in con.execute(
-                    "SELECT column_name FROM information_schema.columns "
-                    "WHERE table_name = 'leap_memory'"
-                ).fetchall()
-            }
-            assert {"domain", "path", "session_id"} <= cols
-
-            indexes = {
-                row[0]
-                for row in con.execute(
-                    "SELECT index_name FROM duckdb_indexes() "
-                    "WHERE table_name = 'leap_memory'"
-                ).fetchall()
-            }
-            assert "idx_lm_session" in indexes
-            assert "idx_lm_domain" in indexes
-
-            # Legacy data survives the migration
-            count = con.execute("SELECT COUNT(*) FROM leap_memory").fetchone()[0]
-            assert count == 1
-        finally:
-            await provider.shutdown()
-
-    @pytest.mark.asyncio
-    async def test_initialize_on_fresh_db_still_works(self, tmp_path: Path) -> None:
-        provider = SemanticMemoryProvider(source=tmp_path / "fresh.duckdb")
-        await provider.initialize()
-        try:
-            indexes = {
-                row[0]
-                for row in provider._connection().execute(
-                    "SELECT index_name FROM duckdb_indexes() "
-                    "WHERE table_name = 'leap_memory'"
-                ).fetchall()
-            }
-            assert "idx_lm_session" in indexes
-        finally:
-            await provider.shutdown()
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# 2. engine_chat bounded wait + critical-only degradation
-# ═══════════════════════════════════════════════════════════════════════════
-
-
-class _NeverReadyContext:
-    """Context stand-in whose deferred init never completes."""
-
-    def __init__(self) -> None:
-        self._deferred_initialized = False
-        self.ensure_calls = 0
-
-    async def _ensure_deferred(self) -> None:
-        self.ensure_calls += 1
-        await asyncio.Event().wait()  # blocks forever until cancelled
-
-
-class TestEngineChatDegradesOnDeferredTimeout:
-    """engine_chat must not hang when deferred init never finishes."""
-
-    @pytest.mark.asyncio
-    async def test_degrades_to_critical_only_after_timeout(self) -> None:
-        service = RuntimeLeapService.__new__(RuntimeLeapService)
-        fake_ctx = _NeverReadyContext()
-        service._ctx = fake_ctx
-        service._DEFERRED_WAIT_TIMEOUT_S = 0.1  # type: ignore[misc]
-        service._turn_admission = type(
-            "_Admission", (), {"locked": staticmethod(lambda: False)}
-        )()
-
-        stream = service.engine_chat("hello", request_id="req-degrade-1")
-        first_chunk: Any = await stream.__anext__()
-        assert first_chunk.event_type == "status"
-        assert "warming up" in first_chunk.content.lower()
-
-        # The next step must complete within the bounded wait (plus margin):
-        # a hang here means the degrade path was not taken.
-        try:
-            await asyncio.wait_for(stream.__anext__(), timeout=2.0)
-        except asyncio.TimeoutError:
-            pytest.fail(
-                "engine_chat hung on _ensure_deferred(); expected bounded "
-                "wait followed by critical-only degradation"
-            )
-        except (StopAsyncIteration, Exception):
-            # Reaching the deeper pipeline (which fails on the bare fake) is
-            # fine — the point is we got PAST the deferred wait quickly.
-            pass
-        finally:
-            await stream.aclose()
-
-        assert fake_ctx.ensure_calls == 1
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# 3. _ensure_deferred: shielded wait, cancel-safe, no duplicate init
-# ═══════════════════════════════════════════════════════════════════════════
-
-
-class TestEnsureDeferredCancelSafety:
-    """A foreground timeout must not cancel or re-run the background init."""
-
-    @staticmethod
-    def _bare_context() -> Context:
-        ctx = Context.__new__(Context)
-        ctx._deferred_initialized = False
-        ctx._deferred_lock = asyncio.Lock()
-        ctx._deferred_attempts = 0
-        ctx._deferred_task = None
-        return ctx
-
-    @pytest.mark.asyncio
-    async def test_timeout_does_not_cancel_background_runner(self) -> None:
-        ctx = self._bare_context()
-        release = asyncio.Event()
-        init_calls = 0
-
-        async def _slow_init() -> None:
-            nonlocal init_calls
-            init_calls += 1
-            await release.wait()
-
-        ctx.initialize_deferred = _slow_init  # type: ignore[method-assign]
-
-        # Background waiter (daemon's _run_deferred_init analog)
-        background = asyncio.create_task(ctx._ensure_deferred())
-        await asyncio.sleep(0.01)  # let the runner task start
-        runner: Optional[asyncio.Task[None]] = ctx._deferred_task
-        assert runner is not None and not runner.done()
-
-        # Foreground bounded wait times out (engine_chat analog)
-        with pytest.raises(asyncio.TimeoutError):
-            await asyncio.wait_for(ctx._ensure_deferred(), timeout=0.05)
-
-        # The runner must survive the foreground timeout untouched
-        assert not runner.cancelled()
-        assert not runner.done()
-        assert init_calls == 1  # no duplicate initialization
-
-        # Completing the init unblocks the background waiter
-        release.set()
-        await asyncio.wait_for(background, timeout=1.0)
-        assert ctx._deferred_initialized is True
-        assert init_calls == 1
-
-        # Subsequent calls are cheap no-ops
-        await ctx._ensure_deferred()
-        assert init_calls == 1
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# 4. Deferred DB work runs off the event loop (dedicated executor)
-# ═══════════════════════════════════════════════════════════════════════════
-
-
-class TestDeferredDbExecutor:
-    """Blocking DuckDB work must not freeze the event loop.
-
-    Asserted behaviorally below: scanning ``initialize_deferred``'s source for
-    ``_run_deferred_db`` occurrences would pin the current call-site layout
-    rather than the contract — that a blocking DB call keeps the loop
-    responsive and that ``status()`` still answers while the DB worker is busy.
-    """
-
-    @pytest.mark.asyncio
-    async def test_event_loop_stays_responsive_during_blocking_db_op(self) -> None:
-        ctx = Context.__new__(Context)
-        ctx._deferred_db_executor = None
-
-        ticks: List[float] = []
-        stop = asyncio.Event()
-
-        async def _ticker() -> None:
-            while not stop.is_set():
-                ticks.append(time.monotonic())
-                await asyncio.sleep(0.01)
-
-        ticker_task = asyncio.create_task(_ticker())
-        try:
-            start = time.monotonic()
-            result = await ctx._run_deferred_db(lambda: (time.sleep(0.3), 42)[1])
-            elapsed = time.monotonic() - start
-            assert result == 42
-            # Windows' monotonic clock quantizes to ~15.6ms, so the measured
-            # interval can read a few ms short of the blocking sleep itself.
-            assert elapsed >= 0.3 - 0.03
-        finally:
-            stop.set()
-            await ticker_task
-            executor = ctx._deferred_db_executor
-            if executor is not None:
-                executor.shutdown(wait=True)
-
-        # The loop must have kept scheduling the ticker while the blocking
-        # sleep ran in the executor thread: gaps stay well under 100ms.
-        in_window = [t for t in ticks if start <= t <= start + 0.3]
-        assert len(in_window) >= 3, (
-            f"event loop starved during blocking DB op: only {len(in_window)} "
-            "ticker iterations observed in the 300ms window"
-        )
-        gaps = [b - a for a, b in zip(in_window, in_window[1:])]
-        assert gaps and max(gaps) < 0.1, (
-            f"event loop stalled for {max(gaps) if gaps else 0:.3f}s during "
-            "the blocking DB operation"
-        )
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# 5. Daemon control-plane responsiveness during deferred init
-# ═══════════════════════════════════════════════════════════════════════════
-
-
-class TestDaemonControlPlaneResponsiveness:
-    """Status/recovery RPCs must get scheduling priority over background init."""
-
-    @pytest.mark.asyncio
-    async def test_service_deferred_runner_yields_before_initialization(self) -> None:
-        order: list[str] = []
-
-        class FakeContext:
-            async def _ensure_deferred(self) -> None:
-                order.append("deferred")
-
-        async def _peer_control_plane_task() -> None:
-            order.append("peer")
-
-        service = RuntimeLeapService.__new__(RuntimeLeapService)
-        deferred = asyncio.create_task(service._run_deferred_init(FakeContext()))
-        peer = asyncio.create_task(_peer_control_plane_task())
-
-        await asyncio.gather(deferred, peer)
-
-        assert order == ["peer", "deferred"]
-
-    @pytest.mark.asyncio
-    async def test_status_returns_while_deferred_db_worker_is_busy(self, tmp_path: Path) -> None:
-        from conftest import make_settings
-        from types import SimpleNamespace
-
-        settings = make_settings(str(tmp_path))
-        service = RuntimeLeapService(settings, mock_host=True)
-        ctx = Context.__new__(Context)
-        ctx.settings = settings
-        ctx.engine = None
-        ctx._db_holder = SimpleNamespace(db_path=settings.duckdb_path)
-        ctx._deferred_initialized = False
-        ctx._deferred_lock = asyncio.Lock()
-        ctx._deferred_attempts = 0
-        ctx._deferred_task = None
-        ctx._deferred_db_executor = None
-
-        async def _slow_init() -> None:
-            await ctx._run_deferred_db(lambda: time.sleep(0.25))
-
-        ctx.initialize_deferred = _slow_init  # type: ignore[method-assign]
-        service._ctx = ctx
-        service._deferred_init_task = asyncio.create_task(service._run_deferred_init(ctx))
-        try:
-            for _ in range(50):
-                runner = getattr(ctx, "_deferred_task", None)
-                if runner is not None and not runner.done():
-                    break
-                await asyncio.sleep(0.01)
-            assert ctx._deferred_task is not None and not ctx._deferred_task.done()
-
-            status = await asyncio.wait_for(service.status(), timeout=0.1)
-
-            assert status["deferred_init"]["running"] is True
-            assert status["deferred_init"]["initialized"] is False
-        finally:
-            await service._deferred_init_task
-            executor = getattr(ctx, "_deferred_db_executor", None)
-            if executor is not None:
-                executor.shutdown(wait=True)
+"""Regression tests for the daemon event-loop permanent-blocking fix.
+
+Root cause chain (observed as a 43-minute daemon freeze where every RPC
+timed out):
+
+1. ``SemanticMemoryProvider._init_schema()`` created an index on
+   ``session_id`` *before* the ALTER TABLE migration that adds the column,
+   so legacy databases failed deferred init with a Binder Error.
+2. The failure made ``engine_chat`` re-enter ``_ensure_deferred()`` which
+   waited *unboundedly* on ``_deferred_lock``.
+3. ``initialize_deferred()`` ran heavy synchronous DuckDB operations
+   directly on the event-loop thread, freezing heartbeats and all RPCs.
+
+Validates:
+- legacy-schema DuckDB files migrate cleanly and end up with the session
+  index in place
+- ``engine_chat`` degrades to critical-only mode after a bounded wait
+  instead of hanging until deferred init completes
+- a foreground timeout on ``_ensure_deferred()`` never cancels the
+  background runner task (shielded wait), and the init is not re-executed
+- deferred DB work runs on the dedicated executor so concurrent tasks keep
+  running with sub-100ms scheduling gaps
+"""
+from __future__ import annotations
+
+import asyncio
+import time
+from pathlib import Path
+from typing import Any, List, Optional
+
+import duckdb
+import pytest
+
+from leapflow.cli.context import Context
+from leapflow.daemon.service import RuntimeLeapService
+from leapflow.memory.providers.semantic import SemanticMemoryProvider
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 1. Semantic schema migration order (defect trigger)
+# ═══════════════════════════════════════════════════════════════════════════
+
+
+class TestSemanticSchemaMigrationOrder:
+    """Indexes on migrated columns must be created AFTER the migrations."""
+
+    @staticmethod
+    def _create_legacy_db(db_path: Path) -> None:
+        """Build a pre-migration leap_memory table (no domain/path/session_id)."""
+        con = duckdb.connect(str(db_path))
+        con.execute(
+            """
+            CREATE TABLE leap_memory (
+                id TEXT PRIMARY KEY,
+                kind TEXT NOT NULL,
+                content TEXT NOT NULL,
+                metadata TEXT,
+                created_at DOUBLE NOT NULL,
+                accessed_at DOUBLE NOT NULL,
+                access_count INTEGER NOT NULL DEFAULT 1
+            );
+            """
+        )
+        con.execute(
+            "INSERT INTO leap_memory (id, kind, content, created_at, accessed_at) "
+            "VALUES ('m1', 'note', 'legacy row', 1.0, 1.0)"
+        )
+        con.close()
+
+    @pytest.mark.asyncio
+    async def test_initialize_on_legacy_schema_succeeds(self, tmp_path: Path) -> None:
+        db_path = tmp_path / "legacy.duckdb"
+        self._create_legacy_db(db_path)
+
+        provider = SemanticMemoryProvider(source=db_path)
+        # Before the fix this raised a Binder Error: CREATE INDEX on
+        # session_id ran before ALTER TABLE ADD COLUMN session_id.
+        await provider.initialize()
+        try:
+            con = provider._connection()
+            cols = {
+                row[0]
+                for row in con.execute(
+                    "SELECT column_name FROM information_schema.columns "
+                    "WHERE table_name = 'leap_memory'"
+                ).fetchall()
+            }
+            assert {"domain", "path", "session_id"} <= cols
+
+            indexes = {
+                row[0]
+                for row in con.execute(
+                    "SELECT index_name FROM duckdb_indexes() "
+                    "WHERE table_name = 'leap_memory'"
+                ).fetchall()
+            }
+            assert "idx_lm_session" in indexes
+            assert "idx_lm_domain" in indexes
+
+            # Legacy data survives the migration
+            count = con.execute("SELECT COUNT(*) FROM leap_memory").fetchone()[0]
+            assert count == 1
+        finally:
+            await provider.shutdown()
+
+    @pytest.mark.asyncio
+    async def test_initialize_on_fresh_db_still_works(self, tmp_path: Path) -> None:
+        provider = SemanticMemoryProvider(source=tmp_path / "fresh.duckdb")
+        await provider.initialize()
+        try:
+            indexes = {
+                row[0]
+                for row in provider._connection().execute(
+                    "SELECT index_name FROM duckdb_indexes() "
+                    "WHERE table_name = 'leap_memory'"
+                ).fetchall()
+            }
+            assert "idx_lm_session" in indexes
+        finally:
+            await provider.shutdown()
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 2. engine_chat bounded wait + critical-only degradation
+# ═══════════════════════════════════════════════════════════════════════════
+
+
+class _NeverReadyContext:
+    """Context stand-in whose deferred init never completes."""
+
+    def __init__(self) -> None:
+        self._deferred_initialized = False
+        self.ensure_calls = 0
+
+    async def _ensure_deferred(self) -> None:
+        self.ensure_calls += 1
+        await asyncio.Event().wait()  # blocks forever until cancelled
+
+
+class TestEngineChatDegradesOnDeferredTimeout:
+    """engine_chat must not hang when deferred init never finishes."""
+
+    @pytest.mark.asyncio
+    async def test_degrades_to_critical_only_after_timeout(self) -> None:
+        service = RuntimeLeapService.__new__(RuntimeLeapService)
+        fake_ctx = _NeverReadyContext()
+        service._ctx = fake_ctx
+        service._DEFERRED_WAIT_TIMEOUT_S = 0.1  # type: ignore[misc]
+        service._turn_admission = type(
+            "_Admission", (), {"locked": staticmethod(lambda: False)}
+        )()
+
+        stream = service.engine_chat("hello", request_id="req-degrade-1")
+        first_chunk: Any = await stream.__anext__()
+        assert first_chunk.event_type == "status"
+        assert "warming up" in first_chunk.content.lower()
+
+        # The next step must complete within the bounded wait (plus margin):
+        # a hang here means the degrade path was not taken.
+        try:
+            await asyncio.wait_for(stream.__anext__(), timeout=2.0)
+        except asyncio.TimeoutError:
+            pytest.fail(
+                "engine_chat hung on _ensure_deferred(); expected bounded "
+                "wait followed by critical-only degradation"
+            )
+        except (StopAsyncIteration, Exception):
+            # Reaching the deeper pipeline (which fails on the bare fake) is
+            # fine — the point is we got PAST the deferred wait quickly.
+            pass
+        finally:
+            await stream.aclose()
+
+        assert fake_ctx.ensure_calls == 1
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 3. _ensure_deferred: shielded wait, cancel-safe, no duplicate init
+# ═══════════════════════════════════════════════════════════════════════════
+
+
+class TestEnsureDeferredCancelSafety:
+    """A foreground timeout must not cancel or re-run the background init."""
+
+    @staticmethod
+    def _bare_context() -> Context:
+        ctx = Context.__new__(Context)
+        ctx._deferred_initialized = False
+        ctx._deferred_lock = asyncio.Lock()
+        ctx._deferred_attempts = 0
+        ctx._deferred_task = None
+        return ctx
+
+    @pytest.mark.asyncio
+    async def test_timeout_does_not_cancel_background_runner(self) -> None:
+        ctx = self._bare_context()
+        release = asyncio.Event()
+        init_calls = 0
+
+        async def _slow_init() -> None:
+            nonlocal init_calls
+            init_calls += 1
+            await release.wait()
+
+        ctx.initialize_deferred = _slow_init  # type: ignore[method-assign]
+
+        # Background waiter (daemon's _run_deferred_init analog)
+        background = asyncio.create_task(ctx._ensure_deferred())
+        await asyncio.sleep(0.01)  # let the runner task start
+        runner: Optional[asyncio.Task[None]] = ctx._deferred_task
+        assert runner is not None and not runner.done()
+
+        # Foreground bounded wait times out (engine_chat analog)
+        with pytest.raises(asyncio.TimeoutError):
+            await asyncio.wait_for(ctx._ensure_deferred(), timeout=0.05)
+
+        # The runner must survive the foreground timeout untouched
+        assert not runner.cancelled()
+        assert not runner.done()
+        assert init_calls == 1  # no duplicate initialization
+
+        # Completing the init unblocks the background waiter
+        release.set()
+        await asyncio.wait_for(background, timeout=1.0)
+        assert ctx._deferred_initialized is True
+        assert init_calls == 1
+
+        # Subsequent calls are cheap no-ops
+        await ctx._ensure_deferred()
+        assert init_calls == 1
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 4. Deferred DB work runs off the event loop (dedicated executor)
+# ═══════════════════════════════════════════════════════════════════════════
+
+
+class TestDeferredDbExecutor:
+    """Blocking DuckDB work must not freeze the event loop.
+
+    Asserted behaviorally below: scanning ``initialize_deferred``'s source for
+    ``_run_deferred_db`` occurrences would pin the current call-site layout
+    rather than the contract — that a blocking DB call keeps the loop
+    responsive and that ``status()`` still answers while the DB worker is busy.
+    """
+
+    @pytest.mark.asyncio
+    async def test_event_loop_stays_responsive_during_blocking_db_op(self) -> None:
+        ctx = Context.__new__(Context)
+        ctx._deferred_db_executor = None
+
+        ticks: List[float] = []
+        stop = asyncio.Event()
+
+        async def _ticker() -> None:
+            while not stop.is_set():
+                ticks.append(time.monotonic())
+                await asyncio.sleep(0.01)
+
+        ticker_task = asyncio.create_task(_ticker())
+        try:
+            start = time.monotonic()
+            result = await ctx._run_deferred_db(lambda: (time.sleep(0.3), 42)[1])
+            elapsed = time.monotonic() - start
+            assert result == 42
+            # Windows' monotonic clock quantizes to ~15.6ms, so the measured
+            # interval can read a few ms short of the blocking sleep itself.
+            assert elapsed >= 0.3 - 0.03
+        finally:
+            stop.set()
+            await ticker_task
+            executor = ctx._deferred_db_executor
+            if executor is not None:
+                executor.shutdown(wait=True)
+
+        # The loop must have kept scheduling the ticker while the blocking
+        # sleep ran in the executor thread: gaps stay well under 100ms.
+        in_window = [t for t in ticks if start <= t <= start + 0.3]
+        assert len(in_window) >= 3, (
+            f"event loop starved during blocking DB op: only {len(in_window)} "
+            "ticker iterations observed in the 300ms window"
+        )
+        gaps = [b - a for a, b in zip(in_window, in_window[1:])]
+        assert gaps and max(gaps) < 0.1, (
+            f"event loop stalled for {max(gaps) if gaps else 0:.3f}s during "
+            "the blocking DB operation"
+        )
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 5. Daemon control-plane responsiveness during deferred init
+# ═══════════════════════════════════════════════════════════════════════════
+
+
+class TestDaemonControlPlaneResponsiveness:
+    """Status/recovery RPCs must get scheduling priority over background init."""
+
+    @pytest.mark.asyncio
+    async def test_service_deferred_runner_yields_before_initialization(self) -> None:
+        order: list[str] = []
+
+        class FakeContext:
+            async def _ensure_deferred(self) -> None:
+                order.append("deferred")
+
+        async def _peer_control_plane_task() -> None:
+            order.append("peer")
+
+        service = RuntimeLeapService.__new__(RuntimeLeapService)
+        deferred = asyncio.create_task(service._run_deferred_init(FakeContext()))
+        peer = asyncio.create_task(_peer_control_plane_task())
+
+        await asyncio.gather(deferred, peer)
+
+        assert order == ["peer", "deferred"]
+
+    @pytest.mark.asyncio
+    async def test_status_returns_while_deferred_db_worker_is_busy(self, tmp_path: Path) -> None:
+        from conftest import make_settings
+        from types import SimpleNamespace
+
+        settings = make_settings(str(tmp_path))
+        service = RuntimeLeapService(settings, mock_host=True)
+        ctx = Context.__new__(Context)
+        ctx.settings = settings
+        ctx.engine = None
+        ctx._db_holder = SimpleNamespace(db_path=settings.duckdb_path)
+        ctx._deferred_initialized = False
+        ctx._deferred_lock = asyncio.Lock()
+        ctx._deferred_attempts = 0
+        ctx._deferred_task = None
+        ctx._deferred_db_executor = None
+
+        async def _slow_init() -> None:
+            await ctx._run_deferred_db(lambda: time.sleep(0.25))
+
+        ctx.initialize_deferred = _slow_init  # type: ignore[method-assign]
+        service._ctx = ctx
+        service._deferred_init_task = asyncio.create_task(service._run_deferred_init(ctx))
+        try:
+            for _ in range(50):
+                runner = getattr(ctx, "_deferred_task", None)
+                if runner is not None and not runner.done():
+                    break
+                await asyncio.sleep(0.01)
+            assert ctx._deferred_task is not None and not ctx._deferred_task.done()
+
+            status = await asyncio.wait_for(service.status(), timeout=0.1)
+
+            assert status["deferred_init"]["running"] is True
+            assert status["deferred_init"]["initialized"] is False
+        finally:
+            await service._deferred_init_task
+            executor = getattr(ctx, "_deferred_db_executor", None)
+            if executor is not None:
+                executor.shutdown(wait=True)
diff --git a/tests/test_tool_call_hardening.py b/tests/test_tool_call_hardening.py
index e98ae9b..6b93866 100644
--- a/tests/test_tool_call_hardening.py
+++ b/tests/test_tool_call_hardening.py
@@ -1,372 +1,372 @@
-"""Tests for P0 tool-calling / result hardening in the agent loop:
-
-- A1: pre-execution required-argument validation (_validate_tool_arguments)
-- B2: structure-aware tool-result truncation (_truncate_result_for_budget)
-
-Both are pure module functions, exercised directly.
-"""
-from __future__ import annotations
-
-import asyncio
-import json
-import os
-
-from leapflow.engine.engine import (
-    _head_tail_truncate,
-    _truncate_result_for_budget,
-    _validate_tool_arguments,
-)
-from leapflow.tools.name_resolver import ToolSpec
-
-
-def _spec(name: str, required: set[str], params: set[str]) -> ToolSpec:
-    return ToolSpec(name=name, parameters=frozenset(params), required=frozenset(required))
-
-
-# ── A1: argument validation ──────────────────────────────────────────
-
-def test_validate_missing_required_returns_structured_error() -> None:
-    spec = _spec("edit_file", {"path"}, {"path", "edits", "diff"})
-    result = _validate_tool_arguments(spec, {"edits": []})  # path missing
-    assert result is not None
-    assert result["ok"] is False and result["error_type"] == "invalid_arguments"
-    assert result["missing"] == ["path"]
-    assert "path" in result["accepted_parameters"]
-    # Must not penalize failure budgets or trip the batch-stop gate.
-    assert result["counts_as_failure"] is False and result["retryable"] is True
-    assert "execution_policy" not in result
-
-
-def test_validate_present_required_passes() -> None:
-    spec = _spec("edit_file", {"path"}, {"path", "edits"})
-    assert _validate_tool_arguments(spec, {"path": "/x", "edits": []}) is None
-
-
-def test_validate_no_required_is_skipped() -> None:
-    spec = _spec("terminal_list", set(), set())
-    assert _validate_tool_arguments(spec, {}) is None
-
-
-def test_validate_present_but_empty_is_not_missing() -> None:
-    # Presence-only: an empty but present required value is the handler's concern
-    # (e.g. text_replace new="" is a valid delete), not a validation rejection.
-    spec = _spec("text_replace", {"text", "old", "new"}, {"text", "old", "new"})
-    assert _validate_tool_arguments(spec, {"text": "abc", "old": "a", "new": ""}) is None
-
-
-def test_validate_none_spec_is_skipped() -> None:
-    assert _validate_tool_arguments(None, {"anything": 1}) is None
-
-
-# ── B2: structure-aware truncation ───────────────────────────────────
-
-def test_truncate_within_budget_is_unchanged() -> None:
-    payload = {"ok": True, "stdout": "small output"}
-    text = _truncate_result_for_budget(payload, 1000)
-    assert json.loads(text) == payload
-
-
-def test_truncate_preserves_head_and_tail_of_large_field() -> None:
-    payload = {"ok": False, "stdout": "HEAD_MARKER" + ("x" * 6000) + "TAIL_ERROR"}
-    text = _truncate_result_for_budget(payload, 800)
-    assert len(text) <= 800
-    obj = json.loads(text)  # still valid JSON (shrank the field, not the JSON string)
-    assert "TAIL_ERROR" in obj["stdout"]   # the actual error at the tail survives
-    assert "HEAD_MARKER" in obj["stdout"]  # head survives
-    assert "elided" in obj["stdout"]       # explicit elision marker
-
-
-def test_truncate_nondict_payload_is_safe() -> None:
-    text = _truncate_result_for_budget("a very long string " * 100, 50)
-    assert len(text) <= 50
-
-
-def test_head_tail_truncate_keeps_both_ends() -> None:
-    text = "START" + ("m" * 1000) + "END"
-    out = _head_tail_truncate(text, 200)
-    assert out.startswith("START") and out.endswith("END") and "elided" in out
-    assert len(out) < len(text)
-
-
-def test_head_tail_truncate_short_text_unchanged() -> None:
-    assert _head_tail_truncate("short", 200) == "short"
-
-
-def test_truncate_list_field_pruned_and_annotated() -> None:
-    """List fields (e.g. file_list entries) must be pruned, not string-cut."""
-    entries = [{"name": f"file_{i}.py", "type": "file", "size": 1000} for i in range(80)]
-    payload = {"ok": True, "kind": "file_list_evidence", "path": "/proj", "entries": entries, "entry_count": 80}
-    text = _truncate_result_for_budget(payload, 1000)
-    obj = json.loads(text)  # must be valid JSON — not a raw string cut
-    assert obj["ok"] is True
-    assert len(obj["entries"]) < 80           # entries were pruned
-    assert "entries_omitted" in obj           # omission count is explicit
-    assert obj["entries_omitted"] + len(obj["entries"]) == 80
-
-
-def test_truncate_over_budget_dict_never_returns_malformed_json() -> None:
-    """When every shrinking strategy fails, a valid sentinel dict is returned."""
-    # A dict where string truncation alone cannot bring it under budget because
-    # the overhead fields themselves exceed the budget.
-    payload = {"ok": True, "kind": "file_list_evidence", "entries": [], "entry_count": 0,
-               "irreducible": "x" * 100}
-    text = _truncate_result_for_budget(payload, 80)  # budget is tiny
-    # Must parse as JSON (no raw cut)
-    obj = json.loads(text)
-    assert isinstance(obj, dict)
-
-
-def test_compaction_preserves_invalid_argument_repair_hints() -> None:
-    from leapflow.engine.context_control import ToolEvidenceBuilder
-    builder = ToolEvidenceBuilder()
-    invalid = {
-        "ok": False,
-        "error": "Invalid arguments for edit_file: missing required parameter(s): path",
-        "error_type": "invalid_arguments",
-        "missing": ["path"],
-        "accepted_parameters": ["diff", "edits", "path"],
-        "retryable": True,
-        "counts_as_failure": False,
-    }
-    compact = builder.build("edit_file", {}, invalid)
-    assert compact["error_type"] == "invalid_arguments"
-    assert compact["missing"] == ["path"]
-    assert compact["accepted_parameters"] == ["diff", "edits", "path"]
-
-
-def test_compaction_preserves_anchor_not_unique_match_count() -> None:
-    from leapflow.engine.context_control import ToolEvidenceBuilder
-    builder = ToolEvidenceBuilder()
-    result = {"ok": False, "error": "not unique", "error_type": "anchor_not_unique", "match_count": 3}
-    compact = builder.build("edit_file", {}, result)
-    assert compact["error_type"] == "anchor_not_unique" and compact["match_count"] == 3
-
-
-# ── failure visibility: stdout/stderr survive compaction; shell_run sets error ──
-
-def test_compact_error_preserves_shell_output() -> None:
-    """A failed shell result must keep stderr (the traceback) + returncode so the
-    agent can diagnose the cause instead of seeing a bare 'unknown error'."""
-    from leapflow.engine.context_control import ToolEvidenceBuilder
-    builder = ToolEvidenceBuilder()
-    failed = {
-        "ok": False,
-        "returncode": 1,
-        "stdout": "partial output",
-        "stderr": "Traceback (most recent call last):\n  ...\nModuleNotFoundError: No module named 'yfinance'",
-        "error": "ModuleNotFoundError: No module named 'yfinance'",
-    }
-    compact = builder.build("shell_run", {}, failed)
-    assert compact["ok"] is False and compact["returncode"] == 1
-    assert "ModuleNotFoundError" in compact["stderr"]   # traceback preserved
-    assert "yfinance" in compact["error"]
-
-
-def test_compact_error_preserves_stderr_without_error_field() -> None:
-    from leapflow.engine.context_control import ToolEvidenceBuilder
-    builder = ToolEvidenceBuilder()
-    result = {"ok": False, "returncode": 2, "stdout": "", "stderr": "boom: the real error"}
-    compact = builder.build("shell_run", {}, result)
-    assert "boom: the real error" in compact["stderr"] and compact["returncode"] == 2
-
-
-def test_shell_run_populates_error_on_failure() -> None:
-    import os
-
-    from leapflow.tools.shell_tools import shell_run
-    # cmd.exe (the Windows shell backend) has no ';' separator; '&&' works on both.
-    joiner = "&&" if os.name == "nt" else ";"
-    result = asyncio.run(shell_run({"command": f"echo BOOM_ERR 1>&2 {joiner} exit 2"}))
-    assert result["ok"] is False and result["returncode"] == 2
-    assert "BOOM_ERR" in result["error"] and "BOOM_ERR" in result["stderr"]
-
-
-def test_shell_run_success_has_no_error_field() -> None:
-    from leapflow.tools.shell_tools import shell_run
-    result = asyncio.run(shell_run({"command": "echo ok"}))
-    assert result["ok"] is True and "error" not in result and "ok" in result["stdout"]
-
-
-def test_workspace_context_resolves_relative_paths_and_blocks_cross_workspace(tmp_path) -> None:
-    from leapflow.tools.execution_context import (
-        ToolExecutionContext,
-        reset_tool_context,
-        set_tool_context,
-    )
-    from leapflow.tools.file_operations import code_search, file_read
-    from leapflow.tools.repo_map import repo_map
-    from leapflow.tools.shell_tools import shell_run
-
-    workspace = tmp_path / "work"
-    other = tmp_path / "other"
-    workspace.mkdir()
-    other.mkdir()
-    (workspace / "alpha.txt").write_text("needle in workspace", encoding="utf-8")
-    (other / "secret.txt").write_text("needle outside", encoding="utf-8")
-
-    token = set_tool_context(
-        ToolExecutionContext.from_strings(
-            workspace_root=str(workspace),
-            session_id="sess-work",
-            task_id="turn-test",
-        )
-    )
-    try:
-        read_result = asyncio.run(file_read({"path": "alpha.txt"}))
-        assert read_result["ok"] is True
-        assert read_result["path"] == str((workspace / "alpha.txt").resolve())
-
-        search_result = asyncio.run(code_search({"pattern": "needle", "path": "."}))
-        assert search_result["ok"] is True
-        assert search_result["path"] == str(workspace.resolve())
-        assert search_result["match_count"] == 1
-
-        repo_result = asyncio.run(repo_map({"path": "."}))
-        assert repo_result["ok"] is True
-        assert repo_result["root"] == str(workspace.resolve())
-
-        pwd_command = "echo %CD%" if os.name == "nt" else "pwd"
-        shell_result = asyncio.run(shell_run({"command": pwd_command}))
-        assert shell_result["ok"] is True, shell_result
-        assert shell_result["cwd"] == str(workspace.resolve())
-
-        blocked = asyncio.run(file_read({"path": str(other / "secret.txt")}))
-        assert blocked["ok"] is False
-        assert blocked["error_type"] == "outside_workspace"
-        assert blocked["workspace_root"] == str(workspace.resolve())
-
-        blocked_shell = asyncio.run(shell_run({"command": f"cat {other / 'secret.txt'}"}))
-        assert blocked_shell["ok"] is False
-        assert blocked_shell["error_type"] == "outside_workspace"
-        assert blocked_shell["workspace_root"] == str(workspace.resolve())
-    finally:
-        reset_tool_context(token)
-
-
-def test_shell_gate_blocks_expanded_and_relative_escapes(tmp_path, monkeypatch) -> None:
-    """The gate must judge the resolved target, not how the operand is spelled.
-
-    A guard that only inspects literal ``/``/``~`` operands passes ``$HOME/...``
-    and ``../../..`` straight through, so the same file is reachable by choosing
-    a different spelling and the workspace boundary stops being a boundary.
-    """
-    from leapflow.tools.execution_context import (
-        ToolExecutionContext,
-        reset_tool_context,
-        set_tool_context,
-    )
-    from leapflow.tools.shell_tools import shell_run
-
-    import os
-
-    workspace = tmp_path / "work"
-    other = tmp_path / "other"
-    workspace.mkdir()
-    (workspace / "sub").mkdir()
-    other.mkdir()
-    (workspace / "alpha.txt").write_text("inside", encoding="utf-8")
-    (other / "secret.txt").write_text("outside", encoding="utf-8")
-    monkeypatch.setenv("LEAP_TEST_OUTSIDE", str(other))
-
-    token = set_tool_context(
-        ToolExecutionContext.from_strings(workspace_root=str(workspace), session_id="sess-gate")
-    )
-    try:
-        for command in (
-            "cat $LEAP_TEST_OUTSIDE/secret.txt",
-            "cat ${LEAP_TEST_OUTSIDE}/secret.txt",
-            "cat ../other/secret.txt",
-            "cat --file=$LEAP_TEST_OUTSIDE/secret.txt",
-            "cd $LEAP_TEST_OUTSIDE && cat secret.txt",
-        ):
-            result = asyncio.run(shell_run({"command": command}))
-            assert result["ok"] is False, command
-            assert result["error_type"] == "outside_workspace", command
-            assert result["resolved_path"].startswith(str(other.resolve())), command
-
-        # Traversal that stays inside must still run: the gate judges the resolved
-        # target, so `sub/../alpha.txt` is an ordinary in-workspace read, and the
-        # content must come back. On Windows no cmd-era builtin reads a '..'
-        # operand (Git's MSYS cat falls back to stdin and hangs, cmd's `type`
-        # rejects the path), so the read goes through PowerShell's Get-Content —
-        # as a command argument; the shell backend stays cmd.
-        if os.name == "nt":
-            command = 'powershell -NoProfile -Command "Get-Content sub/../alpha.txt"'
-        else:
-            command = "cat sub/../alpha.txt"
-        inside = asyncio.run(shell_run({"command": command}))
-        assert inside["ok"] is True
-        assert inside["stdout"].strip() == "inside"
-    finally:
-        reset_tool_context(token)
-
-
-def test_shell_gate_allows_search_list_variables(tmp_path, monkeypatch) -> None:
-    """Expanding a variable must not turn ordinary commands into refusals.
-
-    ``$PATH`` expands to an ``os.pathsep``-joined list that begins with ``/`` but
-    names no file. Treating that as a path operand blocked ``echo $PATH`` and
-    ``PATH=$PATH:./bin npm test``, which have nothing to do with the workspace
-    boundary.
-    """
-    from leapflow.tools.execution_context import (
-        ToolExecutionContext,
-        reset_tool_context,
-        set_tool_context,
-    )
-    from leapflow.tools.shell_tools import _command_workspace_escape
-
-    workspace = tmp_path / "work"
-    workspace.mkdir()
-    monkeypatch.setenv("PATH", "/usr/local/bin:/usr/bin:/bin")
-    monkeypatch.setenv("LEAP_TEST_HOME", str(tmp_path / "outside"))
-
-    token = set_tool_context(
-        ToolExecutionContext.from_strings(workspace_root=str(workspace), session_id="sess-list")
-    )
-    try:
-        for command in (
-            "echo $PATH",
-            "export PATH=$PATH:/usr/local/bin && make",
-            "PATH=$PATH:./node_modules/.bin npm test",
-        ):
-            assert _command_workspace_escape(command, cwd=workspace) is None, command
-
-        # A single-path variable must still be gated.
-        blocked = _command_workspace_escape("cat $LEAP_TEST_HOME/secret", cwd=workspace)
-        assert blocked is not None
-        assert blocked["error_type"] == "outside_workspace"
-    finally:
-        reset_tool_context(token)
-
-
-def test_shell_gate_redirects_leapflow_config_targets(tmp_path) -> None:
-    """Refusing a config path must name the capability that serves the goal.
-
-    Without the redirect the model only learns "not here" and moves the same
-    probe to another spelling, which is the loop the config tools exist to end.
-    """
-    from leapflow.tools.execution_context import (
-        ToolExecutionContext,
-        reset_tool_context,
-        set_tool_context,
-    )
-    from leapflow.tools.shell_tools import _command_workspace_escape
-    from leapflow.config import get_settings
-
-    workspace = tmp_path / "work"
-    workspace.mkdir()
-    config_path = get_settings().layout.global_config_dir / "user.yaml"
-
-    token = set_tool_context(
-        ToolExecutionContext.from_strings(workspace_root=str(workspace), session_id="sess-hint")
-    )
-    try:
-        error = _command_workspace_escape(f"cat {config_path}", cwd=workspace)
-    finally:
-        reset_tool_context(token)
-
-    assert error is not None
-    assert error["error_type"] == "outside_workspace"
-    assert "config_get" in error["error"]
-    assert "cannot be lifted by approval" in error["error"]
+"""Tests for P0 tool-calling / result hardening in the agent loop:
+
+- A1: pre-execution required-argument validation (_validate_tool_arguments)
+- B2: structure-aware tool-result truncation (_truncate_result_for_budget)
+
+Both are pure module functions, exercised directly.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+
+from leapflow.engine.engine import (
+    _head_tail_truncate,
+    _truncate_result_for_budget,
+    _validate_tool_arguments,
+)
+from leapflow.tools.name_resolver import ToolSpec
+
+
+def _spec(name: str, required: set[str], params: set[str]) -> ToolSpec:
+    return ToolSpec(name=name, parameters=frozenset(params), required=frozenset(required))
+
+
+# ── A1: argument validation ──────────────────────────────────────────
+
+def test_validate_missing_required_returns_structured_error() -> None:
+    spec = _spec("edit_file", {"path"}, {"path", "edits", "diff"})
+    result = _validate_tool_arguments(spec, {"edits": []})  # path missing
+    assert result is not None
+    assert result["ok"] is False and result["error_type"] == "invalid_arguments"
+    assert result["missing"] == ["path"]
+    assert "path" in result["accepted_parameters"]
+    # Must not penalize failure budgets or trip the batch-stop gate.
+    assert result["counts_as_failure"] is False and result["retryable"] is True
+    assert "execution_policy" not in result
+
+
+def test_validate_present_required_passes() -> None:
+    spec = _spec("edit_file", {"path"}, {"path", "edits"})
+    assert _validate_tool_arguments(spec, {"path": "/x", "edits": []}) is None
+
+
+def test_validate_no_required_is_skipped() -> None:
+    spec = _spec("terminal_list", set(), set())
+    assert _validate_tool_arguments(spec, {}) is None
+
+
+def test_validate_present_but_empty_is_not_missing() -> None:
+    # Presence-only: an empty but present required value is the handler's concern
+    # (e.g. text_replace new="" is a valid delete), not a validation rejection.
+    spec = _spec("text_replace", {"text", "old", "new"}, {"text", "old", "new"})
+    assert _validate_tool_arguments(spec, {"text": "abc", "old": "a", "new": ""}) is None
+
+
+def test_validate_none_spec_is_skipped() -> None:
+    assert _validate_tool_arguments(None, {"anything": 1}) is None
+
+
+# ── B2: structure-aware truncation ───────────────────────────────────
+
+def test_truncate_within_budget_is_unchanged() -> None:
+    payload = {"ok": True, "stdout": "small output"}
+    text = _truncate_result_for_budget(payload, 1000)
+    assert json.loads(text) == payload
+
+
+def test_truncate_preserves_head_and_tail_of_large_field() -> None:
+    payload = {"ok": False, "stdout": "HEAD_MARKER" + ("x" * 6000) + "TAIL_ERROR"}
+    text = _truncate_result_for_budget(payload, 800)
+    assert len(text) <= 800
+    obj = json.loads(text)  # still valid JSON (shrank the field, not the JSON string)
+    assert "TAIL_ERROR" in obj["stdout"]   # the actual error at the tail survives
+    assert "HEAD_MARKER" in obj["stdout"]  # head survives
+    assert "elided" in obj["stdout"]       # explicit elision marker
+
+
+def test_truncate_nondict_payload_is_safe() -> None:
+    text = _truncate_result_for_budget("a very long string " * 100, 50)
+    assert len(text) <= 50
+
+
+def test_head_tail_truncate_keeps_both_ends() -> None:
+    text = "START" + ("m" * 1000) + "END"
+    out = _head_tail_truncate(text, 200)
+    assert out.startswith("START") and out.endswith("END") and "elided" in out
+    assert len(out) < len(text)
+
+
+def test_head_tail_truncate_short_text_unchanged() -> None:
+    assert _head_tail_truncate("short", 200) == "short"
+
+
+def test_truncate_list_field_pruned_and_annotated() -> None:
+    """List fields (e.g. file_list entries) must be pruned, not string-cut."""
+    entries = [{"name": f"file_{i}.py", "type": "file", "size": 1000} for i in range(80)]
+    payload = {"ok": True, "kind": "file_list_evidence", "path": "/proj", "entries": entries, "entry_count": 80}
+    text = _truncate_result_for_budget(payload, 1000)
+    obj = json.loads(text)  # must be valid JSON — not a raw string cut
+    assert obj["ok"] is True
+    assert len(obj["entries"]) < 80           # entries were pruned
+    assert "entries_omitted" in obj           # omission count is explicit
+    assert obj["entries_omitted"] + len(obj["entries"]) == 80
+
+
+def test_truncate_over_budget_dict_never_returns_malformed_json() -> None:
+    """When every shrinking strategy fails, a valid sentinel dict is returned."""
+    # A dict where string truncation alone cannot bring it under budget because
+    # the overhead fields themselves exceed the budget.
+    payload = {"ok": True, "kind": "file_list_evidence", "entries": [], "entry_count": 0,
+               "irreducible": "x" * 100}
+    text = _truncate_result_for_budget(payload, 80)  # budget is tiny
+    # Must parse as JSON (no raw cut)
+    obj = json.loads(text)
+    assert isinstance(obj, dict)
+
+
+def test_compaction_preserves_invalid_argument_repair_hints() -> None:
+    from leapflow.engine.context_control import ToolEvidenceBuilder
+    builder = ToolEvidenceBuilder()
+    invalid = {
+        "ok": False,
+        "error": "Invalid arguments for edit_file: missing required parameter(s): path",
+        "error_type": "invalid_arguments",
+        "missing": ["path"],
+        "accepted_parameters": ["diff", "edits", "path"],
+        "retryable": True,
+        "counts_as_failure": False,
+    }
+    compact = builder.build("edit_file", {}, invalid)
+    assert compact["error_type"] == "invalid_arguments"
+    assert compact["missing"] == ["path"]
+    assert compact["accepted_parameters"] == ["diff", "edits", "path"]
+
+
+def test_compaction_preserves_anchor_not_unique_match_count() -> None:
+    from leapflow.engine.context_control import ToolEvidenceBuilder
+    builder = ToolEvidenceBuilder()
+    result = {"ok": False, "error": "not unique", "error_type": "anchor_not_unique", "match_count": 3}
+    compact = builder.build("edit_file", {}, result)
+    assert compact["error_type"] == "anchor_not_unique" and compact["match_count"] == 3
+
+
+# ── failure visibility: stdout/stderr survive compaction; shell_run sets error ──
+
+def test_compact_error_preserves_shell_output() -> None:
+    """A failed shell result must keep stderr (the traceback) + returncode so the
+    agent can diagnose the cause instead of seeing a bare 'unknown error'."""
+    from leapflow.engine.context_control import ToolEvidenceBuilder
+    builder = ToolEvidenceBuilder()
+    failed = {
+        "ok": False,
+        "returncode": 1,
+        "stdout": "partial output",
+        "stderr": "Traceback (most recent call last):\n  ...\nModuleNotFoundError: No module named 'yfinance'",
+        "error": "ModuleNotFoundError: No module named 'yfinance'",
+    }
+    compact = builder.build("shell_run", {}, failed)
+    assert compact["ok"] is False and compact["returncode"] == 1
+    assert "ModuleNotFoundError" in compact["stderr"]   # traceback preserved
+    assert "yfinance" in compact["error"]
+
+
+def test_compact_error_preserves_stderr_without_error_field() -> None:
+    from leapflow.engine.context_control import ToolEvidenceBuilder
+    builder = ToolEvidenceBuilder()
+    result = {"ok": False, "returncode": 2, "stdout": "", "stderr": "boom: the real error"}
+    compact = builder.build("shell_run", {}, result)
+    assert "boom: the real error" in compact["stderr"] and compact["returncode"] == 2
+
+
+def test_shell_run_populates_error_on_failure() -> None:
+    import os
+
+    from leapflow.tools.shell_tools import shell_run
+    # cmd.exe (the Windows shell backend) has no ';' separator; '&&' works on both.
+    joiner = "&&" if os.name == "nt" else ";"
+    result = asyncio.run(shell_run({"command": f"echo BOOM_ERR 1>&2 {joiner} exit 2"}))
+    assert result["ok"] is False and result["returncode"] == 2
+    assert "BOOM_ERR" in result["error"] and "BOOM_ERR" in result["stderr"]
+
+
+def test_shell_run_success_has_no_error_field() -> None:
+    from leapflow.tools.shell_tools import shell_run
+    result = asyncio.run(shell_run({"command": "echo ok"}))
+    assert result["ok"] is True and "error" not in result and "ok" in result["stdout"]
+
+
+def test_workspace_context_resolves_relative_paths_and_blocks_cross_workspace(tmp_path) -> None:
+    from leapflow.tools.execution_context import (
+        ToolExecutionContext,
+        reset_tool_context,
+        set_tool_context,
+    )
+    from leapflow.tools.file_operations import code_search, file_read
+    from leapflow.tools.repo_map import repo_map
+    from leapflow.tools.shell_tools import shell_run
+
+    workspace = tmp_path / "work"
+    other = tmp_path / "other"
+    workspace.mkdir()
+    other.mkdir()
+    (workspace / "alpha.txt").write_text("needle in workspace", encoding="utf-8")
+    (other / "secret.txt").write_text("needle outside", encoding="utf-8")
+
+    token = set_tool_context(
+        ToolExecutionContext.from_strings(
+            workspace_root=str(workspace),
+            session_id="sess-work",
+            task_id="turn-test",
+        )
+    )
+    try:
+        read_result = asyncio.run(file_read({"path": "alpha.txt"}))
+        assert read_result["ok"] is True
+        assert read_result["path"] == str((workspace / "alpha.txt").resolve())
+
+        search_result = asyncio.run(code_search({"pattern": "needle", "path": "."}))
+        assert search_result["ok"] is True
+        assert search_result["path"] == str(workspace.resolve())
+        assert search_result["match_count"] == 1
+
+        repo_result = asyncio.run(repo_map({"path": "."}))
+        assert repo_result["ok"] is True
+        assert repo_result["root"] == str(workspace.resolve())
+
+        pwd_command = "echo %CD%" if os.name == "nt" else "pwd"
+        shell_result = asyncio.run(shell_run({"command": pwd_command}))
+        assert shell_result["ok"] is True, shell_result
+        assert shell_result["cwd"] == str(workspace.resolve())
+
+        blocked = asyncio.run(file_read({"path": str(other / "secret.txt")}))
+        assert blocked["ok"] is False
+        assert blocked["error_type"] == "outside_workspace"
+        assert blocked["workspace_root"] == str(workspace.resolve())
+
+        blocked_shell = asyncio.run(shell_run({"command": f"cat {other / 'secret.txt'}"}))
+        assert blocked_shell["ok"] is False
+        assert blocked_shell["error_type"] == "outside_workspace"
+        assert blocked_shell["workspace_root"] == str(workspace.resolve())
+    finally:
+        reset_tool_context(token)
+
+
+def test_shell_gate_blocks_expanded_and_relative_escapes(tmp_path, monkeypatch) -> None:
+    """The gate must judge the resolved target, not how the operand is spelled.
+
+    A guard that only inspects literal ``/``/``~`` operands passes ``$HOME/...``
+    and ``../../..`` straight through, so the same file is reachable by choosing
+    a different spelling and the workspace boundary stops being a boundary.
+    """
+    from leapflow.tools.execution_context import (
+        ToolExecutionContext,
+        reset_tool_context,
+        set_tool_context,
+    )
+    from leapflow.tools.shell_tools import shell_run
+
+    import os
+
+    workspace = tmp_path / "work"
+    other = tmp_path / "other"
+    workspace.mkdir()
+    (workspace / "sub").mkdir()
+    other.mkdir()
+    (workspace / "alpha.txt").write_text("inside", encoding="utf-8")
+    (other / "secret.txt").write_text("outside", encoding="utf-8")
+    monkeypatch.setenv("LEAP_TEST_OUTSIDE", str(other))
+
+    token = set_tool_context(
+        ToolExecutionContext.from_strings(workspace_root=str(workspace), session_id="sess-gate")
+    )
+    try:
+        for command in (
+            "cat $LEAP_TEST_OUTSIDE/secret.txt",
+            "cat ${LEAP_TEST_OUTSIDE}/secret.txt",
+            "cat ../other/secret.txt",
+            "cat --file=$LEAP_TEST_OUTSIDE/secret.txt",
+            "cd $LEAP_TEST_OUTSIDE && cat secret.txt",
+        ):
+            result = asyncio.run(shell_run({"command": command}))
+            assert result["ok"] is False, command
+            assert result["error_type"] == "outside_workspace", command
+            assert result["resolved_path"].startswith(str(other.resolve())), command
+
+        # Traversal that stays inside must still run: the gate judges the resolved
+        # target, so `sub/../alpha.txt` is an ordinary in-workspace read, and the
+        # content must come back. On Windows no cmd-era builtin reads a '..'
+        # operand (Git's MSYS cat falls back to stdin and hangs, cmd's `type`
+        # rejects the path), so the read goes through PowerShell's Get-Content —
+        # as a command argument; the shell backend stays cmd.
+        if os.name == "nt":
+            command = 'powershell -NoProfile -Command "Get-Content sub/../alpha.txt"'
+        else:
+            command = "cat sub/../alpha.txt"
+        inside = asyncio.run(shell_run({"command": command}))
+        assert inside["ok"] is True
+        assert inside["stdout"].strip() == "inside"
+    finally:
+        reset_tool_context(token)
+
+
+def test_shell_gate_allows_search_list_variables(tmp_path, monkeypatch) -> None:
+    """Expanding a variable must not turn ordinary commands into refusals.
+
+    ``$PATH`` expands to an ``os.pathsep``-joined list that begins with ``/`` but
+    names no file. Treating that as a path operand blocked ``echo $PATH`` and
+    ``PATH=$PATH:./bin npm test``, which have nothing to do with the workspace
+    boundary.
+    """
+    from leapflow.tools.execution_context import (
+        ToolExecutionContext,
+        reset_tool_context,
+        set_tool_context,
+    )
+    from leapflow.tools.shell_tools import _command_workspace_escape
+
+    workspace = tmp_path / "work"
+    workspace.mkdir()
+    monkeypatch.setenv("PATH", "/usr/local/bin:/usr/bin:/bin")
+    monkeypatch.setenv("LEAP_TEST_HOME", str(tmp_path / "outside"))
+
+    token = set_tool_context(
+        ToolExecutionContext.from_strings(workspace_root=str(workspace), session_id="sess-list")
+    )
+    try:
+        for command in (
+            "echo $PATH",
+            "export PATH=$PATH:/usr/local/bin && make",
+            "PATH=$PATH:./node_modules/.bin npm test",
+        ):
+            assert _command_workspace_escape(command, cwd=workspace) is None, command
+
+        # A single-path variable must still be gated.
+        blocked = _command_workspace_escape("cat $LEAP_TEST_HOME/secret", cwd=workspace)
+        assert blocked is not None
+        assert blocked["error_type"] == "outside_workspace"
+    finally:
+        reset_tool_context(token)
+
+
+def test_shell_gate_redirects_leapflow_config_targets(tmp_path) -> None:
+    """Refusing a config path must name the capability that serves the goal.
+
+    Without the redirect the model only learns "not here" and moves the same
+    probe to another spelling, which is the loop the config tools exist to end.
+    """
+    from leapflow.tools.execution_context import (
+        ToolExecutionContext,
+        reset_tool_context,
+        set_tool_context,
+    )
+    from leapflow.tools.shell_tools import _command_workspace_escape
+    from leapflow.config import get_settings
+
+    workspace = tmp_path / "work"
+    workspace.mkdir()
+    config_path = get_settings().layout.global_config_dir / "user.yaml"
+
+    token = set_tool_context(
+        ToolExecutionContext.from_strings(workspace_root=str(workspace), session_id="sess-hint")
+    )
+    try:
+        error = _command_workspace_escape(f"cat {config_path}", cwd=workspace)
+    finally:
+        reset_tool_context(token)
+
+    assert error is not None
+    assert error["error_type"] == "outside_workspace"
+    assert "config_get" in error["error"]
+    assert "cannot be lifted by approval" in error["error"]

From 1e181ede1c19b138e15a1142e169342c1606c2e6 Mon Sep 17 00:00:00 2001
From: fanqiNO1 <1848839264@qq.com>
Date: Fri, 7 Aug 2026 13:33:14 +0800
Subject: [PATCH 4/4] scale heartbeat test timing for slow CI runners

---
 tests/test_daemon_rpc.py | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/tests/test_daemon_rpc.py b/tests/test_daemon_rpc.py
index 54adccd..2eb97a1 100644
--- a/tests/test_daemon_rpc.py
+++ b/tests/test_daemon_rpc.py
@@ -76,8 +76,12 @@ async def engine_chat(self, message: str, **kwargs: Any) -> AsyncIterator[Stream
 
 
 class _SlowFirstChunkService(_FakeService):
+    def __init__(self, first_chunk_delay: float = 0.16) -> None:
+        super().__init__()
+        self._first_chunk_delay = first_chunk_delay
+
     async def engine_chat(self, message: str, **kwargs: Any) -> AsyncIterator[StreamChunk]:
-        await asyncio.sleep(0.16)
+        await asyncio.sleep(self._first_chunk_delay)
         yield StreamChunk(request_id="", content=f"slow {message}", event_type="chunk")
         yield StreamChunk(request_id="", content="done", event_type="final")
 
@@ -617,11 +621,14 @@ async def test_daemon_client_stream_heartbeat_prevents_idle_timeout() -> None:
     with tempfile.TemporaryDirectory(prefix="lfd-", dir=_short_tempdir()) as root:
         server, task, runtime_dir = await _start_server(
             Path(root) / "runtime",
-            service=_SlowFirstChunkService(),
-            stream_heartbeat_s=0.03,
+            service=_SlowFirstChunkService(first_chunk_delay=0.6),
+            stream_heartbeat_s=0.1,
         )
         socket_path = get_transport().readiness_path(runtime_dir)
-        client = DaemonClient(socket_path, timeout_s=0.1)
+        # The read timeout must stay smaller than the first-chunk delay (so an
+        # idle stream would die) but large enough that slow CI dispatch latency
+        # cannot starve the first heartbeat; 0.3s keeps both invariants.
+        client = DaemonClient(socket_path, timeout_s=0.3)
 
         try:
             events = [event async for event in client.engine_chat("world")]