soothe-cli 1.0.8__tar.gz → 1.0.9__tar.gz

{soothe_cli-1.0.8 → soothe_cli-1.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: soothe-cli
-Version: 1.0.8
+Version: 1.0.9
 Summary: Soothe CLI client - communicates with daemon via WebSocket
 Project-URL: Homepage, https://github.com/mirasoth/soothe
 Project-URL: Documentation, https://soothe.readthedocs.io
@@ -56,10 +56,10 @@ soothe
 # Headless single-prompt mode
 soothe -p "Research AI advances"
 
-# Autopilot job from GOAL.md (greenfield-system rail)
+# Autopilot goal via the TUI /autopilot slash command (loop-native rail)
 cd /path/to/repo
-soothe autopilot submit -f GOAL.md --rail greenfield-system
-soothe autopilot top
+soothe
+# Inside the TUI: /autopilot greenfield-system Refactor the auth module
 
 # Loop management
 soothe loop list

{soothe_cli-1.0.8 → soothe_cli-1.0.9}/README.md

@@ -19,10 +19,10 @@ soothe
 # Headless single-prompt mode
 soothe -p "Research AI advances"
 
-# Autopilot job from GOAL.md (greenfield-system rail)
+# Autopilot goal via the TUI /autopilot slash command (loop-native rail)
 cd /path/to/repo
-soothe autopilot submit -f GOAL.md --rail greenfield-system
-soothe autopilot top
+soothe
+# Inside the TUI: /autopilot greenfield-system Refactor the auth module
 
 # Loop management
 soothe loop list

{soothe_cli-1.0.8 → soothe_cli-1.0.9}/src/soothe_cli/cli/execution/daemon.py

@@ -66,6 +66,39 @@ def _parse_cron_slash_prompt(prompt: str) -> str | None:
     return rest
 
 
+def _parse_autopilot_slash_prompt(prompt: str) -> tuple[str | None, str] | None:
+    """Parse a ``/autopilot`` slash command from headless input.
+
+    Mirrors the TUI ``/autopilot [rail_name] <goal description>`` syntax.
+    When the first token after ``/autopilot`` matches a builtin rail id,
+    it is used as the rail; otherwise the full text is the goal (no rail).
+
+    Args:
+    prompt: User input (e.g. ``/autopilot hotfix fix the login bug``).
+
+    Returns:
+    ``(rail_id, goal_text)`` tuple, or ``None`` if not an autopilot slash
+    command. ``rail_id`` is ``None`` when no rail prefix is present.
+    """
+    stripped = prompt.strip()
+    if not stripped.lower().startswith("/autopilot"):
+        return None
+    rest = stripped[len("/autopilot") :].strip()
+    if not rest:
+        return None
+    try:
+        from soothe.rails.catalog import BUILTIN_RAIL_IDS
+
+        tokens = rest.split(None, 1)
+        if len(tokens) >= 2 and tokens[0] in BUILTIN_RAIL_IDS:
+            return tokens[0], tokens[1].strip()
+    except Exception:
+        pass
+    # No rail prefix matched — return "auto" so the StrangeLoop auto-picks
+    # a rail via ``resolve_rail_for_job`` instead of running without one.
+    return "auto", rest
+
+
 async def _run_headless_session_once(
     cfg: Any,
     prompt: str,
@@ -98,6 +131,24 @@ async def _run_headless_session_once(
         typer.echo(f"  Next run: {str(job.get('next_run', ''))[:19]}")
         return 0, False
 
+    # Parse /autopilot slash command (headless equivalent of the TUI handler).
+    # When the first token matches a builtin rail id, it is used as the rail;
+    # otherwise the full text is the goal (no rail).
+    autopilot_parsed = _parse_autopilot_slash_prompt(prompt)
+    autopilot_rail_id: str | None = None
+    if autopilot_parsed is not None:
+        autopilot_rail_id, autopilot_goal = autopilot_parsed
+        if not autopilot_goal:
+            _emit_headless_error(
+                "Usage: /autopilot [rail_name] <task description>\n"
+                "Example: /autopilot refactor the auth module\n"
+                "Example: /autopilot hotfix fix the login bug"
+            )
+            return 1, False
+        # Replace the prompt with the goal text so subagent parsing and
+        # send_turn operate on the clean goal, not the slash command.
+        prompt = autopilot_goal
+
     try:
         cli_ws = resolve_cli_loop_workspace()
         # Three first-class modes (batch / adaptive / streaming).
@@ -138,6 +189,7 @@ async def _run_headless_session_once(
             session.send_turn(
                 effective_prompt,
                 preferred_subagent=subagent_name,
+                autopilot_rail_id=autopilot_rail_id,
             ),
             timeout=_SESSION_BOOTSTRAP_TIMEOUT_S,
         )

{soothe_cli-1.0.8 → soothe_cli-1.0.9}/src/soothe_cli/cli/main.py

@@ -175,9 +175,8 @@ def main(
         typer.Option(
             "--mode",
             help=(
-                "Composer mode: 'auto' (veritas auto-answers), "
-                "'manual' (relay AI questions to you), or 'plan' (read-only "
-                "plan mode without typing /plan). Default: 'manual'."
+                "Composer mode: 'auto' (veritas auto-answers) or 'plan' "
+                "(read-only plan mode without typing /plan). Default: 'auto'."
             ),
         ),
     ] = None,
@@ -227,9 +226,9 @@ def main(
         raise typer.Exit
 
     home_path = Path(soothe_home).expanduser() if soothe_home else Path(SOOTHE_HOME)
-    if mode is not None and mode not in ("manual", "auto", "plan"):
+    if mode is not None and mode not in ("auto", "plan"):
         typer.echo(
-            f"Invalid --mode {mode!r}; expected 'manual', 'auto', or 'plan'.",
+            f"Invalid --mode {mode!r}; expected 'auto' or 'plan'.",
             err=True,
         )
         raise typer.Exit(code=2)
@@ -276,7 +275,6 @@ def main(
 # Sub-command groups (nested Typer apps)
 # ---------------------------------------------------------------------------
 
-from soothe_cli.cli.commands.autopilot_cmd import app as _autopilot_app  # noqa: E402
 from soothe_cli.cli.commands.config_cmd import config_app as _config_app  # noqa: E402
 from soothe_cli.cli.commands.cron_cmd import app as _cron_app  # noqa: E402
 from soothe_cli.cli.commands.loop_cmd import loop_app as _loop_app  # noqa: E402
@@ -284,16 +282,12 @@ from soothe_cli.cli.commands.status_cmd import status_app as _status_app  # noqa
 
 for _sub_app, _name in (
     (_loop_app, "loop"),
-    (_autopilot_app, "autopilot"),
     (_cron_app, "cron"),
     (_config_app, "config"),
 ):
     configure_command_group(_sub_app, show_help_on_no_args=True)
     app.add_typer(_sub_app, name=_name)
 
-# Alias: 'ap' -> 'autopilot'
-app.add_typer(_autopilot_app, name="ap")
-
 # status has a custom default action (combined status) — keep it; add help only.
 configure_command_group(_status_app, show_help_on_no_args=False)
 app.add_typer(_status_app, name="status")
@@ -309,7 +303,7 @@ def help_command(
     ctx: typer.Context,
     commands: Annotated[
         list[str] | None,
-        typer.Argument(help="Optional command path (e.g. loop, loop list, autopilot top)."),
+        typer.Argument(help="Optional command path (e.g. loop, loop list, cron list)."),
     ] = None,
 ) -> None:
     """Show this message and exit."""

{soothe_cli-1.0.8 → soothe_cli-1.0.9}/src/soothe_cli/commands/command_registry.py

@@ -66,13 +66,6 @@ class SlashCommand:
 
 
 COMMANDS: tuple[SlashCommand, ...] = (
-    SlashCommand(
-        name="/autopilot",
-        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>)",

{soothe_cli-1.0.8 → soothe_cli-1.0.9}/src/soothe_cli/commands/slash_commands.py

@@ -252,12 +252,6 @@ COMMANDS: dict[str, dict[str, Any]] = {
         "description": "Resume a loop by id",
         "params_schema": {"loop_id": {"type": "string", "required": True}},
     },
-    "/autopilot": {
-        "location": "daemon",
-        "type": "routing",
-        "description": "Submit autopilot job (usage: /autopilot <task>)",
-        "requires_query": True,
-    },
     "/cron": {
         "location": "daemon",
         "type": "rpc",

{soothe_cli-1.0.8 → soothe_cli-1.0.9}/src/soothe_cli/config/cli_config.py

@@ -44,10 +44,10 @@ class CLIConfig:
     output_streaming_mode: str | None = None
     """Override daemon streaming mode: 'streaming' or 'batch'."""
 
-    # Composer mode (Auto / Manual / Plan). Auto/Manual map to RFC-622
-    # clarification_mode; Plan sets interaction_mode=plan (read-only plan graph).
+    # Composer mode (Auto / Plan). Auto maps to RFC-622 clarification_mode=auto;
+    # Plan sets interaction_mode=plan (read-only plan graph).
     clarification_mode: str | None = None
-    """'manual', 'auto', or 'plan'. None = seed from daemon default_mode."""
+    """'auto' or 'plan'. None = seed from daemon default_mode."""
 
     # Resume behavior: when the launcher finds an active loop on startup,
     # auto-resume it (True) or prompt the user (False, default).

{soothe_cli-1.0.8 → soothe_cli-1.0.9}/src/soothe_cli/display/card.py

@@ -11,14 +11,9 @@ from __future__ import annotations
 from textual.content import Content
 
 from soothe_cli.display import theme
-from soothe_cli.display.preview_limits import STEP_TASK_CARD_COLLAPSE_LINE_THRESHOLD
 from soothe_cli.display.tool_display import display_width
 from soothe_cli.settings import get_glyphs
 
-# Preview limits imported from preview_limits module
-_STEP_TOOL_PREVIEW_ROWS = STEP_TASK_CARD_COLLAPSE_LINE_THRESHOLD
-"""Collapsed step/task activity preview shows this many rows."""
-
 
 def _card_dot_tone(
     status: str,

{soothe_cli-1.0.8 → soothe_cli-1.0.9}/src/soothe_cli/display/preview_limits.py

@@ -5,16 +5,21 @@ from __future__ import annotations
 from typing import Final
 
 # --- Step cognition cards (`CognitionStepMessage`) ---
-# When False, step cards show the latest N tool activity lines in the branch tree
-# (task + main-agent scopes) plus per-kind counts on the running status line.
-# When True, the full nested tool list also renders in `#step-cognition-tools`.
-STEP_CARD_SHOW_TOOL_ROW_DETAILS: Final[bool] = False
-
 # Latest per-tool invocation lines on step cards and orphan SubAgent cards.
-STEP_CARD_TOOL_ACTIVITY_PREVIEW_COUNT: Final[int] = 2
-
-# Optional manual full tool-list folding threshold (not auto-collapse).
-STEP_TASK_CARD_COLLAPSE_LINE_THRESHOLD: Final[int] = 3
+STEP_CARD_TOOL_ACTIVITY_PREVIEW_COUNT: Final[int] = 5
+
+# File-edit branch on step cards: latest N file-write tool rows (write_file,
+# edit_file, edit_lines, insert_lines, delete_lines, apply_diff, delete_file).
+# The File-edit branch is always rendered (no gate); it only shows when there
+# are file-write tool rows for the step.
+STEP_CARD_FILE_EDIT_PREVIEW_COUNT: Final[int] = 5
+
+# TUI file-change preview cards (the standalone write/edit/delete diff cards
+# mounted in the chat transcript, NOT the step-card File-edit branch).
+# When False (default), the standalone file-change cards are suppressed so
+# file edits appear only in the step-card File-edit branch. Set True to also
+# mount the dedicated diff/content preview cards.
+TUI_FILE_CHANGE_CARDS_ENABLED: Final[bool] = False
 
 # Single-line task-description preview on task markers and orphan SubAgent headers.
 TASK_DELEGATION_DESC_MAX_CHARS: Final[int] = 80

{soothe_cli-1.0.8 → soothe_cli-1.0.9}/src/soothe_cli/tui/app/_execution.py

@@ -347,11 +347,13 @@ class _ExecutionMixin:
 
         Reads `agent.clarification.default_mode` from the daemon config via
         a one-shot WebSocket RPC. Falls back to `"auto"` when the daemon is
-        unreachable, the section is missing, or the value is not
-        `auto`/`manual`.
+        unreachable, the section is missing, or the value is not `auto`.
+        A daemon-configured `manual` default clamps to `auto` (manual is no
+        longer a user-selectable composer mode; the auto→manual fallback
+        card is driven by the runtime clarification event instead).
 
         Returns:
-        Normalized composer mode (`"auto"` or `"manual"`).
+            Normalized composer mode (`"auto"`).
         """
         from soothe_cli.tui.composer_mode import normalize_composer_mode
 
@@ -383,9 +385,11 @@ class _ExecutionMixin:
         """Seed the composer mode from the daemon's configured default.
 
         When the operator did not pass `--mode` explicitly, the TUI badge
-        must reflect `agent.clarification.default_mode` from the daemon
-        config (e.g. `manual`) rather than a hard-coded `auto`. This runs
-        once after the daemon is ready so subsequent turns send the correct
+        reflects `agent.clarification.default_mode` from the daemon config
+        rather than a hard-coded `auto`. A daemon default of `manual` clamps
+        to `auto` (manual is no longer user-selectable; its fallback card is
+        driven by the runtime clarification event). This runs once after the
+        daemon is ready so subsequent turns send the correct
         `clarification_mode` wire field.
 
         When `--mode` was passed, `CLIConfig.clarification_mode` is set
@@ -735,13 +739,18 @@ class _ExecutionMixin:
             rewritten = f"/skill:skill-creator {args}" if args else "/skill:skill-creator"
             await self._handle_skill_command(rewritten)
         elif cmd == "/autopilot" or cmd.startswith("/autopilot "):
-            # Submit autopilot job via WebSocket (like CLI `soothe autopilot submit`)
+            # Submit autopilot job via the normal loop submission path (not the
+            # autopilot_submit RPC) so the goal runs through StrangeLoop directly.
+            # When the first token matches a known builtin rail id, it is used as
+            # the autopilot rail: `/autopilot [rail_name] <goal description>`.
             args = command.strip()[len("/autopilot") :].strip()
             if not args:
                 await self._mount_message(UserMessage(command))
                 await self._mount_message(
                     AppMessage(
-                        "Usage: /autopilot <task description>\nExample: /autopilot refactor the auth module"
+                        "Usage: /autopilot [rail_name] <task description>\n"
+                        "Example: /autopilot refactor the auth module\n"
+                        "Example: /autopilot hotfix fix the login bug"
                     )
                 )
                 return
@@ -909,6 +918,7 @@ class _ExecutionMixin:
         message: str,
         *,
         skip_daemon_send_turn: bool = False,
+        autopilot_rail_id: str | None = None,
     ) -> None:
         """Send a message to the agent and start execution.
 
@@ -920,6 +930,10 @@ class _ExecutionMixin:
         message: The prompt to send to the agent.
         skip_daemon_send_turn: When using a daemon session, only attach to
         the in-flight stream (prompt already queued on the daemon).
+        autopilot_rail_id: Optional builtin rail id. When set, the daemon
+            binds a ``LoopRailInterpreter`` for this goal via
+            ``run_with_progress(autopilot_rail_id=…)``. Used by the
+            ``/autopilot [rail_name] <goal>`` slash command.
         """
         # Anchor to bottom so streaming response stays visible
         with suppress(NoMatches, ScreenStackError):
@@ -955,6 +969,7 @@ class _ExecutionMixin:
                 self._run_agent_task(
                     message,
                     skip_daemon_send_turn=skip_daemon_send_turn,
+                    autopilot_rail_id=autopilot_rail_id,
                 ),
                 exclusive=False,
             )
@@ -1015,6 +1030,7 @@ class _ExecutionMixin:
         message: str,
         *,
         skip_daemon_send_turn: bool = False,
+        autopilot_rail_id: str | None = None,
     ) -> None:
         """Run the agent task in a background worker.
 
@@ -1024,6 +1040,9 @@ class _ExecutionMixin:
         message: The prompt to send to the agent.
         skip_daemon_send_turn: When `True` with a daemon session, only
         consume the daemon stream (prompt already queued server-side).
+        autopilot_rail_id: Optional builtin rail id forwarded to
+        ``execute_task_textual`` → ``send_turn`` → ``loop_input`` so the
+        daemon binds a ``LoopRailInterpreter`` for this goal.
         """
         # Caller ensures _ui_adapter is set (checked in _handle_user_message)
         if self._ui_adapter is None:
@@ -1073,6 +1092,7 @@ class _ExecutionMixin:
                         clarification_mode=wire_clar,
                         sticky_preferred_subagent=sticky_subagent,
                         interaction_mode=wire_interaction,
+                        autopilot_rail_id=autopilot_rail_id,
                         is_shutting_down=lambda: getattr(self, "_exit", False),
                     )
                     break

{soothe_cli-1.0.8 → soothe_cli-1.0.9}/src/soothe_cli/tui/app/_messages_mixin.py

@@ -1147,7 +1147,7 @@ class _MessagesMixin:
         """Shift+Tab: navigate loop selector when active, otherwise cycle mode.
 
         - In the LoopSelectorScreen, defer to its filter navigation.
-        - On the main screen, cycle composer mode Auto → Bypass → Manual → Plan → Ask.
+        - On the main screen, cycle composer mode Auto → Bypass → Plan → Ask.
         """
         from soothe_cli.tui.widgets.loop_selector import LoopSelectorScreen
 
@@ -1159,8 +1159,8 @@ class _MessagesMixin:
     def cycle_composer_mode(self) -> None:
         """Advance composer mode and refresh the status-bar badge.
 
-        Cycle: Auto → Bypass → Manual → Plan → Ask → Auto. For agent sub-modes
-        (auto/bypass/manual) hot-swap the running goal's agent mode via
+        Cycle: Auto → Bypass → Plan → Ask → Auto. For agent sub-modes
+        (auto/bypass) hot-swap the running goal's agent mode via
         `loop_set_clarification_mode`; Plan/Ask take effect on the next turn.
         """
         from soothe_cli.tui.composer_mode import (

{soothe_cli-1.0.8 → soothe_cli-1.0.9}/src/soothe_cli/tui/app/_model.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import asyncio
 import logging
-import os
 from contextlib import suppress
 from typing import TYPE_CHECKING, Any
 
@@ -304,51 +303,87 @@ class _ModelMixin:
         self.push_screen(HelpScreen(), handle_result)
 
     async def _submit_autopilot_job(self, task: str) -> None:
-        """Submit an autopilot job via WebSocket (like CLI `soothe autopilot submit`).
+        """Submit an autopilot goal via the normal loop submission path.
+
+        Parses an optional leading rail id from ``[rail_name] <goal>``. When the
+        first token matches a builtin rail id, it is used as ``autopilot_rail_id``
+        and forwarded through the loop_input wire so ``StrangeLoop.run_with_progress``
+        binds a ``LoopRailInterpreter`` for this goal. When no rail prefix is
+        present, the goal runs as a normal loop turn (no rail).
+
+        This bypasses ``AutopilotService.submit_task()`` — the goal is submitted
+        like any other user message via the daemon's loop_input dispatcher.
 
         Args:
-        task: Task description for autonomous execution.
+        task: Task description, optionally prefixed with ``[rail_name]``.
         """
-        from soothe_client import (
-            async_command_client_from_config,
-            is_daemon_live,
-            websocket_url_from_config,
-        )
+        from soothe.rails.catalog import BUILTIN_RAIL_IDS
 
         from soothe_cli.runtime import load_config
-        from soothe_cli.tui.widgets.messages import ErrorMessage, UserMessage
+        from soothe_cli.tui.widgets.messages import (
+            AppMessage,
+            ErrorMessage,
+            UserMessage,
+        )
 
-        await self._mount_message(UserMessage(f"/autopilot {task}"))
+        # Parse optional rail prefix: ``/autopilot [rail_name] <goal>``.
+        tokens = task.split(None, 1)
+        rail_id: str | None = None
+        goal_text = task
+        if len(tokens) >= 2 and tokens[0] in BUILTIN_RAIL_IDS:
+            rail_id = tokens[0]
+            goal_text = tokens[1].strip()
+        else:
+            # No rail prefix — send "auto" so the StrangeLoop auto-picks a
+            # rail via ``resolve_rail_for_job`` instead of running without one.
+            rail_id = "auto"
+
+        if not goal_text:
+            await self._mount_message(UserMessage(f"/autopilot {task}"))
+            await self._mount_message(
+                AppMessage(
+                    "Usage: /autopilot [rail_name] <task description>\n"
+                    "Example: /autopilot hotfix fix the login bug"
+                )
+            )
+            return
+
+        display = (
+            f"/autopilot {task}" if rail_id and rail_id != "auto" else f"/autopilot {goal_text}"
+        )
+        await self._mount_message(UserMessage(display))
+
+        # Verify the daemon is live before submitting via the loop path.
+        from soothe_client import is_daemon_live, websocket_url_from_config
 
         cfg = load_config()
         ws_url = websocket_url_from_config(cfg)
-
-        # Check daemon is running
         if not await is_daemon_live(ws_url, timeout=5.0):
             await self._mount_message(
                 ErrorMessage("Daemon not running. Start with 'soothed start'.")
             )
             return
 
-        workspace = self._cwd if hasattr(self, "_cwd") else os.getcwd()
-
+        # Submit via the normal loop submission path (not autopilot_submit RPC).
+        # _send_to_agent → execute_task_textual → daemon_session.send_turn →
+        # loop_input RPC → run_with_progress(autopilot_rail_id=rail_id).
         try:
-            client = async_command_client_from_config(cfg)
-            result = await client.autopilot_submit(task, workspace=workspace)
-        except RuntimeError as exc:
-            await self._mount_message(ErrorMessage(str(exc)))
-            return
+            await self._send_to_agent(goal_text, autopilot_rail_id=rail_id)
         except Exception as exc:  # noqa: BLE001
-            logger.exception("Autopilot submit failed")
-            await self._mount_message(ErrorMessage(f"Failed to submit autopilot job: {exc}"))
+            logger.exception("Autopilot loop submission failed")
+            await self._mount_message(ErrorMessage(f"Failed to submit autopilot goal: {exc}"))
             return
 
-        goal_id = result.get("goal_id", "")
-        if goal_id:
-            self.notify(f"Autopilot job submitted: {goal_id[:8]}", timeout=5)
-            logger.info("Submitted autopilot job %s: %s", goal_id, task[:50])
+        if rail_id and rail_id != "auto":
+            self.notify(f"Autopilot goal submitted (rail: {rail_id})", timeout=5)
+            logger.info(
+                "Submitted autopilot goal via loop path (rail=%s): %s",
+                rail_id,
+                goal_text[:50],
+            )
         else:
-            await self._mount_message(ErrorMessage("No goal_id returned from daemon"))
+            self.notify("Autopilot goal submitted", timeout=5)
+            logger.info("Submitted autopilot goal via loop path: %s", goal_text[:50])
 
     async def _submit_cron_job(self, text: str, *, slash_input: str | None = None) -> None:
         """Submit a cron job via WebSocket (like CLI `soothe cron add`).

{soothe_cli-1.0.8 → soothe_cli-1.0.9}/src/soothe_cli/tui/composer_mode.py

@@ -1,7 +1,7 @@
 """TUI composer modes — working-mode hierarchy.
 
-Agent sub-modes (auto, bypass, manual) grouped first, then plan and ask.
-Shift+Tab cycle: Auto → Bypass → Manual → Plan → Ask → Auto.
+Agent sub-modes (auto, bypass) grouped first, then plan and ask.
+Shift+Tab cycle: Auto → Bypass → Plan → Ask → Auto.
 """
 
 from __future__ import annotations
@@ -9,7 +9,6 @@ from __future__ import annotations
 from dataclasses import dataclass
 
 COMPOSER_MODE_AUTO = "auto"
-COMPOSER_MODE_MANUAL = "manual"
 COMPOSER_MODE_PLAN = "plan"
 COMPOSER_MODE_ASK = "ask"
 COMPOSER_MODE_BYPASS = "bypass"
@@ -18,16 +17,13 @@ COMPOSER_MODE_BYPASS = "bypass"
 COMPOSER_MODE_ORDER: tuple[str, ...] = (
     COMPOSER_MODE_AUTO,
     COMPOSER_MODE_BYPASS,
-    COMPOSER_MODE_MANUAL,
     COMPOSER_MODE_PLAN,
     COMPOSER_MODE_ASK,
 )
 VALID_COMPOSER_MODES: frozenset[str] = frozenset(COMPOSER_MODE_ORDER)
 
 # Agent working mode sub-modes (full mutating tool surface).
-AGENT_SUB_MODES: frozenset[str] = frozenset(
-    {COMPOSER_MODE_AUTO, COMPOSER_MODE_MANUAL, COMPOSER_MODE_BYPASS}
-)
+AGENT_SUB_MODES: frozenset[str] = frozenset({COMPOSER_MODE_AUTO, COMPOSER_MODE_BYPASS})
 # Standalone working modes (not agent sub-modes).
 STANDALONE_WORKING_MODES: frozenset[str] = frozenset({COMPOSER_MODE_PLAN, COMPOSER_MODE_ASK})
 
@@ -59,9 +55,9 @@ def next_composer_mode(current: str) -> str:
 def resolve_composer_wire_fields(mode: str) -> ComposerWireFields:
     """Map composer mode to wire fields.
 
-    auto → clarification=auto, interaction=None; manual → clarification=manual;
-    bypass → clarification=auto, interaction=bypass; plan → interaction=plan;
-    ask → interaction=ask. Slash routing in the message wins over the sticky hint.
+    auto → clarification=auto, interaction=None; bypass → clarification=auto,
+    interaction=bypass; plan → interaction=plan; ask → interaction=ask.
+    Slash routing in the message wins over the sticky hint.
     """
     normalized = normalize_composer_mode(mode)
     if normalized == COMPOSER_MODE_PLAN:
@@ -70,6 +66,4 @@ def resolve_composer_wire_fields(mode: str) -> ComposerWireFields:
         return ComposerWireFields(COMPOSER_MODE_AUTO, None, COMPOSER_MODE_ASK)
     if normalized == COMPOSER_MODE_BYPASS:
         return ComposerWireFields(COMPOSER_MODE_AUTO, None, COMPOSER_MODE_BYPASS)
-    if normalized == COMPOSER_MODE_MANUAL:
-        return ComposerWireFields(COMPOSER_MODE_MANUAL, None, None)
     return ComposerWireFields(COMPOSER_MODE_AUTO, None, None)

{soothe_cli-1.0.8 → soothe_cli-1.0.9}/src/soothe_cli/tui/file_change_notify.py

@@ -6,6 +6,7 @@ import asyncio
 import logging
 from typing import TYPE_CHECKING, Any
 
+from soothe_cli.display.preview_limits import TUI_FILE_CHANGE_CARDS_ENABLED
 from soothe_cli.runtime.state.file_tracker import (
     FILE_CHANGE_TOOLS,
     file_change_action_label,
@@ -97,6 +98,8 @@ async def mount_file_change_preview(
     assistant_id: Agent id for path resolution.
     file_op_tracker: Optional tracker with `recently_completed` lookups.
     """
+    if not TUI_FILE_CHANGE_CARDS_ENABLED:
+        return
     if tool_name not in FILE_CHANGE_TOOLS:
         return
     tcid = str(tool_call_id or "").strip()
@@ -208,6 +211,8 @@ async def mount_completed_file_change_preview(
     Returns:
     True when a completed preview card was mounted from the tracker record.
     """
+    if not TUI_FILE_CHANGE_CARDS_ENABLED:
+        return False
     tool_name = str(record.tool_name or "").strip()
     tcid = str(record.tool_call_id or "").strip()
     if tool_name not in FILE_CHANGE_TOOLS or not tcid:

{soothe_cli-1.0.8 → soothe_cli-1.0.9}/src/soothe_cli/tui/textual_adapter.py

@@ -3031,6 +3031,7 @@ async def execute_task_textual(
     clarification_mode: str | None = None,
     sticky_preferred_subagent: str | None = None,
     interaction_mode: str | None = None,
+    autopilot_rail_id: str | None = None,
     is_shutting_down: Callable[[], bool] | None = None,
 ) -> SessionStats:
     """Execute a task with output directed to Textual UI."""
@@ -3202,6 +3203,7 @@ async def execute_task_textual(
                 interaction_mode=interaction_mode,
                 clarification_answer=sending_clarification_answer,
                 clarification_answers=pending_clarification_answers,
+                autopilot_rail_id=autopilot_rail_id,
             )
             chunk_source = daemon_session.iter_turn_chunks()