soothe-cli 0.7.10__tar.gz → 0.7.12__tar.gz

{soothe_cli-0.7.10 → soothe_cli-0.7.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.7.10
+Version: 0.7.12
 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.7.12/src/soothe_cli/__init__.py

@@ -0,0 +1,5 @@
+"""Soothe CLI client - communicates with daemon via WebSocket."""
+
+from soothe_cli.tui._version import __version__
+
+__all__ = ["__version__"]

{soothe_cli-0.7.10 → soothe_cli-0.7.12}/src/soothe_cli/cli/main.py

@@ -6,7 +6,6 @@ from dotenv import load_dotenv
 
 load_dotenv()
 
-from importlib.metadata import version  # noqa: E402
 from pathlib import Path  # noqa: E402
 from typing import Annotated  # noqa: E402
 
@@ -15,6 +14,7 @@ from soothe_sdk.client.config import SOOTHE_HOME  # noqa: E402
 
 from soothe_cli.config.cli_config import CLIConfig  # noqa: E402
 from soothe_cli.config.loader import set_runtime_config  # noqa: E402
+from soothe_cli.tui._version import __version__  # noqa: E402
 from soothe_cli.tui.markdown_theme import (  # noqa: E402
     DEFAULT_MARKDOWN_THEME,
     REGISTRY,
@@ -177,7 +177,7 @@ def main(
 
     # Handle --version flag
     if show_version:
-        typer.echo(f"soothe {version('soothe-cli')}")
+        typer.echo(f"soothe {__version__}")
         raise typer.Exit
 
     home_path = Path(soothe_home).expanduser() if soothe_home else Path(SOOTHE_HOME)

{soothe_cli-0.7.10 → soothe_cli-0.7.12}/src/soothe_cli/runtime/presentation/duration_format.py

@@ -4,13 +4,15 @@ from __future__ import annotations
 
 
 def format_duration(seconds: float) -> str:
-    """Format a duration in seconds into a human-readable string.
+    """Format a completed duration in seconds into a human-readable string.
 
     Args:
         seconds: Duration in seconds.
 
     Returns:
-        Formatted string like `"5s"`, `"2.3s"`, `"5m 12s"`, or `"1h 23m 4s"`.
+        Formatted string like ``5s``, ``2.3s``, ``5m 12s``, or ``1h 23m 4s``.
+        For live running timers that tick in whole seconds, use
+        :func:`format_running_elapsed` instead.
     """
     rounded = round(seconds, 1)
     if rounded < 60:  # noqa: PLR2004
@@ -24,6 +26,11 @@ def format_duration(seconds: float) -> str:
     return f"{hours}h {minutes}m {secs}s"
 
 
+def format_running_elapsed(seconds: float) -> str:
+    """Format a live running timer using whole-second ticks (e.g. ``20s``, ``1m 5s``)."""
+    return format_duration(float(max(0, int(seconds))))
+
+
 def format_duration_ms(milliseconds: int) -> str:
     """Format a wall-clock duration in milliseconds for status lines and cards.
 

{soothe_cli-0.7.10 → soothe_cli-0.7.12}/src/soothe_cli/runtime/state/step_router.py

@@ -174,9 +174,8 @@ class StepTaskRouter:
     ) -> 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.
+        Future steps are not pre-mounted in the message list; only the active step
+        may transition to ``running`` before ``step.started`` when tools arrive early.
         """
         if getattr(step_w, "_status", "") != "pending":
             return

soothe_cli-0.7.12/src/soothe_cli/tui/_version.py

@@ -0,0 +1,128 @@
+"""Version information and lightweight constants for `soothe`."""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from importlib.metadata import PackageNotFoundError, distribution, version
+from pathlib import Path
+from urllib.parse import unquote, urlparse
+
+logger = logging.getLogger(__name__)
+
+_VERSION_PATTERN = re.compile(r"^(\d+\.\d+\.\d+)")
+
+
+def _parse_version_file_text(text: str) -> str | None:
+    """Extract the semver from a repo ``VERSION`` file."""
+    for line in text.splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+        match = _VERSION_PATTERN.match(stripped)
+        if match:
+            return match.group(1)
+    return None
+
+
+def _editable_source_roots() -> list[Path]:
+    """Return resolved source roots for editable Soothe packages."""
+    roots: list[Path] = []
+    seen: set[Path] = set()
+    for dist_name in ("soothe-cli", "soothe", "Soothe"):
+        try:
+            dist = distribution(dist_name)
+        except PackageNotFoundError:
+            continue
+        try:
+            raw = dist.read_text("direct_url.json")
+        except (FileNotFoundError, OSError):
+            continue
+        if not raw:
+            continue
+        try:
+            data = json.loads(raw)
+        except json.JSONDecodeError:
+            logger.debug("Invalid direct_url.json for %s", dist_name, exc_info=True)
+            continue
+        if not data.get("dir_info", {}).get("editable"):
+            continue
+        url = data.get("url", "")
+        if not url.startswith("file://"):
+            continue
+        root = Path(unquote(urlparse(url).path)).resolve()
+        if root not in seen:
+            seen.add(root)
+            roots.append(root)
+    return roots
+
+
+def _read_repo_version_from_source(root: Path) -> str | None:
+    """Read the monorepo ``VERSION`` file for an editable install root."""
+    candidates = [root.parent.parent / "VERSION", *(parent / "VERSION" for parent in root.parents)]
+    for path in candidates:
+        if not path.is_file():
+            continue
+        try:
+            parsed = _parse_version_file_text(path.read_text(encoding="utf-8"))
+        except OSError:
+            logger.debug("Failed to read VERSION file at %s", path, exc_info=True)
+            continue
+        if parsed:
+            return parsed
+    return None
+
+
+def _resolve_version() -> str:
+    """Resolve the CLI version, preferring repo ``VERSION`` for editable installs."""
+    for root in _editable_source_roots():
+        repo_version = _read_repo_version_from_source(root)
+        if repo_version:
+            return repo_version
+
+    for pkg in ("soothe-cli", "soothe"):
+        try:
+            return version(pkg)
+        except PackageNotFoundError:
+            continue
+    return "0.0.0"
+
+
+def is_editable_install() -> bool:
+    """Return whether Soothe is installed in editable mode."""
+    return bool(_editable_source_roots())
+
+
+def editable_install_display_path() -> str | None:
+    """Return a ``~``-contracted source path for editable installs."""
+    roots = _editable_source_roots()
+    if not roots:
+        return None
+
+    install_root = roots[0]
+    for root in roots:
+        if root.name == "soothe-cli":
+            install_root = root
+            break
+
+    path = str(install_root)
+    home = str(Path.home())
+    if path.startswith(home):
+        return "~" + path[len(home) :]
+    return path
+
+
+__version__ = _resolve_version()
+
+DOCS_URL = "https://github.com/mirasoth/soothe/docs"
+"""URL for Soothe documentation."""
+
+PYPI_URL = "https://pypi.org/pypi/soothe/json"
+"""PyPI JSON API endpoint for version checks."""
+
+CHANGELOG_URL = "https://github.com/mirasoth/soothe/blob/main/CHANGELOG.md"
+"""URL for the full changelog."""
+
+USER_AGENT = f"soothe/{__version__} update-check"
+"""User-Agent header sent with PyPI requests."""

{soothe_cli-0.7.10 → soothe_cli-0.7.12}/src/soothe_cli/tui/app/_execution.py

@@ -533,36 +533,9 @@ class _ExecutionMixin:
             await self._open_url_command(command, cmd)
         elif cmd == "/version":
             await self._mount_message(UserMessage(command))
-            # Show CLI and SDK package versions
-            try:
-                from soothe_cli.tui._version import (
-                    __version__ as cli_version,
-                )
-
-                cli_line = f"Soothe version: {cli_version}"
-            except ImportError:
-                logger.debug("soothe._version module not found")
-                cli_line = "Soothe version: unknown"
-            except Exception:
-                logger.warning("Unexpected error looking up CLI version", exc_info=True)
-                cli_line = "Soothe version: unknown"
-            try:
-                from importlib.metadata import (
-                    PackageNotFoundError,
-                )
-                from importlib.metadata import (
-                    version as _pkg_version,
-                )
+            from soothe_cli.tui._version import __version__ as cli_version
 
-                sdk_version = _pkg_version("Soothe")
-                sdk_line = f"Soothe (SDK) version: {sdk_version}"
-            except PackageNotFoundError:
-                logger.debug("Soothe SDK package not found in environment")
-                sdk_line = "Soothe (SDK) version: unknown"
-            except Exception:
-                logger.warning("Unexpected error looking up SDK version", exc_info=True)
-                sdk_line = "Soothe (SDK) version: unknown"
-            await self._mount_message(AppMessage(f"{cli_line}\n{sdk_line}"))
+            await self._mount_message(AppMessage(f"Soothe version: {cli_version}"))
         elif cmd == "/clear":
             self._pending_messages.clear()
             self._queued_widgets.clear()

{soothe_cli-0.7.10 → soothe_cli-0.7.12}/src/soothe_cli/tui/app/_startup.py

@@ -119,6 +119,9 @@ class _StartupMixin:
         gc.freeze()
 
         chat = self.query_one("#chat", VerticalScroll)
+        # Transcript scrolling is mouse-driven; keeping the region unfocusable
+        # prevents clicks in the message area from stealing the chat prompt caret.
+        chat.can_focus = False
         chat.anchor()
 
         self._status_bar = self.query_one("#status-bar", StatusBar)

{soothe_cli-0.7.10 → soothe_cli-0.7.12}/src/soothe_cli/tui/config.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import importlib
-import json
 import logging
 import os
 import re
@@ -11,14 +10,19 @@ import sys
 import threading
 from dataclasses import dataclass
 from enum import StrEnum
-from importlib.metadata import PackageNotFoundError, distribution
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
-from urllib.parse import unquote, urlparse
 
 from soothe_sdk.client.config import SOOTHE_HOME
 
-from soothe_cli.tui._version import __version__
+from soothe_cli.tui._version import (
+    __version__,
+)
+from soothe_cli.tui._version import (
+    is_editable_install as _is_editable_install,
+)
+
+__all__ = ["_is_editable_install"]
 
 logger = logging.getLogger(__name__)
 
@@ -330,67 +334,6 @@ ASCII_GLYPHS = Glyphs(
 _glyphs_cache: Glyphs | None = None
 """Module-level cache for detected glyphs."""
 
-_editable_cache: tuple[bool, str | None] | None = None
-"""Module-level cache for editable install info: (is_editable, source_path)."""
-
-
-def _resolve_editable_info() -> tuple[bool, str | None]:
-    """Parse PEP 610 `direct_url.json` once and cache both results.
-
-    Returns:
-        Tuple of (is_editable, contracted_source_path). The path is
-        `~`-contracted when it falls under the user's home directory, or
-        `None` when the install is non-editable or the path is unavailable.
-    """
-    global _editable_cache  # noqa: PLW0603  # Module-level cache requires global statement
-    if _editable_cache is not None:
-        return _editable_cache
-
-    editable = False
-    path: str | None = None
-
-    try:
-        dist = distribution("Soothe")
-        raw = dist.read_text("direct_url.json")
-        if raw:
-            data = json.loads(raw)
-            editable = data.get("dir_info", {}).get("editable", False)
-            if editable:
-                url = data.get("url", "")
-                if url.startswith("file://"):
-                    path = unquote(urlparse(url).path)
-                    home = str(Path.home())
-                    if path.startswith(home):
-                        path = "~" + path[len(home) :]
-    except (PackageNotFoundError, FileNotFoundError, json.JSONDecodeError, TypeError):
-        logger.debug(
-            "Failed to read editable install info from PEP 610 metadata",
-            exc_info=True,
-        )
-
-    _editable_cache = (editable, path)
-    return _editable_cache
-
-
-def _is_editable_install() -> bool:
-    """Check if Soothe is installed in editable mode.
-
-    Uses PEP 610 `direct_url.json` metadata to detect editable installs.
-
-    Returns:
-        `True` if installed in editable mode, `False` otherwise.
-    """
-    return _resolve_editable_info()[0]
-
-
-def _get_editable_install_path() -> str | None:
-    """Return the `~`-contracted source directory for an editable install.
-
-    Returns `None` for non-editable installs or when the path cannot be
-    determined.
-    """
-    return _resolve_editable_info()[1]
-
 
 def _detect_charset_mode() -> CharsetMode:
     """Auto-detect terminal charset capabilities.
@@ -544,19 +487,10 @@ def build_stream_config(
 ) -> RunnableConfig:
     """Build the LangGraph stream config dict.
 
-    Injects CLI and SDK versions into `metadata["versions"]` so runs can be
-    correlated with specific releases.
-
-    Why the CLI sets *both* versions:
-
-    * `create_deep_agent` bakes `versions: {"Soothe": "X.Y.Z"}` into the
-        compiled graph via `with_config`. At stream time, LangGraph merges
-        the graph config with the runtime config passed here. Because the
-        metadata merge is shallow (effectively `{**graph_meta, **runtime_meta}`
-        for top-level keys), both configs containing a `versions` key means
-        the runtime dict **replaces** the graph dict entirely — the SDK
-        version would be lost.
-    * Including the SDK version here ensures it survives the merge.
+    Injects the resolved Soothe version into ``metadata["versions"]`` so runs
+    can be correlated with specific releases. The runtime config replaces the
+    graph config's ``versions`` key at stream time, so this must carry the
+    canonical release string.
 
     Args:
         loop_id: Active StrangeLoop id (stored under LangGraph ``configurable.thread_id``).
@@ -571,8 +505,6 @@ def build_stream_config(
     Returns:
         Config dict with `configurable` and `metadata` keys.
     """
-    import contextlib
-    import importlib.metadata as importlib_metadata
     from datetime import UTC, datetime
 
     try:
@@ -581,13 +513,8 @@ def build_stream_config(
         logger.warning("Could not determine working directory", exc_info=True)
         cwd = ""
 
-    # Include SDK version alongside CLI version — see docstring for why.
-    versions: dict[str, str] = {"Soothe": __version__}
-    with contextlib.suppress(importlib_metadata.PackageNotFoundError):
-        versions["Soothe"] = importlib_metadata.version("Soothe")
-
     metadata: dict[str, Any] = {
-        "versions": versions,
+        "versions": {"Soothe": __version__},
     }
     from soothe_cli.tui._env_vars import USER_ID
 

{soothe_cli-0.7.10 → soothe_cli-0.7.12}/src/soothe_cli/tui/preview_limits.py

@@ -15,7 +15,7 @@ from typing import Final
 STEP_CARD_SHOW_TOOL_ROW_DETAILS: Final[bool] = False
 
 # Latest per-tool invocation lines on step and SubAgent cards (shared activity tree).
-STEP_CARD_TOOL_ACTIVITY_PREVIEW_COUNT: Final[int] = 3
+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

{soothe_cli-0.7.10 → soothe_cli-0.7.12}/src/soothe_cli/tui/textual_adapter.py

@@ -298,9 +298,6 @@ class TextualUIAdapter:
         self._execute_wave_completed: int = 0
         """Completed steps in the current execute batch."""
 
-        self._successful_step_ids: set[str] = set()
-        """Step ids that finished successfully this loop (survives plan=keep replays)."""
-
         self._clarification_input_by_step: dict[str, ClarificationInputMessage] = {}
         """Active inline ``ClarificationInputMessage`` widgets keyed by step id.
 
@@ -406,7 +403,7 @@ def _stream_end_pending_error_message(
     if is_daemon_worker_thread_lost(err_msg) or is_daemon_worker_subprocess_lost(err_msg):
         return "Worker stopped during stream"
     if end_state == "idle" and any(
-        getattr(widget, "_status", "") in {"running", "queued"}
+        getattr(widget, "_status", "") == "running"
         for widget in adapter._current_step_messages.values()
     ):
         return "Stream ended before steps completed"
@@ -1448,12 +1445,16 @@ async def _ensure_goal_tree_message(
     return widget
 
 
-async def sync_pending_step_cards_from_plan(
+async def cleanup_stale_plan_step_cards(
     adapter: TextualUIAdapter,
     *,
     steps: list[dict[str, Any]],
 ) -> None:
-    """Mount step cards in ``pending`` state for planned steps not yet executing."""
+    """Drop stale pending step cards after replan; do not mount future steps.
+
+    Planned and queued steps appear only in the Ctrl+T plan quick view (goal tree).
+    Step cards mount in the message list when ``step_started`` fires.
+    """
     planned_ids = {
         str(row.get("id", "")).strip()
         for row in steps
@@ -1468,23 +1469,6 @@ async def sync_pending_step_cards_from_plan(
                 if bound is widget:
                     adapter._step_by_namespace.pop(ns, None)
 
-    for row in steps:
-        if not isinstance(row, dict):
-            continue
-        sid = str(row.get("id", "")).strip()
-        if not sid or sid in adapter._current_step_messages:
-            continue
-        if _is_successful_step_id(adapter, sid):
-            continue
-        desc = str(row.get("description", "")).strip() or "(step)"
-        step_widget = CognitionStepMessage(
-            step_id=sid,
-            description=desc,
-            id=f"step-{uuid.uuid4().hex[:8]}",
-        )
-        await adapter._mount_message(step_widget)
-        adapter._current_step_messages[sid] = step_widget
-
 
 def _step_card_lookup_keys(step_id: str) -> list[str]:
     """Return dict lookup keys for a step id (canonical and wire variants)."""
@@ -1501,17 +1485,6 @@ def _step_card_lookup_keys(step_id: str) -> list[str]:
     return keys
 
 
-def _register_successful_step_id(adapter: TextualUIAdapter, step_id: str) -> None:
-    """Remember a step that completed successfully so plan=keep does not remount it."""
-    for key in _step_card_lookup_keys(step_id):
-        adapter._successful_step_ids.add(key)
-
-
-def _is_successful_step_id(adapter: TextualUIAdapter, step_id: str) -> bool:
-    """True when this step already succeeded earlier in the current loop."""
-    return any(key in adapter._successful_step_ids for key in _step_card_lookup_keys(step_id))
-
-
 def _lookup_step_card(
     adapter: TextualUIAdapter,
     step_id: str,
@@ -2856,7 +2829,6 @@ async def execute_task_textual(
     router.reset_turn()
     adapter._execute_wave_total = 0
     adapter._execute_wave_completed = 0
-    adapter._successful_step_ids.clear()
     ui_coalesce = TurnToolUiCoalescer()
     adapter._goal_completion_mounted_this_turn = False
     adapter._goal_tree_message = None
@@ -3865,7 +3837,7 @@ async def execute_task_textual(
                                         done_steps,
                                         len(raw_steps),
                                     )
-                                    await sync_pending_step_cards_from_plan(
+                                    await cleanup_stale_plan_step_cards(
                                         adapter,
                                         steps=raw_steps,
                                     )
@@ -3883,26 +3855,13 @@ async def execute_task_textual(
                             if event_type == STRANGE_LOOP_STEP_QUEUED:
                                 step_id = str(data.get("step_id", "")).strip()
                                 description = str(data.get("description", "")).strip()
-                                if step_id:
-                                    step_widget = adapter._current_step_messages.get(step_id)
-                                    if step_widget is None:
-                                        step_widget = CognitionStepMessage(
-                                            step_id=step_id,
-                                            description=description or "(step)",
-                                            id=f"step-{uuid.uuid4().hex[:8]}",
-                                        )
-                                        await adapter._mount_message(step_widget)
-                                        adapter._current_step_messages[step_id] = step_widget
-                                    elif description:
-                                        step_widget.set_description(description)
-                                    step_widget.set_queued()
-                                    if not ns_key:
-                                        _sync_goal_tree_step_phase(
-                                            adapter,
-                                            step_id,
-                                            "queued",
-                                            description=description,
-                                        )
+                                if step_id and not ns_key:
+                                    _sync_goal_tree_step_phase(
+                                        adapter,
+                                        step_id,
+                                        "queued",
+                                        description=description,
+                                    )
                                 continue
 
                             if event_type == STRANGE_LOOP_STEP_STARTED:
@@ -4018,8 +3977,6 @@ async def execute_task_textual(
                                         pending_text_by_namespace[ns_key] = ""
                                         assistant_message_by_namespace.pop(ns_key, None)
                                     success = bool(data.get("success", True))
-                                    if success:
-                                        _register_successful_step_id(adapter, step_id)
                                     duration_ms = int(data.get("duration_ms", 0))
                                     tool_call_count = int(data.get("tool_call_count", 0))
                                     summary = str(

{soothe_cli-0.7.10 → soothe_cli-0.7.12}/src/soothe_cli/tui/widgets/loading.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING
 from textual.content import Content
 from textual.widgets import Static
 
-from soothe_cli.runtime.presentation.duration_format import format_duration
+from soothe_cli.runtime.presentation.duration_format import format_running_elapsed
 from soothe_cli.tui import theme
 from soothe_cli.tui.config import get_glyphs
 
@@ -101,7 +101,7 @@ class LoadingWidget(Static):
         return f" {status}... "
 
     def _format_hint_line(self, elapsed_secs: float, *, include_interrupt: bool = False) -> str:
-        duration = format_duration(elapsed_secs)
+        duration = format_running_elapsed(elapsed_secs)
         segments: list[str] = []
         if self._hint_extra:
             segments.append(self._hint_extra)
@@ -121,7 +121,7 @@ class LoadingWidget(Static):
         status_part = Content.styled(self._format_status_line(self._status), colors.primary)
         if self._paused:
             spinner_part = Content.styled(get_glyphs().pause, "dim")
-            paused_duration = format_duration(float(self._paused_total_elapsed))
+            paused_duration = format_running_elapsed(float(self._paused_total_elapsed))
             if self._show_interrupt_hint:
                 paused_hint = f" (paused at {paused_duration} · esc to interrupt)"
             else:

{soothe_cli-0.7.10 → soothe_cli-0.7.12}/src/soothe_cli/tui/widgets/messages/cognition_goal_tree.py

@@ -11,7 +11,7 @@ from textual.containers import Vertical
 from textual.content import Content
 from textual.widgets import Static
 
-from soothe_cli.runtime.presentation.duration_format import format_duration
+from soothe_cli.runtime.presentation.duration_format import format_duration, format_running_elapsed
 from soothe_cli.tui import theme
 from soothe_cli.tui.config import get_glyphs
 from soothe_cli.tui.preview_limits import PLAN_QUICK_VIEW_STEP_LINE_MAX_CHARS
@@ -253,8 +253,7 @@ class CognitionGoalTreeMessage(Vertical):
         if st.phase == "running":
             parts: list[str] = []
             if st.started_at is not None:
-                elapsed_s = max(0.001, time() - st.started_at)
-                parts.append(format_duration(elapsed_s))
+                parts.append(format_running_elapsed(time() - st.started_at))
             if st.tool_call_count > 0:
                 parts.append(f"{st.tool_call_count} tools")
             if not parts:

{soothe_cli-0.7.10 → soothe_cli-0.7.12}/src/soothe_cli/tui/widgets/messages/cognition_step.py

@@ -135,7 +135,7 @@ class CognitionStepMessage(Vertical):
         super().__init__(**kwargs)
         self._step_id = step_id
         self._description = description.strip()
-        self._status = "pending"  # pending | queued | running | success | error
+        self._status = "pending"  # pending | running | success | error
         self._spinner_position = 0
         self._start_time: float | None = None
         self._animation_timer: Timer | None = None
@@ -217,7 +217,7 @@ class CognitionStepMessage(Vertical):
             return
         self._input_tokens += input_tokens
         self._output_tokens += output_tokens
-        if self._status in ("running", "pending", "queued"):
+        if self._status in ("running", "pending"):
             self._sync_running_status_line()
 
     def _token_budget_suffix(self) -> str:
@@ -283,8 +283,6 @@ class CognitionStepMessage(Vertical):
             return
         if self._status == "running":
             self._ensure_running_ui()
-        elif self._status == "queued":
-            self._sync_step_card_surface()
         elif self._status == "pending":
             self._sync_step_card_surface()
 
@@ -466,8 +464,6 @@ class CognitionStepMessage(Vertical):
             self._sync_running_status_text(index)
         elif self._status == "pending":
             self._refresh_pending_display(index)
-        elif self._status == "queued":
-            self._refresh_queued_display(index)
 
         if STEP_CARD_SHOW_TOOL_ROW_DETAILS:
             self._refresh_tools_display()
@@ -1156,37 +1152,6 @@ class CognitionStepMessage(Vertical):
         )
         self._status_widget.display = True
 
-    def _refresh_queued_display(self, index: StepRowIndex | None = None) -> None:
-        """Show ready steps waiting for a concurrency slot (``max_parallel_steps``)."""
-        if self._status != "queued" or self._status_widget is None:
-            return
-        if index is None:
-            index = self._build_row_index()
-        try:
-            colors = theme.get_theme_colors(self)
-        except Exception:  # noqa: BLE001
-            colors = theme.DARK_COLORS
-        g = get_glyphs()
-        gutter = f"{g.output_prefix} "
-        self._status_widget.update(
-            StepCardStatusLine.footer_queued(
-                gutter=gutter,
-                circle_empty=g.circle_empty,
-                stats_suffix=stats_title_suffix(index),
-                token_suffix=self._token_budget_suffix(),
-                colors=colors,
-            )
-        )
-        self._status_widget.display = True
-
-    def set_queued(self) -> None:
-        """Mark a ready step as waiting for an execute batch slot."""
-        if self._status in ("running", "success", "error"):
-            return
-        self._status = "queued"
-        self._refresh_header_title()
-        self._sync_step_card_surface()
-
     def _maybe_start_running_timer(self) -> None:
         """Start the spinner timer when the step is running and mounted."""
         if self._status != "running":

{soothe_cli-0.7.10 → soothe_cli-0.7.12}/src/soothe_cli/tui/widgets/messages/cognition_step_activity.py

@@ -19,7 +19,7 @@ from soothe_sdk.ux.task_namespace import (
 )
 from textual.content import Content
 
-from soothe_cli.runtime.presentation.duration_format import format_duration
+from soothe_cli.runtime.presentation.duration_format import format_running_elapsed
 from soothe_cli.tui import theme
 from soothe_cli.tui.commands.subagent_routing import get_subagent_display_name
 from soothe_cli.tui.preview_limits import STEP_CARD_TOOL_ACTIVITY_PREVIEW_COUNT
@@ -433,7 +433,7 @@ class StepCardStatusLine:
         """Step card footer while executing."""
         elapsed = ""
         if elapsed_secs is not None:
-            elapsed = f" ({format_duration(float(elapsed_secs))})"
+            elapsed = f" ({format_running_elapsed(float(elapsed_secs))})"
         head = f"{gutter}{spinner_frame} Running{retry_suffix}...{elapsed}"
         tail = f"{stats_suffix}{token_suffix}"
         parts: list[object] = [Content.styled(head, colors.warning)]
@@ -458,23 +458,6 @@ class StepCardStatusLine:
             parts.append(Content.styled(tail, theme.SECONDARY_TEXT_STYLE))
         return Content.assemble(*parts)
 
-    @staticmethod
-    def footer_queued(
-        *,
-        gutter: str,
-        circle_empty: str,
-        stats_suffix: str,
-        token_suffix: str = "",
-        colors: Any,
-    ) -> Content:
-        """Step card footer for ready steps waiting for a concurrency slot."""
-        head = f"{gutter}{circle_empty} Queued..."
-        tail = f"{stats_suffix}{token_suffix}"
-        parts: list[object] = [Content.styled(head, colors.cognition)]
-        if tail:
-            parts.append(Content.styled(tail, theme.SECONDARY_TEXT_STYLE))
-        return Content.assemble(*parts)
-
 
 # Activity tree renderer
 # ---------------------------------------------------------------------------

{soothe_cli-0.7.10 → soothe_cli-0.7.12}/src/soothe_cli/tui/widgets/plan_quick_view_overlay.py

@@ -108,6 +108,7 @@ class PlanQuickViewOverlay(Vertical):
 
     def on_mount(self) -> None:
         self._content = self.query_one("#plan-quick-view-content", Static)
+        self.query_one("#plan-quick-view-body", VerticalScroll).can_focus = False
         self.display = False
 
     @property

soothe_cli-0.7.10/src/soothe_cli/__init__.py

@@ -1,10 +0,0 @@
-"""Soothe CLI client - communicates with daemon via WebSocket."""
-
-import importlib.metadata
-
-try:
-    __version__ = importlib.metadata.version("soothe-cli")
-except importlib.metadata.PackageNotFoundError:
-    __version__ = "0.0.0"
-
-__all__ = []

soothe_cli-0.7.10/src/soothe_cli/tui/_version.py

@@ -1,21 +0,0 @@
-"""Version information and lightweight constants for `soothe`."""
-
-from importlib.metadata import PackageNotFoundError, version
-
-try:
-    __version__ = version("soothe")
-except PackageNotFoundError:
-    # Fallback for development/editable installs
-    __version__ = "0.0.0"
-
-DOCS_URL = "https://github.com/mirasoth/soothe/docs"
-"""URL for Soothe documentation."""
-
-PYPI_URL = "https://pypi.org/pypi/soothe/json"
-"""PyPI JSON API endpoint for version checks."""
-
-CHANGELOG_URL = "https://github.com/mirasoth/soothe/blob/main/CHANGELOG.md"
-"""URL for the full changelog."""
-
-USER_AGENT = f"soothe/{__version__} update-check"
-"""User-Agent header sent with PyPI requests."""