soothe-cli 0.10.2__tar.gz → 0.10.4__tar.gz

{soothe_cli-0.10.2 → soothe_cli-0.10.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.10.2
+Version: 0.10.4
 Summary: Soothe CLI client - communicates with daemon via WebSocket
 Project-URL: Homepage, https://github.com/mirasoth/soothe
 Project-URL: Documentation, https://soothe.readthedocs.io
@@ -14,16 +14,15 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: <3.15,>=3.11
+Requires-Python: <3.14,>=3.11
 Requires-Dist: pillow<12.0.0,>=10.0.0
 Requires-Dist: python-dotenv<2.0.0,>=1.0.0
 Requires-Dist: pyyaml<7.0.0,>=6.0.0
 Requires-Dist: rich<15.0.0,>=13.0.0
-Requires-Dist: soothe-client-python<2.0.0,>=1.0.12
-Requires-Dist: soothe-sdk<2.0.0,>=1.0.7
+Requires-Dist: soothe-client-python<2.0.0,>=1.0.15
+Requires-Dist: soothe-sdk<2.0.0,>=1.0.8
 Requires-Dist: termaid<1.0.0,>=0.7.1
 Requires-Dist: textual<10.0.0,>=8.0.0
 Requires-Dist: typer<2.0.0,>=0.9.0

{soothe_cli-0.10.2 → soothe_cli-0.10.4}/pyproject.toml

@@ -8,7 +8,7 @@ dynamic = ["version"]
 description = "Soothe CLI client - communicates with daemon via WebSocket"
 readme = "README.md"
 license = { text = "MIT" }
-requires-python = ">=3.11,<3.15"
+requires-python = ">=3.11,<3.14"
 keywords = ["soothe", "cli", "client", "tui", "websocket"]
 classifiers = [
     "Development Status :: 3 - Alpha",
@@ -18,13 +18,12 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
-    "Programming Language :: Python :: 3.14",
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
     "Topic :: Software Development :: Libraries :: Python Modules",
 ]
 dependencies = [
-    "soothe-sdk>=1.0.7,<2.0.0",    # events/display/wire contracts
-    "soothe-client-python>=1.0.12,<2.0.0",  # WebSocket transport client; matched to latest release v1.0.12
+    "soothe-sdk>=1.0.8,<2.0.0",    # events/display/wire contracts
+    "soothe-client-python>=1.0.15,<2.0.0",  # WebSocket transport client; matched to latest release v1.0.15
     "typer>=0.9.0,<2.0.0",          # CLI framework
     "textual>=8.0.0,<10.0.0",       # TUI framework
     "rich>=13.0.0,<15.0.0",         # Console output

{soothe_cli-0.10.2 → soothe_cli-0.10.4}/src/soothe_cli/cli/commands/autopilot_cmd.py

@@ -66,7 +66,8 @@ _STYLE_METRIC_RAIL = "bold bright_green"
 # Compact description previews at the row tail so metrics stay visible first.
 _TOP_DESC_JOB = 32
 _TOP_DESC_GOAL = 32
-_TOP_DESC_STEP = 28
+# Steps can show a bit more than job/goal: deps trail after the desc (`→id`).
+_TOP_DESC_STEP = 40
 _STATUS_STYLE: dict[str, str] = {
     "active": _STYLE_ACTIVE,
     "pending": "yellow",
@@ -560,6 +561,43 @@ def resume_goal(
     typer.echo(f"Goal resumed: {resumed_id[:8]} → {result.get('new_status', 'pending')}")
 
 
+@app.command("guide")
+def guide_job(
+    job_id: str = typer.Argument(..., help="Job (root goal) ID."),
+    text: str = typer.Argument(..., help="Guidance text for the next Autopilot dispatch."),
+    goal_id: str | None = typer.Option(
+        None,
+        "--goal",
+        "-g",
+        help="Optional goal under the job (default: job-root / job-wide scope).",
+    ),
+) -> None:
+    """Absorb operator guidance into ContextEngine (does not create goals).
+
+    Text is stored on the job/goal for Autopilot cognition and applied on the
+    next worker dispatch. It does not spawn or inject new goals.
+    """
+    cleaned = (text or "").strip()
+    if not cleaned:
+        typer.echo("Guidance text must be non-empty.", err=True)
+        raise typer.Exit(1)
+    client = _require_daemon_ws()
+    try:
+        result = client.job_guidance(job_id, cleaned, goal_id=goal_id)
+    except RuntimeError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(1) from exc
+    absorbed = bool(result.get("absorbed"))
+    target = str(result.get("goal_id") or goal_id or job_id)
+    if not absorbed:
+        typer.echo(
+            f"Guidance not absorbed for job {job_id[:8]} goal {target[:8]}.",
+            err=True,
+        )
+        raise typer.Exit(1)
+    typer.echo(f"Guidance absorbed: job {job_id[:8]} → goal {target[:8]}")
+
+
 def _short_loop_id(loop_id: str, *, head: int = 4, tail: int = 4) -> str:
     """Shorten loop ids as ``prefix…suffix`` (4 chars each by default)."""
     text = str(loop_id or "")

{soothe_cli-0.10.2 → soothe_cli-0.10.4}/src/soothe_cli/cli/commands/cron_cmd.py

@@ -29,7 +29,10 @@ from soothe_client import (
 
 from soothe_cli.runtime import load_config
 
-console = Console()
+# Rich reads width from the TTY; under CI / test runners (no TTY) it falls back
+# to a narrow default that truncates the Job ID column. Use a comfortable fixed
+# width when stdout is not interactive so IDs render in full.
+console = Console() if sys.stdout.isatty() else Console(width=100)
 
 app = typer.Typer(help="Manage scheduled cron jobs — natural language scheduled tasks.")
 
@@ -148,7 +151,7 @@ def list_jobs(
         return
 
     table = Table(title="Scheduled Jobs")
-    table.add_column("Job ID", style="cyan", width=12)
+    table.add_column("Job ID", style="cyan", no_wrap=True, width=12)
     table.add_column("Description", width=40)
     table.add_column("Status", style="green", width=10)
     table.add_column("Next Run", style="yellow", width=20)
@@ -156,8 +159,8 @@ def list_jobs(
 
     for job in jobs:
         desc = job.get("description", "")
-        if len(desc) > 40:
-            desc = desc[:37] + "..."
+        if len(desc) > 28:
+            desc = desc[:25] + "..."
         table.add_row(
             job.get("id", "?")[:12],
             desc,

{soothe_cli-0.10.2 → soothe_cli-0.10.4}/src/soothe_cli/cli/execution/daemon_errors.py

@@ -23,6 +23,15 @@ _FRIENDLY_DAEMON_CONNECTION_LOST = (
     "Send your message again to reconnect and continue this loop."
 )
 
+# Partial match for the attach-only idle timeout raised by ``iter_turn_chunks``
+# when a stale ``live`` probe attaches to a loop whose runner already exited.
+ATTACH_IDLE_TIMEOUT_MARKER = "attach window"
+
+_FRIENDLY_ATTACH_IDLE_TIMEOUT = (
+    "No follow-on turn started within the attach window; the prior turn had "
+    "already completed. Ready for your next message."
+)
+
 
 def is_daemon_connection_error(exc: BaseException | str) -> bool:
     """Return whether an error indicates the daemon WebSocket is unavailable."""
@@ -51,6 +60,8 @@ def friendly_daemon_execution_error(exc: BaseException | str) -> str:
     """Map known daemon failures to concise, actionable copy."""
     if is_daemon_connection_error(exc):
         return _FRIENDLY_DAEMON_CONNECTION_LOST
+    if is_attach_idle_timeout(exc):
+        return _FRIENDLY_ATTACH_IDLE_TIMEOUT
     if isinstance(exc, RuntimeError) and DAEMON_WORKER_SUBPROCESS_LOST in str(exc):
         return _FRIENDLY_WORKER_SUBPROCESS_LOST
     if isinstance(exc, RuntimeError) and DAEMON_WORKER_THREAD_LOST in str(exc):
@@ -73,3 +84,12 @@ def is_daemon_worker_thread_lost(exc: BaseException | str) -> bool:
     """Return whether an error indicates a pool worker thread exited mid-query."""
     text = str(exc)
     return DAEMON_WORKER_THREAD_LOST in text
+
+
+def is_attach_idle_timeout(exc: BaseException | str) -> bool:
+    """Return whether an error is the attach-only idle timeout.
+
+    Raised by ``iter_turn_chunks`` when a stale ``live`` probe attached to a
+    loop whose runner had already exited (no follow-on turn materialized).
+    """
+    return ATTACH_IDLE_TIMEOUT_MARKER in str(exc)

{soothe_cli-0.10.2 → soothe_cli-0.10.4}/src/soothe_cli/cli/main.py

@@ -217,11 +217,12 @@ def main(
         typer.Option(
             "--plan-panel/--no-plan-panel",
             help=(
-                "Auto-show the in-flow plan panel when a goal plan is active. "
-                "Ctrl+t toggles thereafter. Default: disabled."
+                "Auto-show the in-flow plan panel while a goal is executing "
+                "and hide it when the goal completes. Ctrl+t toggles "
+                "thereafter. Default: enabled."
             ),
         ),
-    ] = False,
+    ] = True,
     show_version: Annotated[  # noqa: FBT002
         bool,
         typer.Option("--version", help="Show version and exit."),

{soothe_cli-0.10.2 → soothe_cli-0.10.4}/src/soothe_cli/config/cli_config.py

@@ -33,8 +33,9 @@ class CLIConfig:
     """Markdown appearance preset (``match-app``, ``langchain``, ``standard``, …)."""
 
     # Plan panel visibility preference
-    plan_panel_default_visible: bool = False
-    """Auto-show the in-flow plan panel when a goal plan is active. Ctrl+t toggles."""
+    plan_panel_default_visible: bool = True
+    """Auto-show the in-flow plan panel while a goal is executing and hide it
+    when the goal completes. Ctrl+t toggles the panel thereafter."""
 
     # Output streaming overrides (RFC-614)
     output_streaming_enabled: bool | None = None

{soothe_cli-0.10.2 → soothe_cli-0.10.4}/src/soothe_cli/tui/app/_app.py

@@ -477,9 +477,10 @@ class SootheApp(
                 )
                 yield Container(id="messages")
         # In-flow plan panel: sits above the sticky bottom chrome so Ctrl+t
-        # never covers the thinking row or chat input. Auto-shows when a plan
-        # is active if CLIConfig.plan_panel_default_visible is True.
-        plan_visible = getattr(self._daemon_config, "plan_panel_default_visible", False)
+        # never covers the thinking row or chat input. Auto-shows while a goal
+        # is executing and auto-hides when it completes (default) unless
+        # CLIConfig.plan_panel_default_visible is False.
+        plan_visible = getattr(self._daemon_config, "plan_panel_default_visible", True)
         yield PlanQuickViewOverlay(
             id="plan-quick-view-overlay",
             default_visible=plan_visible,

{soothe_cli-0.10.2 → soothe_cli-0.10.4}/src/soothe_cli/tui/app/_execution.py

@@ -20,6 +20,7 @@ from textual.style import Style as TStyle
 
 from soothe_cli.cli.execution.daemon_errors import (
     friendly_daemon_connection_error,
+    is_attach_idle_timeout,
     is_daemon_connection_error,
 )
 from soothe_cli.cli.execution.daemon_errors import (
@@ -271,6 +272,15 @@ class _ExecutionMixin:
         non_empty = [a for a in event.answers if a.strip()]
         if not non_empty:
             return
+
+        # When a plan is approved for execution, switch composer mode to Auto
+        # so subsequent turns use standard loop routing without planner hint.
+        first_answer = str(event.answers[0]).strip() if event.answers else ""
+        if first_answer == "Approve":
+            self._composer_mode = "auto"
+            if self._status_bar is not None:
+                self._status_bar.set_clarification_mode("auto")
+
         # Send the answers as a structured list so the daemon resumes the
         # graph with one answer per question instead of broadcasting a single
         # concatenated string. ``content`` carries a human-readable summary
@@ -848,6 +858,51 @@ class _ExecutionMixin:
         else:
             await self._mount_message(AppMessage("Agent not configured for this session."))
 
+    async def _daemon_loop_is_live(self) -> bool:
+        """Return True when the subscribed daemon loop has a live runner now.
+
+        Used to attach with ``skip_daemon_send_turn`` instead of enqueueing a
+        duplicate ``loop_input`` (stale-reader / ghost follow-on goals).
+
+        The active-runner signal (``active_runner``) is authoritative: a loop's
+        metadata ``status`` field can lag ``"running"`` for up to the 5-minute
+        reconciliation window after its runner exits, so status alone produces
+        false positives that leave the TUI attached to a phantom follow-on turn
+        for minutes. When the daemon exposes ``active_runner`` we require it;
+        only as a fallback for daemons without the field do we fall back to the
+        status check, and even then we treat a ``None`` (unknown) signal as
+        not-live to avoid the stale-status hang.
+        """
+        session = self._daemon_session
+        state = self._session_state
+        if session is None or state is None:
+            return False
+        loop_id = str(getattr(state, "loop_id", "") or "").strip()
+        if not loop_id:
+            return False
+        try:
+            exec_state = await session.fetch_execution_state(loop_id)
+        except Exception:
+            logger.debug("live probe via fetch_execution_state failed", exc_info=True)
+            return False
+        status = str(getattr(exec_state, "status", "") or "").strip().lower()
+        if status != "running":
+            return False
+        active_runner = getattr(exec_state, "active_runner", None)
+        if active_runner is True:
+            return True
+        # ``None`` = daemon older than the field, or probe failed. Only then do
+        # we consult the card-ledger live-goal index — and only as a weak hint
+        # that still requires status=="running" (already checked above).
+        if active_runner is None:
+            try:
+                history = await session.fetch_loop_history(loop_id)
+                if getattr(history, "live_goal_index", None) is not None:
+                    return True
+            except Exception:
+                logger.debug("live probe via fetch_loop_history failed", exc_info=True)
+        return False
+
     async def _run_agent_task(
         self,
         message: str,
@@ -883,6 +938,14 @@ class _ExecutionMixin:
         try:
             for attempt in (1, 2):
                 try:
+                    attach_only = skip_daemon_send_turn
+                    if (
+                        not attach_only
+                        and self._daemon_session is not None
+                        and await self._daemon_loop_is_live()
+                    ):
+                        attach_only = True
+                        logger.info("Daemon loop already live; attaching without send_turn")
                     await execute_task_textual(
                         user_input=message,
                         daemon_session=self._daemon_session,
@@ -898,7 +961,7 @@ class _ExecutionMixin:
                             router_profile=self._router_profile_override,
                         ),
                         turn_stats=turn_stats,
-                        skip_daemon_send_turn=skip_daemon_send_turn,
+                        skip_daemon_send_turn=attach_only,
                         clarification_mode=wire_clar,
                         sticky_preferred_subagent=sticky_subagent,
                         is_shutting_down=lambda: getattr(self, "_exit", False),
@@ -923,23 +986,40 @@ class _ExecutionMixin:
                             pass
                     raise
         except Exception as e:  # Resilient tool rendering
-            logger.exception("Agent execution failed")
-            if is_daemon_connection_error(e):
-                display_err = friendly_daemon_connection_error(e)
-                error_title = "Daemon connection error"
+            # Attach-only idle timeout is benign: the prior turn had already
+            # completed and no follow-on turn materialized. Surface it as an
+            # informational message (not a red error) and fall through to
+            # normal cleanup so the TUI returns to a ready state.
+            if is_attach_idle_timeout(e):
+                logger.info("Attach-only idle timeout: no follow-on turn; returning to ready")
+                try:
+                    await self._mount_message(AppMessage(_friendly_agent_execution_error(e)))
+                except Exception:
+                    logger.debug(
+                        "Could not mount attach-timeout message (app closing?)", exc_info=True
+                    )
             else:
-                display_err = _friendly_agent_execution_error(e)
-                error_title = "Agent error"
-            # Ensure any in-flight tool calls don't remain stuck in "Running..."
-            # when streaming aborts before tool results arrive.
-            if self._ui_adapter:
-                self._ui_adapter.finalize_pending_tools_with_error(f"{error_title}: {display_err}")
-                self._ui_adapter.finalize_pending_steps_with_error(f"{error_title}: {display_err}")
-            await self._try_recover_goal_completion_from_ledger()
-            try:
-                await self._mount_message(ErrorMessage(f"{error_title}. {display_err}"))
-            except Exception:
-                logger.debug("Could not mount error message (app closing?)", exc_info=True)
+                logger.exception("Agent execution failed")
+                if is_daemon_connection_error(e):
+                    display_err = friendly_daemon_connection_error(e)
+                    error_title = "Daemon connection error"
+                else:
+                    display_err = _friendly_agent_execution_error(e)
+                    error_title = "Agent error"
+                # Ensure any in-flight tool calls don't remain stuck in "Running..."
+                # when streaming aborts before tool results arrive.
+                if self._ui_adapter:
+                    self._ui_adapter.finalize_pending_tools_with_error(
+                        f"{error_title}: {display_err}"
+                    )
+                    self._ui_adapter.finalize_pending_steps_with_error(
+                        f"{error_title}: {display_err}"
+                    )
+                await self._try_recover_goal_completion_from_ledger()
+                try:
+                    await self._mount_message(ErrorMessage(f"{error_title}. {display_err}"))
+                except Exception:
+                    logger.debug("Could not mount error message (app closing?)", exc_info=True)
         finally:
             # Merge turn stats before cleanup — _cleanup_agent_task may raise
             # during teardown (widget removal on a torn-down DOM), and stats
@@ -1049,5 +1129,42 @@ class _ExecutionMixin:
                     )
                 )
 
+        # If the daemon already admitted a follow-on goal (serial input queue /
+        # successor turn), re-attach without sending another loop_input.
+        if (
+            not self._exit
+            and self._daemon_session is not None
+            and self._ui_adapter is not None
+            and self._runtime_backend_ready()
+            and await self._daemon_loop_is_live()
+        ):
+            await self._attach_to_live_daemon_turn()
+            return
+
         # Process next message from queue if any
         await self._process_next_from_queue()
+
+    async def _attach_to_live_daemon_turn(self) -> None:
+        """Attach the TUI reader to an already-running daemon turn.
+
+        When a local queue head exists, mount it as the user echo then attach
+        with ``skip_daemon_send_turn`` (prompt already on the daemon). Otherwise
+        attach with an empty prompt so activity keeps streaming.
+        """
+        prompt = ""
+        if self._pending_messages:
+            msg = self._pending_messages.popleft()
+            prompt = msg.text
+            if self._queued_widgets:
+                widget = self._queued_widgets.popleft()
+                with suppress(Exception):
+                    await widget.remove()
+                self._refresh_queued_goal_tips()
+            if msg.mode != "normal":
+                # Shell/command still need their normal handlers.
+                await self._process_message(msg.text, msg.mode)
+                return
+            if prompt.strip():
+                await self._mount_message(UserMessage(prompt))
+        logger.info("Attaching TUI to live daemon turn (skip send_turn)")
+        await self._send_to_agent(prompt, skip_daemon_send_turn=True)

{soothe_cli-0.10.2 → soothe_cli-0.10.4}/src/soothe_cli/tui/command_registry.py

@@ -34,6 +34,19 @@ class BypassTier(StrEnum):
     """Must wait in the queue when the app is busy."""
 
 
+class EnterAction(StrEnum):
+    """How Enter behaves when a slash autocomplete suggestion is selected.
+
+    Tab always completes without submitting. Click also completes only.
+    """
+
+    EXECUTE = "execute"
+    """One-stage: insert the command token and submit immediately."""
+
+    COMPLETE = "complete"
+    """Two-stage: insert the command token (with trailing space) for more typing."""
+
+
 @dataclass(frozen=True, slots=True, kw_only=True)
 class SlashCommand:
     """A single slash-command definition."""
@@ -53,6 +66,9 @@ class SlashCommand:
     aliases: tuple[str, ...] = ()
     """Alternative names (e.g. `("/q",)` for `/quit`)."""
 
+    enter_action: EnterAction = EnterAction.EXECUTE
+    """Enter key behavior when completing this command from autocomplete."""
+
 
 COMMANDS: tuple[SlashCommand, ...] = (
     SlashCommand(
@@ -60,12 +76,14 @@ COMMANDS: tuple[SlashCommand, ...] = (
         description="Submit autopilot job (usage: /autopilot <task>)",
         bypass_tier=BypassTier.QUEUED,
         hidden_keywords="goals autonomous job submit",
+        enter_action=EnterAction.COMPLETE,
     ),
     SlashCommand(
         name="/cron",
         description="Add scheduled job (usage: /cron <natural language>)",
         bypass_tier=BypassTier.QUEUED,
         hidden_keywords="schedule timer reminder",
+        enter_action=EnterAction.COMPLETE,
     ),
     SlashCommand(
         name="/clear",
@@ -124,22 +142,26 @@ COMMANDS: tuple[SlashCommand, ...] = (
         name="/deep_research",
         description="Route prompt to deep_research subagent (usage: /deep_research <query>)",
         bypass_tier=BypassTier.QUEUED,
+        enter_action=EnterAction.COMPLETE,
     ),
     SlashCommand(
         name="/academic_research",
         description="Route prompt to academic_research subagent (usage: /academic_research <query>)",
         bypass_tier=BypassTier.QUEUED,
+        enter_action=EnterAction.COMPLETE,
     ),
     SlashCommand(
         name="/browser_use",
         description="Route prompt to browser_use subagent (usage: /browser_use <task>)",
         bypass_tier=BypassTier.QUEUED,
         hidden_keywords="browser automation web",
+        enter_action=EnterAction.COMPLETE,
     ),
     SlashCommand(
         name="/plan",
         description="Send input in plan mode (usage: /plan or /plan <prompt>)",
         bypass_tier=BypassTier.QUEUED,
+        enter_action=EnterAction.COMPLETE,
     ),
     SlashCommand(
         name="/reload",
@@ -229,6 +251,29 @@ def resolve_command_head(command: str) -> str:
     return _ALIAS_TO_CANONICAL.get(head, head)
 
 
+_CANONICAL_ENTER_ACTION: dict[str, EnterAction] = {cmd.name: cmd.enter_action for cmd in COMMANDS}
+
+
+def enter_action_for(command: str) -> EnterAction:
+    """Resolve Enter autocomplete behavior for a completed slash token.
+
+    Dynamic skill rows (`/skill:<name>`) always use two-stage complete so the
+    operator can append arguments before submitting.
+
+    Args:
+        command: Completed suggestion label (e.g. ``/clear`` or ``/skill:foo``).
+
+    Returns:
+        `EnterAction.EXECUTE` for one-stage submit, or `EnterAction.COMPLETE`
+        for insert-only. Unknown static commands default to execute.
+    """
+    stripped = command.strip()
+    if stripped.startswith(("/skill:", "/skills:")):
+        return EnterAction.COMPLETE
+    head = resolve_command_head(stripped)
+    return _CANONICAL_ENTER_ACTION.get(head, EnterAction.EXECUTE)
+
+
 # ---------------------------------------------------------------------------
 # Derived bypass-tier frozensets
 # ---------------------------------------------------------------------------
@@ -299,15 +344,6 @@ def parse_skill_command(command: str) -> tuple[str, str]:
     return skill_name, args
 
 
-_STATIC_SKILL_ALIASES: frozenset[str] = frozenset()
-"""Skill names that have a dedicated top-level slash command in `COMMANDS`.
-
-Only list skills whose `/skill:<name>` autocomplete entry is redundant because
-a `/<name>` convenience alias exists. Do **not** add every command name here —
-that would suppress unrelated user skills that share a name with a slash command.
-"""
-
-
 def build_skill_commands_from_wire(
     rows: list[dict[str, Any]],
 ) -> list[tuple[str, str, str]]:
@@ -322,7 +358,7 @@ def build_skill_commands_from_wire(
     tuples: list[tuple[str, str, str]] = []
     for row in rows:
         name = str(row.get("name", "")).strip().lower()
-        if not name or name in _STATIC_SKILL_ALIASES:
+        if not name:
             continue
         desc = str(row.get("description", "")).strip()
         tuples.append((f"/skill:{name}", desc, name))
@@ -338,17 +374,10 @@ def build_skill_commands(
     Each skill becomes a `/skill:<name>` entry with its description
     and the skill name as a hidden keyword for fuzzy matching.
 
-    Skills listed in `_STATIC_SKILL_ALIASES` are excluded to avoid duplicate
-    autocomplete entries when a top-level alias exists.
-
     Args:
         skills: List of discovered skill metadata.
 
     Returns:
         List of `(name, description, hidden_keywords)` tuples.
     """
-    return [
-        (f"/skill:{skill['name']}", skill["description"], skill["name"])
-        for skill in skills
-        if skill["name"] not in _STATIC_SKILL_ALIASES
-    ]
+    return [(f"/skill:{skill['name']}", skill["description"], skill["name"]) for skill in skills]

{soothe_cli-0.10.2 → soothe_cli-0.10.4}/src/soothe_cli/tui/commands/slash_commands.py

@@ -153,6 +153,8 @@ def show_cron_add(console: Console, data: dict[str, Any]) -> None:
 # ---------------------------------------------------------------------------
 
 KEYBOARD_SHORTCUTS: dict[str, str] = {
+    "Enter": "Submit message; with slash suggestions, run or fill for more input",
+    "Tab": "Accept slash or @ file autocomplete (never submits)",
     "Esc": "Dismiss modal, plan overlay, or autocomplete",
     "Ctrl+D": "Type exit, quit, or /quit to exit the TUI",
     "Ctrl+C": "Clear input or interrupt running agent/shell",

{soothe_cli-0.10.2 → soothe_cli-0.10.4}/src/soothe_cli/tui/textual_adapter.py

@@ -535,6 +535,15 @@ _EXECUTE_WAVE_UI_COALESCE_SEC = 0.2
 _CHUNK_YIELD_INTERVAL = 12
 _CHUNK_YIELD_BUDGET_SEC = 0.016
 
+# Hard cap on how long an attach-only read (``skip_daemon_send_turn``) waits
+# for the first progress event before giving up. A stale ``live`` probe can
+# leave the TUI attached to a phantom follow-on turn whose runner already
+# exited; without this bound the thinking row spins for minutes until the
+# daemon's 5-minute status reconciliation catches up. ``TimeoutError`` raised
+# here is caught by the normal agent-execution error path, which falls back to
+# ``_process_next_from_queue``.
+_ATTACH_ONLY_IDLE_TIMEOUT_S = 45.0
+
 
 class TurnToolUiCoalescer:
     """Batch tool-card repaints, dedupe wire kwargs, and yield during dense streams."""
@@ -3139,7 +3148,9 @@ async def execute_task_textual(
         adapter._clarification_answers_pending = None
     try:
         if skip_daemon_send_turn:
-            chunk_source = daemon_session.iter_turn_chunks()
+            chunk_source = daemon_session.iter_turn_chunks(
+                idle_timeout_s=_ATTACH_ONLY_IDLE_TIMEOUT_S
+            )
         else:
             subagent_name, routed_text = parse_subagent_from_input(final_input)
             if subagent_name is None and sticky_preferred_subagent:

{soothe_cli-0.10.2 → soothe_cli-0.10.4}/src/soothe_cli/tui/widgets/autocomplete.py

@@ -17,6 +17,7 @@ from enum import StrEnum
 from pathlib import Path
 from typing import TYPE_CHECKING, Protocol
 
+from soothe_cli.tui.command_registry import EnterAction, enter_action_for
 from soothe_cli.tui.path_utils import path_is_file
 from soothe_cli.tui.project_utils import find_project_root
 
@@ -39,7 +40,7 @@ class CompletionResult(StrEnum):
 
     IGNORED = "ignored"  # Key not handled, let default behavior proceed
     HANDLED = "handled"  # Key handled, prevent default
-    SUBMIT = "submit"  # Key triggers submission (e.g., Enter on slash command)
+    SUBMIT = "submit"  # Complete + submit (one-stage slash Enter)
 
 
 class CompletionView(Protocol):
@@ -235,6 +236,10 @@ class SlashCommandController:
     def on_key(self, event: events.Key, _text: str, cursor_index: int) -> CompletionResult:
         """Handle key events for navigation and selection.
 
+        Enter follows each command's `enter_action`: one-stage commands submit
+        immediately; two-stage commands (skills, query routers) only complete
+        into the input. Tab always completes without submitting.
+
         Returns:
             CompletionResult indicating how the key was handled.
         """
@@ -247,7 +252,10 @@ class SlashCommandController:
                     return CompletionResult.HANDLED
                 return CompletionResult.IGNORED
             case "enter":
-                if self._apply_selected_completion(cursor_index):
+                selected = self._suggestions[self._selected_index][0]
+                if not self._apply_selected_completion(cursor_index):
+                    return CompletionResult.HANDLED
+                if enter_action_for(selected) == EnterAction.EXECUTE:
                     return CompletionResult.SUBMIT
                 return CompletionResult.HANDLED
             case "down":

{soothe_cli-0.10.2 → soothe_cli-0.10.4}/src/soothe_cli/tui/widgets/help_screen.py

@@ -49,7 +49,8 @@ def build_keyboard_shortcut_rows() -> list[tuple[str, str]]:
     """
     newline = newline_shortcut()
     return [
-        ("Enter", "Submit message"),
+        ("Enter", "Submit message; with slash suggestions, run or fill for more input"),
+        ("Tab", "Accept slash or @ file autocomplete (never submits)"),
         (
             f"{newline}, Shift+Enter, Alt+Enter, Ctrl+Enter",
             "Insert newline in the chat input",