soothe-cli 0.6.15__tar.gz → 0.6.17__tar.gz

{soothe_cli-0.6.15 → soothe_cli-0.6.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.6.15
+Version: 0.6.17
 Summary: Soothe CLI client - communicates with daemon via WebSocket
 Project-URL: Homepage, https://github.com/mirasoth/soothe
 Project-URL: Documentation, https://soothe.readthedocs.io

{soothe_cli-0.6.15 → soothe_cli-0.6.17}/src/soothe_cli/cli/commands/autopilot_cmd.py

@@ -397,96 +397,3 @@ def dream() -> None:
     client = _require_daemon_ws()
     client.autopilot_dream()
     typer.echo("Dream signal sent.")
-
-
-def _discover_goals(autopilot_dir: Path) -> list[dict]:
-    """Parse goals from GOAL.md/GOALS.md files for offline CLI display."""
-    import re
-
-    goals: list[dict] = []
-
-    goal_file = autopilot_dir / "GOAL.md"
-    if goal_file.exists():
-        g = _parse_single_goal(goal_file.read_text(), str(goal_file))
-        if g:
-            return [g]
-
-    goals_file = autopilot_dir / "GOALS.md"
-    if goals_file.exists():
-        text = goals_file.read_text()
-        for section in re.split(r"## Goal:", text)[1:]:
-            g = _parse_goals_section(section.strip(), str(goals_file))
-            if g:
-                goals.append(g)
-
-    goals_dir = autopilot_dir / "goals"
-    if goals_dir.exists():
-        for subdir in sorted(goals_dir.iterdir()):
-            gfile = subdir / "GOAL.md"
-            if gfile.exists():
-                g = _parse_single_goal(gfile.read_text(), str(gfile))
-                if g:
-                    goals.append(g)
-
-    return goals
-
-
-def _parse_single_goal(text: str, source: str) -> dict | None:
-    """Parse a single GOAL.md file."""
-    if not text.startswith("---"):
-        return None
-
-    parts = text.split("---", 2)
-    if len(parts) < 3:  # noqa: PLR2004
-        return None
-
-    import yaml
-
-    fm = yaml.safe_load(parts[1]) or {}
-    body = parts[2].strip()
-
-    desc = ""
-    for line in body.splitlines():
-        s = line.strip()
-        if s.startswith("# "):
-            desc = s[2:]
-            break
-
-    return {
-        "id": fm.get("id", source.split("/")[-2]),
-        "description": desc or preview_first(body, 100),
-        "priority": int(fm.get("priority", 50)),
-        "status": fm.get("status", "pending"),
-        "depends_on": fm.get("depends_on", []),
-        "source_file": source,
-    }
-
-
-def _parse_goals_section(text: str, source: str) -> dict | None:
-    """Parse a single goal section from GOALS.md."""
-    lines = text.splitlines()
-    name = lines[0].strip() if lines else ""
-    metadata: dict = {}
-
-    for line in lines[1:]:
-        s = line.strip()
-        if s.startswith("- id:"):
-            metadata["id"] = s.split(":", 1)[1].strip()
-        elif s.startswith("- priority:"):
-            metadata["priority"] = int(s.split(":", 1)[1].strip())
-        elif s.startswith("- depends_on:"):
-            raw = s.split(":", 1)[1].strip()
-            if raw.startswith("[") and raw.endswith("]"):
-                inner = raw[1:-1].strip()
-                metadata["depends_on"] = (
-                    [x.strip() for x in inner.split(",") if x.strip()] if inner else []
-                )
-
-    return {
-        "id": metadata.get("id", name.lower().replace(" ", "-")),
-        "description": name,
-        "priority": metadata.get("priority", 50),
-        "status": "pending",
-        "depends_on": metadata.get("depends_on", []),
-        "source_file": source,
-    }

{soothe_cli-0.6.15 → soothe_cli-0.6.17}/src/soothe_cli/config/cli_config.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any
 
 from soothe_sdk.client.config import SOOTHE_HOME
 
@@ -44,41 +43,6 @@ class CLIConfig:
     # Paths
     soothe_home: Path = field(default_factory=lambda: Path(SOOTHE_HOME))
 
-    # Daemon config cache (fetched via RPC)
-    _daemon_config_cache: dict[str, Any] = field(default_factory=dict)
-
     def websocket_url(self) -> str:
         """Construct WebSocket URL for daemon connection."""
         return f"ws://{self.daemon_host}:{self.daemon_port}"
-
-    async def fetch_daemon_config(self, section: str = "all") -> dict[str, Any]:
-        """Fetch daemon config section via WebSocket RPC.
-
-        Args:
-            section: Config section name (e.g., "providers", "defaults", "all").
-
-        Returns:
-            Wire-safe config section dict.
-        """
-        from soothe_sdk.client import WebSocketClient, fetch_config_section
-
-        client = WebSocketClient(url=self.websocket_url())
-        await client.connect()
-
-        try:
-            config_section = await fetch_config_section(client, section, timeout=5.0)
-            self._daemon_config_cache[section] = config_section
-            return config_section
-        finally:
-            await client.close()
-
-    def get_cached_config(self, section: str) -> dict[str, Any]:
-        """Get cached daemon config section.
-
-        Args:
-            section: Config section name.
-
-        Returns:
-            Cached config section dict, or empty dict if not cached.
-        """
-        return self._daemon_config_cache.get(section, {})

soothe_cli-0.6.17/src/soothe_cli/runtime/__init__.py

@@ -0,0 +1,17 @@
+"""Daemon event processing and display state for the CLI (source of truth for TUI).
+
+Bridges daemon events/messages to in-memory state. ``soothe_cli.tui`` owns widgets
+and layout only.
+"""
+
+from soothe_cli.config.loader import load_config
+from soothe_cli.config.logging_setup import setup_logging
+from soothe_cli.runtime.headless.processor import EventProcessor
+from soothe_cli.runtime.headless.processor_state import ProcessorState
+
+__all__ = [
+    "EventProcessor",
+    "ProcessorState",
+    "load_config",
+    "setup_logging",
+]

{soothe_cli-0.6.15 → soothe_cli-0.6.17}/src/soothe_cli/runtime/parse/message_processing.py

@@ -16,17 +16,14 @@ from soothe_sdk.display.message_processing import (
     _resolve_pending_lookup_tool_name,
     accumulate_tool_call_chunks,
     coerce_tool_call_args_to_dict,
-    coerce_tool_call_entry_to_dict,
     extract_tool_args_dict,
     extract_tool_brief,
     finalize_pending_tool_call,
     ingest_tool_call_stream_state,
     normalize_tool_calls_list,
     richest_pending_args_for_lookup,
-    seed_pending_tool_calls_from_message,
     tool_calls_have_any_arg_dict,
     tool_ids_touched_by_stream_message,
-    tool_lookup_step_id,
     try_parse_pending_tool_call_args,
 )
 
@@ -36,16 +33,13 @@ __all__ = [
     "_resolve_pending_lookup_tool_name",
     "accumulate_tool_call_chunks",
     "coerce_tool_call_args_to_dict",
-    "coerce_tool_call_entry_to_dict",
     "extract_tool_args_dict",
     "extract_tool_brief",
     "finalize_pending_tool_call",
     "ingest_tool_call_stream_state",
     "normalize_tool_calls_list",
     "richest_pending_args_for_lookup",
-    "seed_pending_tool_calls_from_message",
     "tool_calls_have_any_arg_dict",
     "tool_ids_touched_by_stream_message",
-    "tool_lookup_step_id",
     "try_parse_pending_tool_call_args",
 ]

{soothe_cli-0.6.15 → soothe_cli-0.6.17}/src/soothe_cli/runtime/parse/tool_call_resolution.py

@@ -17,7 +17,15 @@ from collections.abc import Mapping
 from dataclasses import dataclass
 from typing import Any
 
-from soothe_sdk.ux.task_namespace import parse_unified_tool_call_id
+from soothe_sdk.ux.execute_namespace import (
+    is_root_execute_namespace_key,
+    is_step_level_execute_namespace_key,
+)
+from soothe_sdk.ux.task_namespace import (
+    TaskScope,
+    parse_unified_tool_call_id,
+    row_key_for_subgraph_tool,
+)
 
 from soothe_cli.runtime.parse.message_processing import (
     extract_tool_args_dict,
@@ -40,15 +48,32 @@ def tool_args_meaningful(raw: Any) -> bool:
 
 
 def is_execute_step_namespace(ns_key: tuple[str, ...]) -> bool:
-    """True for CoreAgent execute root namespace (``execute:{run_id}``), not nested ``tools:`` subgraphs."""
-    if len(ns_key) != 1:
-        return False
-    return str(ns_key[0] or "").startswith("execute:")
+    """True for CoreAgent execute root namespace (``execute:{run_id}``), not nested ``/N`` or ``tools:`` subgraphs."""
+    return is_root_execute_namespace_key(ns_key)
 
 
 def is_step_card_tool_scope(*, ns_key: tuple[str, ...]) -> bool:
     """True when tool activity belongs on the step card as main execute-graph tools."""
-    return ns_key == () or is_execute_step_namespace(ns_key)
+    return ns_key == () or is_step_level_execute_namespace_key(ns_key)
+
+
+def resolve_tool_result_row_key(
+    *,
+    ns_key: tuple[str, ...],
+    tool_call_id: str,
+    task_scope: TaskScope | None = None,
+) -> str:
+    """Row key for completing a tool row from a streamed ``ToolMessage``.
+
+    Execute-graph namespaces (``()`` or ``execute:…``) keep the unified ``s:`` id.
+    Subagent ``tools:…`` namespaces remap via :func:`row_key_for_subgraph_tool`.
+    """
+    sid = str(tool_call_id or "").strip()
+    if not sid:
+        return ""
+    if is_step_card_tool_scope(ns_key=ns_key):
+        return sid
+    return row_key_for_subgraph_tool(ns_key, sid, task_scope=task_scope)
 
 
 def is_main_step_level_tool_call_id(tool_call_id: str) -> bool:
@@ -64,6 +89,45 @@ def is_main_step_level_tool_call_id(tool_call_id: str) -> bool:
     return not is_step_level_task_tool_id(tcid)
 
 
+def predict_main_execute_tool_call_id(
+    step_id: str,
+    *,
+    tool_call_id: str = "",
+    tool_name: str = "",
+    chunk_index: Any = None,
+) -> str:
+    """Best-effort unified id for main-graph execute tools during streaming."""
+    from soothe_sdk.ux.task_namespace import (
+        _format_unified_tool_call_id,
+        _provider_tool_fragment,
+        is_unified_tool_call_id,
+        parse_unified_tool_call_id,
+    )
+
+    tcid = str(tool_call_id or "").strip()
+    if tcid and is_unified_tool_call_id(tcid):
+        parsed_sid, type_code, _, _ = parse_unified_tool_call_id(tcid)
+        if parsed_sid and type_code == "s":
+            return tcid
+    sid = str(step_id or "").strip()
+    if not sid:
+        return tcid
+    raw_tid = tcid
+    if not raw_tid:
+        name = str(tool_name or "").strip()
+        if name and chunk_index is not None:
+            try:
+                idx = int(chunk_index)
+            except (TypeError, ValueError):
+                idx = None
+            if idx is not None:
+                raw_tid = f"{name}:{idx}"
+    if not raw_tid:
+        return ""
+    frag = _provider_tool_fragment(raw_tid)
+    return _format_unified_tool_call_id(sid, "s", frag)
+
+
 def is_task_level_subgraph_tool_call_id(tool_call_id: str) -> bool:
     """True for unified subgraph tools (``{step}:t{n}:{tool}:{seq}``), not nested ``task`` rows."""
     from soothe_sdk.ux.task_namespace import (
@@ -87,19 +151,22 @@ def should_ingest_tool_for_step_stats(
 ) -> bool:
     """Whether the TUI should register a tool row for step-card stats.
 
-    Main step-level tools are tracked as soon as ``tool_call_id`` and ``tool_name``
-    are known; display does not wait for streamed args.
+    Main execute-graph tools are tracked as soon as ``tool_call_id`` and ``tool_name``
+    are known; display does not wait for streamed args. Subgraph explore tools often
+    arrive with placeholder kwargs before real args.
     """
+    from soothe_sdk.ux.task_namespace import is_step_level_task_tool_id
+
     name = str(tool_name or "").strip()
     tcid = str(tool_call_id or "").strip()
     if not name or not tcid or name == "task":
         return False
     if args_meaningful:
         return True
-    if is_step_card_scope and is_main_step_level_tool_call_id(tcid):
-        return True
+    if is_step_card_scope:
+        return not is_step_level_task_tool_id(tcid)
     # Subgraph explore tools often arrive with ``{"_subgraph_tool": true}`` before real args.
-    return not is_step_card_scope and is_task_level_subgraph_tool_call_id(tcid)
+    return is_task_level_subgraph_tool_call_id(tcid)
 
 
 def _args_from_toolish_block(block: dict[str, Any]) -> dict[str, Any]:
@@ -498,11 +565,13 @@ __all__ = [
     "is_main_step_level_tool_call_id",
     "is_step_card_tool_scope",
     "is_task_level_subgraph_tool_call_id",
+    "predict_main_execute_tool_call_id",
     "is_toolish_display_block",
     "materialize_ai_blocks_with_resolved_tools",
     "merge_tool_display_args",
     "resolve_stream_tool_name",
     "resolve_tool_invocations_for_display",
+    "resolve_tool_result_row_key",
     "should_ingest_tool_for_step_stats",
     "tool_args_meaningful",
 ]

{soothe_cli-0.6.15 → soothe_cli-0.6.17}/src/soothe_cli/runtime/parse/tool_result.py

@@ -3,13 +3,11 @@
 from __future__ import annotations
 
 from soothe_sdk.display.tool_result import (
-    ToolResultPayload,
     extract_tool_result_payload,
     infer_tool_output_suggests_error,
 )
 
 __all__ = [
-    "ToolResultPayload",
     "extract_tool_result_payload",
     "infer_tool_output_suggests_error",
 ]

{soothe_cli-0.6.15 → soothe_cli-0.6.17}/src/soothe_cli/runtime/state/step_router.py

@@ -165,6 +165,47 @@ class StepTaskRouter:
         if sid:
             self.active_step_ids.add(sid)
 
+    def maybe_promote_step_to_running(
+        self,
+        step_w: StepWidget,
+        tool_call_id: str,
+        *,
+        step_cards: dict[str, StepWidget],
+    ) -> None:
+        """Promote a pending step card to running only when it is executing (RFC-628).
+
+        Pre-mounted future steps must stay ``pending`` until ``step.started`` even when
+        tools are stamped with their unified step id. The pre-``step.started`` race for
+        the active step is allowed only while no sibling step card is already running.
+        """
+        if getattr(step_w, "_status", "") != "pending":
+            return
+        step_id = str(getattr(step_w, "_step_id", "") or "").strip()
+        if not step_id:
+            return
+
+        tcid = str(tool_call_id or "").strip()
+        parsed_sid, _, _, _ = parse_unified_tool_call_id(tcid)
+        if parsed_sid and parsed_sid != step_id:
+            return
+
+        if step_id in self.active_step_ids:
+            allowed = True
+        elif self.active_step_ids:
+            allowed = False
+        else:
+            allowed = not any(
+                getattr(w, "_status", "") == "running"
+                and str(getattr(w, "_step_id", "") or "").strip() != step_id
+                for w in step_cards.values()
+            )
+
+        if not allowed:
+            return
+        promote = getattr(step_w, "promote_to_running_if_pending", None)
+        if callable(promote):
+            promote()
+
     def on_step_completed(self, step_id: str) -> None:
         """Drop step from the active set and spawn registry."""
         sid = step_id.strip()
@@ -353,6 +394,11 @@ class StepTaskRouter:
                     item.args,
                     raw_args=item.raw_args,
                 )
+                self.maybe_promote_step_to_running(
+                    step_w,
+                    item.tool_call_id,
+                    step_cards=step_cards,
+                )
             tool_to_step[item.tool_call_id] = step_w
             existing = tool_display_by_call_id.get(item.tool_call_id)
             if existing is None:
@@ -394,6 +440,8 @@ class StepTaskRouter:
         parent: ParentWidget,
         scope: TaskScope,
         tool_to_step: dict[str, ParentWidget],
+        *,
+        step_cards: dict[str, StepWidget] | None = None,
     ) -> bool:
         """Register one subgraph tool row on an already-resolved parent step card."""
         if _is_task_metadata_subgraph_tool(item):
@@ -432,7 +480,6 @@ class StepTaskRouter:
                         resolved_args = parsed
                 update(row_id, resolved_args)
         else:
-            parent_task_id = str(scope[0]).strip()
             resolved_args = dict(item.args or {})
             from soothe_cli.runtime.parse.message_processing import extract_tool_args_dict
 
@@ -446,9 +493,10 @@ class StepTaskRouter:
                 item.tool_name,
                 resolved_args,
                 raw_args=item.raw_args,
-                parent_tool_call_id=parent_task_id or None,
             )
         tool_to_step[row_id] = parent
+        if step_cards is not None:
+            self.maybe_promote_step_to_running(parent, row_id, step_cards=step_cards)
         return True
 
     def try_route_subgraph_tool(
@@ -522,7 +570,13 @@ class StepTaskRouter:
             return False
         pending_key = _subgraph_pending_key(ns_key, item.lookup_id)
         self._pending_subgraph_tools.pop(pending_key, None)
-        return self._ingest_subgraph_tool_on_parent(item, parent, scope, tool_to_step)
+        return self._ingest_subgraph_tool_on_parent(
+            item,
+            parent,
+            scope,
+            tool_to_step,
+            step_cards=step_cards,
+        )
 
     def route_pending_subgraph_tools(
         self,
@@ -575,7 +629,13 @@ class StepTaskRouter:
             if parent is None:
                 still[key] = item
                 continue
-            if self._ingest_subgraph_tool_on_parent(item, parent, scope, tool_to_step):
+            if self._ingest_subgraph_tool_on_parent(
+                item,
+                parent,
+                scope,
+                tool_to_step,
+                step_cards=step_cards,
+            ):
                 routed += 1
             else:
                 still[key] = item
@@ -586,15 +646,15 @@ class StepTaskRouter:
         """Snapshot of subgraph tools still awaiting parent resolution."""
         return list(self._pending_subgraph_tools.values())
 
+    def discard_pending_subgraph_tool(self, ns_key: tuple[str, ...], lookup_id: str) -> None:
+        """Drop a buffered subgraph tool after routing it to a SubAgent card."""
+        self._pending_subgraph_tools.pop(_subgraph_pending_key(ns_key, lookup_id), None)
+
     @property
     def pending_main_tool_count(self) -> int:
         """Number of root tools still awaiting step card routing."""
         return len(self._pending_main_tools)
 
-    def clear_step_tool_bindings(self, step_id: str) -> None:
-        """No-op: step routing uses unified tool_call_id encoding only."""
-        _ = step_id
-
 
 __all__ = [
     "ParentWidget",

{soothe_cli-0.6.15 → soothe_cli-0.6.17}/src/soothe_cli/tui/app/_app.py

@@ -49,10 +49,6 @@ from soothe_cli.tui.widgets.welcome import WelcomeBanner
 logger = logging.getLogger(__name__)
 _monotonic = time.monotonic
 
-InputMode = (
-    "normal"  # Literal type alias — actual value used in _module_init; here for isinstance guards
-)
-
 
 class SootheApp(
     App,

{soothe_cli-0.6.15 → soothe_cli-0.6.17}/src/soothe_cli/tui/app/_execution.py

@@ -664,8 +664,6 @@ class _ExecutionMixin:
             await self._submit_cron_job(args, slash_input=command)
         elif cmd == "/autopilot-dashboard":
             await self._show_autopilot_dashboard()
-        elif cmd == "/autopilot-toggle":
-            await self._toggle_autopilot_mode()
         elif cmd == "/mcp":
             await self._show_mcp_viewer()
         elif cmd == "/theme":

{soothe_cli-0.6.15 → soothe_cli-0.6.17}/src/soothe_cli/tui/app/_messages_mixin.py

@@ -393,25 +393,42 @@ class _MessagesMixin:
         copy_selection_to_clipboard(self, notify_if_empty=True)
 
     def action_quit_or_interrupt(self) -> None:
-        """Handle Ctrl+C - interrupt agent or quit on double press.
+        """Handle Ctrl+C - clear input, interrupt agent, or quit on double press.
 
-        Priority order:
-        1. If shell command is running, kill it
-        2. If agent is running, interrupt it (preserve input)
-        3. If double press (quit_pending), quit
-        4. Otherwise clear draft input and show quit hint
+        Priority order when task is running (agent/shell):
+        1. If input has pending text, clear it (first Ctrl+C)
+        2. If input is empty, interrupt the running task (second Ctrl+C)
+
+        Priority order when idle:
+        1. If double press (quit_pending), quit
+        2. Otherwise clear pending input and show quit hint
 
         Note: Copying selected text is bound to Ctrl+Y (`action_copy_selection`)
         so Ctrl+C is reserved for interrupt/quit only.
         """
-        # If shell command is running, cancel the worker
+        # Check if input has pending content (text, mode, or completion)
+        has_pending_input = self._chat_input and (
+            self._chat_input.value.strip()
+            or self._chat_input.mode != "normal"
+            or self._chat_input._current_suggestions
+        )
+
+        # If shell command is running: clear input first, then kill shell
         if self._shell_running and self._shell_worker:
+            if has_pending_input:
+                self._chat_input.clear_input()
+                self._quit_pending = False
+                return
             self._cancel_worker(self._shell_worker)
             self._quit_pending = False
             return
 
-        # If agent is running, interrupt it and discard queued messages
+        # If agent is running: clear input first, then interrupt
         if self._agent_running and self._agent_worker:
+            if has_pending_input:
+                self._chat_input.clear_input()
+                self._quit_pending = False
+                return
             if self._daemon_session is not None:
                 self.run_worker(
                     self._interrupt_daemon_agent_turn(),
@@ -430,7 +447,7 @@ class _MessagesMixin:
             self._arm_quit_pending("Ctrl+C")
 
     def _arm_quit_pending(self, shortcut: str) -> None:
-        """Set the pending-quit flag, clear draft input, and show a matching hint.
+        """Set the pending-quit flag, clear pending input, and show a matching hint.
 
         Args:
             shortcut: The key chord to show in the quit hint.
@@ -743,8 +760,3 @@ class _MessagesMixin:
     # =========================================================================
     # Model Switching
     # =========================================================================
-    # SOOTHE: Slash command actions
-
-    def action_detach(self) -> None:
-        """Exit TUI but leave daemon running."""
-        self._detach_or_exit()

{soothe_cli-0.6.15 → soothe_cli-0.6.17}/src/soothe_cli/tui/app/_model.py

@@ -293,48 +293,6 @@ class _ModelMixin:
 
         self.push_screen(screen, handle_result)
 
-    async def _toggle_autopilot_mode(self) -> None:
-        """Toggle autopilot mode (solo ↔ autopilot) via daemon RPC.
-
-        Sends command_request to daemon and updates local dashboard mode.
-        """
-        from soothe_cli.tui.widgets.messages import ErrorMessage, UserMessage
-
-        await self._mount_message(UserMessage("/autopilot-toggle"))
-
-        lid = self._loop_id
-        if not lid:
-            await self._mount_message(ErrorMessage("No active loop for autopilot toggle"))
-            return
-
-        if not self._client:
-            await self._mount_message(ErrorMessage("Not connected to daemon"))
-            return
-
-        try:
-            from soothe_cli.tui.commands.command_router import handle_rpc_command
-            from soothe_cli.tui.commands.slash_commands import COMMANDS
-
-            entry = COMMANDS.get("/autopilot-toggle")
-            if not entry:
-                await self._mount_message(ErrorMessage("Command /autopilot-toggle not found"))
-                return
-
-            await handle_rpc_command(
-                entry,
-                "autopilot-toggle",
-                None,
-                self._console,
-                self._client,
-                loop_id=lid,
-            )
-            new_mode = "solo" if self._loop_autopilot_mode == "autopilot" else "autopilot"
-            self._apply_loop_autopilot_mode(new_mode)
-
-        except Exception as exc:
-            logger.exception("Autopilot toggle failed")
-            await self._mount_message(ErrorMessage(f"Failed to toggle autopilot: {exc}"))
-
     async def _submit_autopilot_job(self, task: str) -> None:
         """Submit an autopilot job via WebSocket (like CLI `soothe autopilot run`).
 

{soothe_cli-0.6.15 → soothe_cli-0.6.17}/src/soothe_cli/tui/command_registry.py

@@ -222,22 +222,6 @@ IMMEDIATE_UI: frozenset[str] = _build_bypass_set(BypassTier.IMMEDIATE_UI)
 SIDE_EFFECT_FREE: frozenset[str] = _build_bypass_set(BypassTier.SIDE_EFFECT_FREE)
 """Commands whose side effect fires immediately; chat output deferred until idle."""
 
-QUEUE_BOUND: frozenset[str] = _build_bypass_set(BypassTier.QUEUED)
-"""Commands that must wait in the queue when the app is busy."""
-
-HIDDEN_DEBUG: frozenset[str] = frozenset({"/debug-error"})
-"""Hidden debug commands not exposed in autocomplete or help."""
-
-ALL_CLASSIFIED: frozenset[str] = (
-    ALWAYS_IMMEDIATE
-    | BYPASS_WHEN_CONNECTING
-    | IMMEDIATE_UI
-    | SIDE_EFFECT_FREE
-    | QUEUE_BOUND
-    | HIDDEN_DEBUG
-)
-"""Union of all tiers plus hidden debug commands — used by drift tests."""
-
 
 # ---------------------------------------------------------------------------
 # Autocomplete tuples