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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soothe-cli
-Version: 0.7.12
+Version: 0.7.14
 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 → soothe_cli-0.7.14}/src/soothe_cli/cli/commands/run_cmd.py

@@ -100,7 +100,7 @@ def run_impl(
             result = get_last_app_result()
             if result is not None and result.loop_id:
                 typer.echo(
-                    f"💡 To continue this loop: soothe loop resume {result.loop_id}",
+                    f"💡 To continue: soothe loop resume {result.loop_id}",
                     err=True,
                 )
 
@@ -113,7 +113,7 @@ def run_impl(
             result = get_last_app_result()
             if result is not None and result.loop_id:
                 typer.echo(
-                    f"💡 To continue this loop: soothe loop resume {result.loop_id}",
+                    f"💡 To continue: soothe loop resume {result.loop_id}",
                     err=True,
                 )
         sys.exit(130)

soothe_cli-0.7.14/src/soothe_cli/runtime/token_events_debug.py

@@ -0,0 +1,180 @@
+"""Debug tracing for loop token events in the CLI TUI.
+
+Enable with ``logging_level: DEBUG`` in CLI config (``~/.soothe/config.yml``)
+or ``SOOTHE_LOG_LEVEL=DEBUG``. Grep ``cli.log`` for ``[token-events]``.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+
+logger = logging.getLogger("soothe_cli.token_events")
+
+
+@dataclass
+class TokenEventTrace:
+    """Per-turn counters for token-related daemon/TUI events."""
+
+    stream_chunks: int = 0
+    stream_input_tokens: int = 0
+    stream_output_tokens: int = 0
+    plan_phase_events: int = 0
+    plan_phase_with_total_field: int = 0
+    plan_phase_missing_total_field: int = 0
+    step_completed_events: int = 0
+    step_completed_with_total_field: int = 0
+    authoritative_applied: int = 0
+    authoritative_unchanged: int = 0
+    display_refreshes: int = 0
+    anomalies: list[str] = field(default_factory=list)
+
+    def reset(self) -> None:
+        """Clear counters for a new turn."""
+        self.stream_chunks = 0
+        self.stream_input_tokens = 0
+        self.stream_output_tokens = 0
+        self.plan_phase_events = 0
+        self.plan_phase_with_total_field = 0
+        self.plan_phase_missing_total_field = 0
+        self.step_completed_events = 0
+        self.step_completed_with_total_field = 0
+        self.authoritative_applied = 0
+        self.authoritative_unchanged = 0
+        self.display_refreshes = 0
+        self.anomalies.clear()
+
+    def note_stream_usage(
+        self, *, input_tokens: int, output_tokens: int, total_tokens: int
+    ) -> None:
+        """Record a messages-stream chunk carrying provider usage."""
+        self.stream_chunks += 1
+        self.stream_input_tokens += max(0, input_tokens)
+        self.stream_output_tokens += max(0, output_tokens)
+        logger.debug(
+            "[token-events] stream usage chunk #%d in=%d out=%d total=%d",
+            self.stream_chunks,
+            input_tokens,
+            output_tokens,
+            total_tokens,
+        )
+
+    def note_plan_phase(
+        self, *, label: str, total_tokens_used: int | None, has_total_field: bool
+    ) -> None:
+        """Record a StrangeLoop plan-phase lifecycle event."""
+        self.plan_phase_events += 1
+        if has_total_field:
+            self.plan_phase_with_total_field += 1
+        else:
+            self.plan_phase_missing_total_field += 1
+            self.anomalies.append(f"plan_phase missing total_tokens_used ({label!r})")
+        logger.debug(
+            "[token-events] plan_phase label=%r total=%s has_total_field=%s",
+            label,
+            total_tokens_used if has_total_field else "—",
+            has_total_field,
+        )
+
+    def note_step_completed(
+        self, *, step_id: str, total_tokens_used: int | None, has_total_field: bool
+    ) -> None:
+        """Record step.completed with optional backend loop total."""
+        self.step_completed_events += 1
+        if has_total_field:
+            self.step_completed_with_total_field += 1
+        logger.debug(
+            "[token-events] step_completed step_id=%s total=%s has_total_field=%s",
+            step_id or "—",
+            total_tokens_used if has_total_field else "—",
+            has_total_field,
+        )
+
+    def note_authoritative_merge(
+        self,
+        *,
+        source: str,
+        goal_run_total: int,
+        previous_goal_run: int,
+        applied: bool,
+        display_total: int,
+    ) -> None:
+        """Record backend total merged into the TUI loop counter."""
+        if applied:
+            self.authoritative_applied += 1
+        else:
+            self.authoritative_unchanged += 1
+        logger.debug(
+            "[token-events] authoritative source=%s goal_run=%d prev_goal_run=%d applied=%s display=%d",
+            source,
+            goal_run_total,
+            previous_goal_run,
+            applied,
+            display_total,
+        )
+
+    def note_display_refresh(self, *, display_total: int, target: str) -> None:
+        """Record a push to the thinking row or status bar."""
+        self.display_refreshes += 1
+        logger.debug(
+            "[token-events] display refresh target=%s total=%d refresh#%d",
+            target,
+            display_total,
+            self.display_refreshes,
+        )
+
+    def finish_turn(
+        self,
+        *,
+        loop_id: str | None,
+        baseline: int,
+        goal_run: int,
+        display_total: int,
+        turn_input: int,
+        turn_output: int,
+        approximate: bool,
+    ) -> None:
+        """Emit one summary line per turn; flags missing events."""
+        has_stream = self.stream_chunks > 0
+        has_backend_total = (
+            self.plan_phase_with_total_field > 0 or self.step_completed_with_total_field > 0
+        )
+        has_any_usage = display_total > 0 or turn_input > 0 or turn_output > 0
+
+        if has_any_usage and not has_stream and not has_backend_total:
+            self.anomalies.append("usage visible but no stream or backend total events")
+        if self.plan_phase_events > 0 and self.plan_phase_missing_total_field > 0:
+            self.anomalies.append(
+                f"{self.plan_phase_missing_total_field}/{self.plan_phase_events} plan_phase "
+                "events lacked total_tokens_used"
+            )
+        if not has_any_usage and (self.plan_phase_events or self.step_completed_events):
+            self.anomalies.append("lifecycle events seen but display total still zero")
+
+        status = "ok"
+        if self.anomalies:
+            status = "anomaly"
+        elif not has_stream and not has_backend_total and not has_any_usage:
+            status = "no_events"
+
+        logger.debug(
+            "[token-events] turn summary loop=%s status=%s baseline=%d goal_run=%d "
+            "display=%d turn_in=%d turn_out=%d stream_chunks=%d plan_phase=%d "
+            "step_completed=%d authoritative_applied=%d approximate=%s anomalies=%s",
+            loop_id or "—",
+            status,
+            baseline,
+            goal_run,
+            display_total,
+            turn_input,
+            turn_output,
+            self.stream_chunks,
+            self.plan_phase_events,
+            self.step_completed_events,
+            self.authoritative_applied,
+            approximate,
+            "; ".join(self.anomalies) if self.anomalies else "none",
+        )
+
+
+__all__ = ["TokenEventTrace", "logger"]

soothe_cli-0.7.14/src/soothe_cli/runtime/token_usage.py

@@ -0,0 +1,119 @@
+"""Token usage extraction and estimation helpers for the TUI."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+__all__ = [
+    "coerce_total_tokens_used",
+    "extract_stream_message_token_usage",
+    "fetch_conversation_token_count",
+    "message_has_token_usage_metadata",
+]
+
+
+def coerce_total_tokens_used(value: Any) -> int:
+    """Parse a non-negative ``total_tokens_used`` field from event payloads."""
+    try:
+        return max(0, int(value or 0))
+    except (TypeError, ValueError):
+        return 0
+
+
+def _coerce_int(value: Any) -> int:
+    return coerce_total_tokens_used(value)
+
+
+def _usage_from_mapping(usage: dict[str, Any]) -> tuple[int, int, int]:
+    """Return ``(input_tokens, output_tokens, total_tokens)`` from a usage dict."""
+    input_toks = _coerce_int(usage.get("input_tokens") or usage.get("prompt_tokens"))
+    output_toks = _coerce_int(usage.get("output_tokens") or usage.get("completion_tokens"))
+    total_toks = _coerce_int(usage.get("total_tokens"))
+    if not total_toks and (input_toks or output_toks):
+        total_toks = input_toks + output_toks
+    return input_toks, output_toks, total_toks
+
+
+def extract_stream_message_token_usage(message: Any) -> tuple[int, int, int]:
+    """Extract token usage from a streamed LangChain or wire-format message.
+
+    Providers vary:
+    - LangChain ``usage_metadata`` (``input_tokens`` / ``output_tokens``)
+    - OpenAI-style ``response_metadata.token_usage`` (``prompt_tokens`` / ``completion_tokens``)
+    - Flat wire dicts with either shape
+    """
+    if message is None:
+        return 0, 0, 0
+
+    usage = getattr(message, "usage_metadata", None)
+    if isinstance(usage, dict) and usage:
+        return _usage_from_mapping(usage)
+
+    response_metadata = getattr(message, "response_metadata", None)
+    if isinstance(response_metadata, dict):
+        for key in ("token_usage", "usage"):
+            nested = response_metadata.get(key)
+            if isinstance(nested, dict) and nested:
+                return _usage_from_mapping(nested)
+
+    if isinstance(message, dict):
+        from soothe_cli.runtime.wire.message_text import wire_message_body
+
+        bodies = [message]
+        nested = wire_message_body(message)
+        if nested is not message:
+            bodies.append(nested)
+        for body in bodies:
+            if not isinstance(body, dict):
+                continue
+            direct_usage = body.get("usage_metadata")
+            if isinstance(direct_usage, dict) and direct_usage:
+                return _usage_from_mapping(direct_usage)
+            response = body.get("response_metadata")
+            if isinstance(response, dict):
+                for key in ("token_usage", "usage"):
+                    nested_usage = response.get(key)
+                    if isinstance(nested_usage, dict) and nested_usage:
+                        return _usage_from_mapping(nested_usage)
+
+    return 0, 0, 0
+
+
+def message_has_token_usage_metadata(message: Any) -> bool:
+    """Return True when a stream message carries provider token usage."""
+    input_toks, output_toks, total_toks = extract_stream_message_token_usage(message)
+    return bool(input_toks or output_toks or total_toks)
+
+
+async def fetch_conversation_token_count(daemon_session: Any, loop_id: str | None) -> int | None:
+    """Return approximate conversation-only token count from loop checkpoint messages."""
+    raw_loop_id = str(loop_id or "").strip()
+    if not raw_loop_id or daemon_session is None:
+        return None
+    try:
+        from langchain_core.messages import messages_from_dict
+        from langchain_core.messages.utils import count_tokens_approximately
+
+        snap = await daemon_session.aget_loop_state(raw_loop_id)
+        vals = getattr(snap, "values", None)
+        if not isinstance(vals, dict):
+            return None
+        raw = vals.get("messages")
+        if not isinstance(raw, list) or not raw:
+            return None
+        if isinstance(raw[0], dict):
+            messages = messages_from_dict(raw)
+        else:
+            messages = raw
+        count = count_tokens_approximately(messages)
+        return count if count > 0 else None
+    except Exception:
+        logger.debug(
+            "Failed to retrieve conversation token count for loop %s",
+            raw_loop_id,
+            exc_info=True,
+        )
+        return None

{soothe_cli-0.7.12 → soothe_cli-0.7.14}/src/soothe_cli/runtime/transport/session.py

@@ -321,6 +321,7 @@ class TuiDaemonSession:
         inbound_dropped_baseline = getattr(self._client, "inbound_dropped", 0)
         query_started = False
         expected_loop_id = self._loop_id
+        stream_payload_seen = False
         self._streaming = True
         turn_read_started = time.monotonic()
         first_event_logged = False
@@ -405,7 +406,20 @@ class TuiDaemonSession:
                         if state == "running":
                             query_started = True
                             progress_seen = True
-                        elif query_started and state in {"idle", "stopped"}:
+                        elif query_started and state == "stopped":
+                            self.last_turn_end_state = state
+                            async for chunk in self._drain_stream_events_after_idle(
+                                expected_loop_id=expected_loop_id,
+                            ):
+                                yield chunk
+                            break
+                        elif query_started and state == "idle":
+                            if not stream_payload_seen and not self.last_turn_cancellation_seen:
+                                logger.debug(
+                                    "Ignoring stale idle before stream payload (loop=%s)",
+                                    (expected_loop_id or "?")[:16],
+                                )
+                                continue
                             self.last_turn_end_state = state
                             async for chunk in self._drain_stream_events_after_idle(
                                 expected_loop_id=expected_loop_id,
@@ -430,6 +444,7 @@ class TuiDaemonSession:
                         self.turn_event_stats.filtered_early += 1
                         continue
                     progress_seen = True
+                    stream_payload_seen = True
                     yield (namespace, mode, data)
                     # Graph auto-resumes LangGraph interrupts server-side; keep consuming events.
                     if mode == "updates" and isinstance(data, dict) and "__interrupt__" in data:

{soothe_cli-0.7.12 → soothe_cli-0.7.14}/src/soothe_cli/runtime/wire/chunk_filter.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from typing import Any
 
+from soothe_cli.runtime.token_usage import message_has_token_usage_metadata
 from soothe_cli.runtime.wire.message_text import (
     extract_plain_text_from_stream_message,
     wire_message_body,
@@ -73,6 +74,8 @@ def message_chunk_is_non_actionable(data: Any) -> bool:
 
     if isinstance(msg, ToolMessage):
         return False
+    if message_has_token_usage_metadata(msg):
+        return False
     if isinstance(msg, dict):
         body = wire_message_body(msg)
         raw = str(body.get("type") or msg.get("type") or "")

{soothe_cli-0.7.12 → soothe_cli-0.7.14}/src/soothe_cli/tui/app/_app.py

@@ -253,12 +253,17 @@ class SootheApp(
         self._connect_spinner_start_mono: float | None = None
         """Monotonic anchor for startup daemon-connect elapsed time in the thinking row."""
 
-        self._context_tokens: int = 0
-        """Local cache of the last total-context token count.
+        self._loop_token_scope_id: str | None = None
+        """Loop id that ``_loop_*_tokens`` counters belong to."""
 
-        Source of truth is `_context_tokens` in graph state; this is a sync
-        copy for the status bar.
-        """
+        self._loop_baseline_tokens: int = 0
+        """Persisted loop usage total loaded from checkpoint (resume baseline)."""
+
+        self._loop_input_tokens: int = 0
+        """Input tokens for the in-flight goal/turn (stream or backend)."""
+
+        self._loop_output_tokens: int = 0
+        """Output tokens for the in-flight goal/turn (stream or backend)."""
 
         self._tokens_approximate: bool = False
         """Whether the cached token count is stale (interrupted generation)."""

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

@@ -25,7 +25,7 @@ from soothe_cli.cli.execution.daemon_errors import (
 from soothe_cli.cli.execution.daemon_errors import (
     friendly_daemon_execution_error as _friendly_agent_execution_error,
 )
-from soothe_cli.runtime.state.session_stats import SessionStats, format_token_count
+from soothe_cli.runtime.state.session_stats import SessionStats
 from soothe_cli.tui import theme
 from soothe_cli.tui._cli_context import CLIContext
 from soothe_cli.tui.app._module_init import (
@@ -450,37 +450,6 @@ class _ExecutionMixin:
         """
         return f"{prefix}: {loop_id}"
 
-    async def _get_conversation_token_count(self) -> int | None:
-        """Return the approximate conversation-only token count.
-
-        Returns:
-            Token count as an integer, or `None` if state is unavailable.
-        """
-        if not self._lc_loop_id:
-            return None
-        try:
-            from langchain_core.messages import messages_from_dict
-            from langchain_core.messages.utils import count_tokens_approximately
-
-            if self._daemon_session is None:
-                return None
-            snap = await self._daemon_session.aget_loop_state(self._lc_loop_id)
-            vals = getattr(snap, "values", None)
-            if not isinstance(vals, dict):
-                return None
-            raw = vals.get("messages")
-            if not isinstance(raw, list) or not raw:
-                return None
-            if isinstance(raw[0], dict):
-                messages = messages_from_dict(raw)
-            else:
-                messages = raw
-
-            return count_tokens_approximately(messages)
-        except Exception:  # best-effort for /tokens display
-            logger.debug("Failed to retrieve conversation token count", exc_info=True)
-            return None
-
     async def _handle_command(self, command: str) -> None:
         """Handle a slash command.
 
@@ -516,9 +485,11 @@ class _ExecutionMixin:
                     self.query_one("#chat", VerticalScroll).anchor()
                 return
 
+        from soothe_cli.tui.command_registry import resolve_command_head
         from soothe_cli.tui.config import settings
 
         cmd = command.lower().strip()
+        cmd_head = resolve_command_head(command)
 
         if cmd in {"/quit", "/q"}:
             self._detach_or_exit()
@@ -540,9 +511,7 @@ class _ExecutionMixin:
             self._pending_messages.clear()
             self._queued_widgets.clear()
             await self._clear_messages()
-            self._context_tokens = 0
-            self._tokens_approximate = False
-            self._update_tokens(0)
+            self._reset_loop_token_usage(None)
             # Clear status message (e.g., "Interrupted" from previous session)
             self._update_status("")
             if self._session_state:
@@ -564,6 +533,7 @@ class _ExecutionMixin:
                     )
                     self._session_state.loop_id = new_loop_id
                     self._lc_loop_id = new_loop_id
+                    self._reset_loop_token_usage(new_loop_id)
                     try:
                         banner = self.query_one("#welcome-banner", WelcomeBanner)
                         banner.update_loop_id(new_loop_id)
@@ -579,51 +549,8 @@ class _ExecutionMixin:
             await self._handle_update_command()
         elif cmd == "/auto-update":
             await self._handle_auto_update_toggle()
-        elif cmd == "/tokens":
-            await self._mount_message(UserMessage(command))
-            if self._context_tokens > 0:
-                count = self._context_tokens
-                formatted = format_token_count(count)
-
-                model_name = settings.model_name
-                context_limit = settings.model_context_limit
-
-                if context_limit is not None:
-                    limit_str = format_token_count(context_limit)
-                    pct = count / context_limit * 100
-                    usage = f"{formatted} / {limit_str} tokens ({pct:.0f}%)"
-                else:
-                    usage = f"{formatted} tokens used"
-
-                msg = f"{usage} \u00b7 {model_name}" if model_name else usage
-
-                conv_tokens = await self._get_conversation_token_count()
-                if conv_tokens is not None:
-                    overhead = max(0, count - conv_tokens)
-                    overhead_str = format_token_count(overhead)
-                    conv_str = format_token_count(conv_tokens)
-
-                    overhead_unit = " tokens" if overhead < 1000 else ""  # noqa: PLR2004  # not bothersome, cosmetic
-                    conv_unit = " tokens" if conv_tokens < 1000 else ""  # noqa: PLR2004  # not bothersome, cosmetic
-
-                    msg += (
-                        f"\n\u251c System prompt + tools: ~{overhead_str}{overhead_unit} (fixed)"  # noqa: E501
-                        f"\n\u2514 Conversation: ~{conv_str}{conv_unit}"
-                    )
-
-                await self._mount_message(AppMessage(msg))
-            else:
-                model_name = settings.model_name
-                context_limit = settings.model_context_limit
-
-                parts: list[str] = ["No token usage yet"]
-                if context_limit is not None:
-                    limit_str = format_token_count(context_limit)
-                    parts.append(f"{limit_str} token context window")
-                if model_name:
-                    parts.append(model_name)
-
-                await self._mount_message(AppMessage(" · ".join(parts)))
+        elif cmd_head == "/context":
+            await self._show_context_viewer()
         elif cmd == "/skill-creator" or cmd.startswith("/skill-creator "):
             # Convenience alias for /skill:skill-creator — shorter and
             # discoverable before skill loading completes.
@@ -654,8 +581,6 @@ class _ExecutionMixin:
                 )
                 return
             await self._submit_cron_job(args, slash_input=command)
-        elif cmd == "/context":
-            await self._show_context_viewer()
         elif cmd == "/mcp":
             await self._show_mcp_viewer()
         elif cmd == "/theme":
@@ -1046,7 +971,7 @@ class _ExecutionMixin:
 
         # Ensure token display is restored (in case of early cancellation).
         # Pass the cached approximate flag so an interrupted "+" isn't clobbered.
-        self._show_tokens(approximate=self._tokens_approximate)
+        self._refresh_token_displays(approximate=self._tokens_approximate)
 
         try:
             await self._maybe_drain_deferred()

{soothe_cli-0.7.12 → soothe_cli-0.7.14}/src/soothe_cli/tui/app/_history.py

@@ -185,9 +185,12 @@ class _HistoryMixin:
             )
             return _LoopHistoryPayload([], context_tokens, goal_dicts)
 
-        from soothe_sdk.display.card_binder import merge_consecutive_assistant_cards
+        from soothe_sdk.display.card_binder import (
+            merge_consecutive_assistant_cards,
+            sanitize_resume_display_cards,
+        )
 
-        data = merge_consecutive_assistant_cards(data)
+        data = sanitize_resume_display_cards(merge_consecutive_assistant_cards(data))
 
         return _LoopHistoryPayload(data, context_tokens, goal_dicts)
 
@@ -294,6 +297,7 @@ class _HistoryMixin:
 
         logger.info("Starting background event consumer for subscribed loop")
         from langchain_core.messages import AIMessage, AIMessageChunk, ToolMessage
+        from soothe_sdk.ux.loop_stream import LOOP_ASSISTANT_OUTPUT_PHASES, assistant_output_phase
 
         assistant_cards_by_ns: dict[tuple[Any, ...], AssistantMessage] = {}
         last_user_text_by_ns: dict[tuple[Any, ...], str] = {}
@@ -324,6 +328,9 @@ class _HistoryMixin:
                     message, _metadata = data
                     message = normalize_stream_message(message)
 
+                    if self._is_loop_internal_checkpoint_message(message):
+                        continue
+
                     user_text = extract_user_text_for_display(message)
                     if user_text is not None:
                         # Deduplicate immediate replayed user rows after reconnect/resubscribe.
@@ -338,6 +345,9 @@ class _HistoryMixin:
                         continue
 
                     if isinstance(message, (AIMessage, AIMessageChunk)):
+                        phase = assistant_output_phase(message)
+                        if phase is not None and phase not in LOOP_ASSISTANT_OUTPUT_PHASES:
+                            continue
                         extracted = extract_ai_text_for_display(message)
                         is_terminal = is_stream_terminal(message)
                         if extracted:

{soothe_cli-0.7.12 → soothe_cli-0.7.14}/src/soothe_cli/tui/app/_messages_mixin.py

@@ -96,9 +96,9 @@ class _MessagesMixin:
                 if not payload.messages:
                     return
 
-                # Seed token cache from persisted state
+                # Seed loop token total from persisted checkpoint
                 if payload.context_tokens > 0:
-                    self._on_tokens_update(payload.context_tokens)
+                    self._seed_loop_token_from_checkpoint(payload.context_tokens)
 
                 # Bulk load into store (sets visible window; replaces prior data).
                 _archived, visible = self._message_store.bulk_load(
@@ -113,9 +113,12 @@ class _MessagesMixin:
                     return
 
                 # Create and mount only visible widgets (max WINDOW_SIZE).
+                from soothe_sdk.display.card_binder import sanitize_resume_display_cards
+
                 from soothe_cli.tui.binding import message_to_widget
 
                 visible = self._dedupe_message_data_by_id(visible)
+                visible = sanitize_resume_display_cards(visible)
                 widgets = [message_to_widget(msg_data) for msg_data in visible]
                 if widgets:
                     await messages_container.mount(*widgets)