lisa-cli 0.2.0__tar.gz → 0.3.0__tar.gz

{lisa_cli-0.2.0/src/lisa_cli.egg-info → lisa_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lisa-cli
-Version: 0.2.0
+Version: 0.3.0
 Summary: Terminal CLI for the Lisa Harness
 License-Expression: MIT
 Requires-Python: >=3.11

{lisa_cli-0.2.0 → lisa_cli-0.3.0}/pyproject.toml

@@ -7,7 +7,7 @@ where = ["src"]
 
 [project]
 name = "lisa-cli"
-version = "0.2.0"
+version = "0.3.0"
 description = "Terminal CLI for the Lisa Harness"
 requires-python = ">=3.11"
 license = "MIT"

{lisa_cli-0.2.0 → lisa_cli-0.3.0}/src/hosts/cli/main.py

@@ -3,8 +3,8 @@
 This is the terminal-transport entry point for the Lisa framework. It
 wraps the transport-neutral :mod:`host` runtime with Typer commands
 and Rich rendering. Every command is a one-shot process: turns run via
-``lisa prompt`` and lifecycle/inspection commands (verify, models, policy,
-pack, mcp, last, intake) run once and exit.
+``lisa prompt`` and lifecycle/inspection commands (verify, update, models,
+policy, pack, mcp, last, intake) run once and exit.
 """
 
 from __future__ import annotations
@@ -14,6 +14,8 @@ import logging
 import os
 import platform
 import shlex
+import shutil
+import subprocess
 import sys
 from collections.abc import Callable
 from pathlib import Path
@@ -415,7 +417,7 @@ def _get_version() -> str:
 
         return _pkg_version("lisa-cli")
     except Exception:  # pylint: disable=broad-except
-        return "0.2.0"
+        return "0.3.0"
 
 
 _VERSION_OPTION = typer.Option(
@@ -1233,7 +1235,7 @@ def _models_command(
             await runtime.start()
             return await handle_models_command(runtime, stripped, stripped)
         finally:
-            await runtime.aclose()
+            await _aclose_runtime_bounded(runtime)
 
     response_text = asyncio.run(_run_models_command())
     console.print(Panel(Markdown(response_text), title="Models", border_style="cyan"))
@@ -1900,6 +1902,142 @@ async def _run_pack_update_all(runtime: HostRuntime) -> tuple[bool, str]:
     return await run_pack_update_all(runtime)
 
 
+# ---------------------------------------------------------------------------
+# update command
+# ---------------------------------------------------------------------------
+
+_UPDATE_TOOL_NAME = "lisa-cli"
+
+#: uv cannot replace a running console-script trampoline on Windows; the
+#: command reports the argv for the operator to run after exiting instead.
+_UPDATE_IN_PLACE_BLOCKED = platform.system() == "Windows"
+
+
+@app.command(
+    "update",
+    help="Upgrade the installed lisa CLI in place (uv tool upgrade lisa-cli).",
+)
+def _update_command(
+    force: bool = typer.Option(
+        False,
+        "--force",
+        help=(
+            "Reinstall even when the recorded version is unchanged "
+            "(picks up new code from a local or git checkout without a version bump)."
+        ),
+    ),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        help="Print the uv command instead of running it.",
+    ),
+) -> None:
+    """Upgrade the tool install that provides this ``lisa`` executable.
+
+    ``uv tool upgrade`` is the only correct update path: it replays the
+    install receipt (``<tool-dir>/lisa-cli/uv-receipt.toml``), which is where
+    the installer records the ``--with`` framework requirements, the
+    ``[prompt]`` extra, and ``no-sources``. ``uv tool install --upgrade
+    lisa-cli`` would rewrite that receipt from a bare index spec and drop
+    all of it, so this command never does that.
+    """
+    from runtime.paths import default_packs_venv, is_tool_install
+
+    if not is_tool_install():
+        console.print(
+            "[yellow]lisa is running from a repo checkout, so there is no uv tool to "
+            "upgrade. Update with:[/yellow] git pull && uv sync"
+        )
+        raise typer.Exit(code=2)
+
+    tool_dir = _installed_tool_dir()
+    if tool_dir is None:
+        console.print(
+            "[yellow]This interpreter is not a uv tool install (no uv-receipt.toml in "
+            f"{sys.prefix}), so there is nothing for `uv tool upgrade` to update.[/yellow]"
+        )
+        raise typer.Exit(code=2)
+
+    uv_bin = shutil.which("uv")
+    # Point uv at the tool dir this process is actually running from. Without
+    # it uv consults only UV_TOOL_DIR/default, so an install made with a custom
+    # tool dir would miss the real one and advise `uv tool install lisa-cli` —
+    # the receipt-clobbering path this command exists to avoid.
+    env = {**os.environ, "UV_TOOL_DIR": str(tool_dir.parent)}
+    argv = [
+        uv_bin or "uv",
+        "tool",
+        "upgrade",
+        *(["--reinstall"] if force else []),
+        _UPDATE_TOOL_NAME,
+    ]
+    printable = shlex.join(argv)
+
+    # On Windows the console script is a .exe trampoline inside the tool
+    # venv, which cannot be replaced while this process still has it open.
+    blocked = uv_bin is None or (_UPDATE_IN_PLACE_BLOCKED and not dry_run)
+    if dry_run or blocked:
+        if dry_run:
+            console.print(f"Run: [bold]{printable}[/bold]")
+        else:
+            reason = (
+                "uv is not on PATH; run it yourself"
+                if uv_bin is None
+                else "Windows locks the running lisa.exe"
+            )
+            console.print(f"[yellow]{reason}.[/yellow] Run: [bold]{printable}[/bold]")
+        raise typer.Exit(code=0 if dry_run else 1)
+
+    console.print(f"Running [bold]{printable}[/bold]")
+    completed = subprocess.run(argv, check=False, env=env)  # inherits stdio so uv streams progress
+    if completed.returncode != 0:
+        console.print(f"[red]uv tool upgrade failed (exit {completed.returncode}).[/red]")
+        raise typer.Exit(code=completed.returncode)
+
+    console.print("Updated. Restart lisa to use the new version.")
+    _warn_stale_packs_venv(default_packs_venv())
+
+
+def _installed_tool_dir() -> Path | None:
+    """Return the uv tool directory this process is running from.
+
+    A ``uv tool`` venv carries the receipt at its root, so ``sys.prefix``
+    identifies the install unambiguously — including installs made with a
+    custom ``UV_TOOL_DIR``, which uv would otherwise not find. The receipt's
+    parent is the value ``UV_TOOL_DIR`` expects (it is the directory holding
+    one subdirectory per tool).
+
+    This is a positive check: a plain virtualenv or pipx install has no
+    receipt and returns ``None``.
+    """
+    prefix = Path(sys.prefix)
+    if not (prefix / "uv-receipt.toml").is_file():
+        return None
+    return prefix
+
+
+def _warn_stale_packs_venv(packs_venv: Path) -> None:
+    """Point the operator at the one follow-up packs may need.
+
+    The packs venv is a second install with its own framework copies. Packs
+    import the CLI's framework packages (the tool venv's site-packages
+    precedes the packs venv on ``sys.path``), so an upgrade does not break
+    them — but a pack whose *dependencies* moved can still need a re-resolve,
+    and ``uv pip install`` never upgrades an already-satisfied requirement.
+    ``lisa pack update --all`` re-installs each pack from its recorded source,
+    which re-resolves its dependency set. Surfacing the command is cheaper
+    than silently re-seeding every pack after an upgrade.
+    """
+    if not packs_venv.is_dir():
+        return
+    console.print(
+        f"[yellow]Packs live in a separate venv ({packs_venv}). Packs keep working "
+        "against the upgraded framework, but their own dependencies are only "
+        "re-resolved by `lisa pack update --all` — run it if a pack misbehaves "
+        "after an update.[/yellow]"
+    )
+
+
 # ---------------------------------------------------------------------------
 # prompt command
 # ---------------------------------------------------------------------------
@@ -2064,7 +2202,7 @@ async def _run_host_command_turn(runtime: HostRuntime, command: str) -> str:
         await runtime.start()
         result = await handle_message(runtime, command, NullTransport())
     finally:
-        await runtime.aclose()
+        await _aclose_runtime_bounded(runtime)
     return getattr(result, "text", "") or str(result)
 
 
@@ -2128,7 +2266,7 @@ async def _decide_approval_turn(
             transport=NullTransport(),
         )
     finally:
-        await runtime.aclose()
+        await _aclose_runtime_bounded(runtime)
     return getattr(result, "text", "") or str(result)
 
 
@@ -2392,76 +2530,6 @@ def _deny_command(  # Match shared runtime options used by one-shot commands.
     )
 
 
-@app.command(
-    "run",
-    hidden=True,
-    help=(
-        "[DEPRECATED] Run one slash command (host admin or pack-defined). "
-        "Every host command now has a real subcommand (pack-registered ones "
-        "like `stalls`/`retry` are generated from the pack registry); this "
-        "escape hatch remains one release for compatibility. The leading '/' "
-        "is optional. Quote multi-word arguments as one string; with multiple "
-        "tokens they are re-quoted verbatim so the runtime sees the exact "
-        "slash-command string."
-    ),
-)
-def _run_command_command(  # Match shared runtime options used by one-shot commands.
-    command: Annotated[
-        list[str] | None,
-        typer.Argument(help="Slash command and its arguments."),
-    ] = None,
-    log_level: LogLevelOption = "",
-    log: LogOption = "",
-    no_log: NoLogOption = False,
-    data_dir: DataDirOption = "",
-    profile: ProfileOption = "",
-    overlays_dir: OverlaysDirOption = "",
-    thread_dir: ThreadDirOption = "",
-    no_thread: NoThreadOption = False,
-    session_context: SessionContextOption = "",
-    timezone: TimezoneOption = "",
-    state_snapshot: StateSnapshotOption = "",
-    streaming: StreamingOption = "",
-    host_log: HostLogOption = "",
-) -> None:
-    """Dispatch one slash command to the runtime exactly as a persistent
-    host would, via ``handle_message`` and ``_run_host_command_turn``.
-
-    DEPRECATED: kept one release for compatibility. Every host admin verb
-    now has a tailored Typer command; pack-registered commands (``stalls``,
-    ``retry``, ...) resolve as dynamically generated subcommands. This
-    generic string escape hatch hides from help and will be removed once
-    scripts have migrated.
-    """
-    console.print(
-        "[yellow]`lisa run` is deprecated: host commands are real subcommands "
-        "now (`lisa settings`, `lisa stalls`, ...).[/yellow]"
-    )
-    if not command:
-        console.print("[red]No slash command given. Example: lisa run '/policy mode trust'[/red]")
-        raise typer.Exit(code=2)
-    parts = list(command)
-    command_str = parts[0] if len(parts) == 1 else " ".join(shlex.quote(part) for part in parts)
-    if not command_str.startswith("/"):
-        command_str = "/" + command_str
-    _run_host_command(
-        command_str,
-        log_level=log_level,
-        log_path=log,
-        no_log=no_log,
-        data_dir=data_dir,
-        profile=profile,
-        overlays_dir=overlays_dir,
-        thread_dir=thread_dir,
-        no_thread=no_thread,
-        session_context=session_context,
-        timezone=timezone,
-        state_snapshot_path=state_snapshot,
-        streaming=streaming,
-        host_log_path=host_log,
-    )
-
-
 def _compose_prompt_message(instruction: str, payload: str) -> str:
     """Compose the prompt-mode turn message from the CLI instruction and stdin.
 
@@ -2672,14 +2740,22 @@ async def _run_prompt_with_teardown(
                 # stop — there is no turn to run.
                 decision_text = getattr(result, "text", "") or str(result)
                 transport.stop_activity()
-                await runtime.aclose()
+                await _aclose_runtime_bounded(runtime)
                 await transport.on_response(decision_text)
                 return transport
         if message:
             await handle_message(runtime, message, transport)
     finally:
         transport.stop_activity()
-        await runtime.aclose()
+        # Bounded teardown: the prompt command previously awaited bare
+        # ``runtime.aclose()`` — when the MCP pool's sequential anyio
+        # task-group teardown stalls (the 2026-09-21 headroom incident
+        # recurred on 2026-10-26 ~16:11: the turn had already completed
+        # and persisted, yet the CLI sat idle in epoll for the rest of
+        # the prompt run because the unbounded close never returned).
+        # The bounded helper falls back to terminating every tracked
+        # MCP/proxy subprocess after the grace window.
+        await _aclose_runtime_bounded(runtime)
     return transport
 
 

{lisa_cli-0.2.0 → lisa_cli-0.3.0}/src/hosts/cli/transport.py

@@ -320,8 +320,7 @@ class PromptTransport:
         # ── Turn counters ───────────────────────────────────────────
         self._turn_started_perf: float = 0.0
         self._current_mode: str = ""
-        self._status_current_model: str = ""
-        self._status_model_provider: str = ""
+        self._reset_model_status()
         # Global thread turn number of the turn being rendered, stamped by
         # the host on the ``model_call`` stage payload (``turn_index``).
         # Rendered on the Response rule and the ⚡ footer; -1 = unknown. A
@@ -329,12 +328,7 @@ class PromptTransport:
         # in ``start_thinking``: a pre-armed-decision run dispatches a second
         # message on the same transport and each capture replaces it.
         self._turn_number: int = -1
-        self._status_turn_tokens: int = 0
-        self._status_prompt_tokens: int = 0
-        self._status_completion_tokens: int = 0
-        self._status_cached_tokens: int = 0
-        self._status_billed_tokens: int = 0
-        self._status_reasoning_chars: int = 0
+        self._init_status_counters()
         self._iteration_durations: list[float] = []
         self._model_call_count: int = 0
         self._handoff_count: int = 0
@@ -382,6 +376,43 @@ class PromptTransport:
         # ── Stream velocity (observable, not manifest-trusted) ──────
         self._init_velocity_state()
 
+    def _init_status_counters(self) -> None:
+        """Zero the per-turn token/cost counters shared by the footer.
+
+        ``start_thinking`` re-runs this for each turn; constructing the
+        transport runs it once for the pre-turn state.
+
+        ``_status_turn_tokens`` is the *walk* (every call's ``total_tokens``),
+        ``_status_billed_tokens`` the uncached basis, and the two cost fields
+        carry the kernel's canonical estimate and the provider's own reported
+        charge. The provider figure is authoritative when non-zero; when the
+        kernel supplied neither cost field the footer falls back to pricing
+        ``model_prices`` itself, so an older runtime still shows a number.
+        """
+        self._status_turn_tokens: int = 0
+        self._status_prompt_tokens: int = 0
+        self._status_completion_tokens: int = 0
+        self._status_cached_tokens: int = 0
+        self._status_billed_tokens: int = 0
+        self._status_cost_usd: float = 0.0
+        self._status_provider_cost_usd: float = 0.0
+        # Model calls that reported a provider charge. A turn mixing
+        # providers (some reporting cost, some silent) has a partial total,
+        # which must not masquerade as the full bill.
+        self._status_provider_cost_calls: int = 0
+        # Per-turn sums of the counters the serving proxy declared on its
+        # response headers (e.g. compression ``tokens_saved``), keyed by the
+        # pack's own field names. Empty when no proxy is in the path — the
+        # footer then renders no proxy segment at all.
+        self._status_proxy_telemetry: dict[str, int] = {}
+        self._status_reasoning_chars: int = 0
+
+    def _reset_model_status(self) -> None:
+        self._status_current_model: str = ""
+        self._status_model_provider: str = ""
+        self._status_proxy_id: str = ""
+        self._status_proxy_via: str = ""
+
     def _init_velocity_state(self) -> None:
         """Initialize the velocity-sampling state (one statement block).
 
@@ -458,12 +489,15 @@ class PromptTransport:
         self._status_completion_tokens = 0
         self._status_cached_tokens = 0
         self._status_billed_tokens = 0
+        self._status_cost_usd = 0.0
+        self._status_provider_cost_usd = 0.0
+        self._status_provider_cost_calls = 0
+        self._status_proxy_telemetry = {}
         self._status_reasoning_chars = 0
         self._fork_children = {}
         self._fork_total = 0
         self._current_mode = ""
-        self._status_current_model = ""
-        self._status_model_provider = ""
+        self._reset_model_status()
         self._active_label = ""
         self._phase_label = "starting runtime"
         self._last_tool_data = None
@@ -755,6 +789,24 @@ class PromptTransport:
         if isinstance(turn_raw, int) and turn_raw >= 0:
             self._turn_number = turn_raw
 
+    def _capture_proxy_route(self, data: dict[str, Any]) -> None:
+        """Capture the provider's proxy routing from a stage payload.
+
+        ``proxy_route.via`` is ``"proxy"`` (requests flow through the named
+        proxy pack, e.g. headroom) or ``"direct"``. A payload without the
+        key clears the chip: transports must not keep showing a stale hop
+        when the runtime stops stamping routing info.
+        """
+        route = data.get("proxy_route")
+        if not isinstance(route, dict):
+            self._status_proxy_id = ""
+            self._status_proxy_via = ""
+            return
+        via = str(route.get("via") or "")
+        self._status_proxy_via = via if via in ("proxy", "direct") else ""
+        proxy_id = route.get("proxy_id") if via == "proxy" else route.get("bypassed_proxy_id")
+        self._status_proxy_id = str(proxy_id or "")
+
     def _handle_model_stage(self, label: str, data: dict[str, Any]) -> None:
         """Route model_call* stage events.
 
@@ -770,6 +822,7 @@ class PromptTransport:
                 provider = data.get("provider")
                 self._status_current_model = str(model_id)
                 self._status_model_provider = str(provider) if provider not in (None, "") else ""
+            self._capture_proxy_route(data)
             self._model_call_count += 1
             self._active_reasoning_model = bool(data.get("reasoning_model"))
             # A new model call resets the stall clock: pre-call silence is
@@ -790,28 +843,7 @@ class PromptTransport:
             if d_raw not in (None, "", 0):
                 with contextlib.suppress(TypeError, ValueError):
                     self._iteration_durations.append(float(d_raw))
-            total_raw = data.get("_state.total_tokens") or data.get("total_tokens")
-            if total_raw not in (None, "", 0):
-                self._status_turn_tokens += int(total_raw)
-            # Split counts feed the footer's cost estimate (manifest prices
-            # are per prompt/completion token). Cache-hit counts let the
-            # estimate price cached prompts at the manifest's cache-read rate.
-            with contextlib.suppress(TypeError, ValueError):
-                self._status_prompt_tokens += int(data.get("prompt_tokens") or 0)
-            with contextlib.suppress(TypeError, ValueError):
-                self._status_completion_tokens += int(data.get("completion_tokens") or 0)
-            cached_now = 0
-            with contextlib.suppress(TypeError, ValueError):
-                cached_now = int(data.get("cached_tokens") or 0)
-            self._status_cached_tokens += cached_now
-            with contextlib.suppress(TypeError, ValueError):
-                prompt_now = int(data.get("prompt_tokens") or 0)
-            # Billed basis (2026-10-12 perf review): the walk figure counts
-            # every cache hit at full size; the operator-facing "what did
-            # this turn actually cost" is uncached prompt + completion.
-            self._status_billed_tokens += max(0, prompt_now - cached_now) + int(
-                data.get("completion_tokens") or 0
-            )
+            self._accumulate_call_usage(data)
             return
         if label == "model_call_failed":
             self._print_event_line(
@@ -1263,7 +1295,7 @@ class PromptTransport:
         return body
 
     def _status_leading_parts(self) -> list[Text]:
-        """Leading status segments: turn, mode, model, in-flight label."""
+        """Leading status segments: turn, mode, model, proxy hop, in-flight label."""
         parts: list[Text] = []
         if self._turn_number >= 0:
             parts.append(Text(f"turn {self._turn_number}", style=STYLE_ROW_MODEL))
@@ -1274,10 +1306,35 @@ class PromptTransport:
             if self._status_model_provider:
                 model = f"{self._status_model_provider}:{model}"
             parts.append(Text(model, style=STYLE_STAGE))
+        chip = self._proxy_chip_part()
+        if chip is not None:
+            parts.append(chip)
         if self._active_label:
             parts.append(Text(_truncate(self._active_label, 48), style=STYLE_STAGE))
         return parts
 
+    def _proxy_chip_part(self) -> Text | None:
+        """Proxy-pack routing chip, or ``None`` when the host stamped nothing.
+
+        ``⤳ <proxy_id>`` when the provider routes through a ready proxy
+        (e.g. headroom); nothing when unstamped or direct with no proxy
+        declared. The chip keeps the model segment honest about where
+        requests actually flow.
+        """
+        if not self._status_proxy_via:
+            return None
+        if self._status_proxy_via == "proxy" and self._status_proxy_id:
+            proxy_id = self._status_proxy_id
+            prefix, separator, suffix = proxy_id.partition(".")
+            if separator and prefix == suffix:
+                proxy_id = prefix
+            return Text(f"⤳ {_truncate(proxy_id, 24)}", style=STYLE_STAGE)
+        if self._status_proxy_via == "direct" and self._status_proxy_id:
+            return Text(
+                f"{_truncate(self._status_proxy_id, 24)} ↓ direct", style=STYLE_ROW_TRANSITION
+            )
+        return None
+
     def _append_meter_parts(self, parts: list[Text]) -> None:
         """Append the thinking meter segment when armed.
 
@@ -1396,20 +1453,126 @@ class PromptTransport:
         if self._status_turn_tokens:
             footer.append(" · ", style=STYLE_TEXT_MUTED)
             footer.append(f"{_format_tokens(self._status_turn_tokens)} tok", style="green3")
-            # Cache-split figure: when the turn walked context with cache
-            # hits, the walk is not the billed basis. Show what the turn
-            # actually consumed next to the walk (2026-10-12 perf review).
-            if self._status_cached_tokens > 0 and self._status_billed_tokens:
+            # Billed segment: the walk above counts every cache hit at full
+            # size, which on a cache-heavy turn reads up to 30x the tokens the
+            # provider actually bills. Always show the billed basis beside it
+            # when the two differ — that is the number to sanity-check spend
+            # against. When the turn had no cache hits the two are identical
+            # and the segment would be noise.
+            if 0 < self._status_billed_tokens < self._status_turn_tokens:
                 footer.append(
                     f" · billed {_format_tokens(self._status_billed_tokens)}",
                     style="cyan",
                 )
-        cost = self._estimate_turn_cost()
+        cost, authoritative = self._resolve_turn_cost()
         if cost:
             footer.append(" · ", style=STYLE_TEXT_MUTED)
-            footer.append(f"${cost:g}", style="cyan")
+            # ``$`` marks a provider-reported charge (the real meter); the
+            # ``~`` prefix marks the harness's own estimate from manifest
+            # rates, so the two are never mistaken for each other.
+            prefix = "$" if authoritative else "~$"
+            footer.append(f"{prefix}{cost:g}", style="cyan")
+        self._append_proxy_savings(footer)
         self.console.print(footer)
 
+    def _append_proxy_savings(self, footer: Text) -> None:
+        """Append the serving proxy's reported savings, when it declared any.
+
+        A proxy in the path (compression, cache steering) reports what it
+        saved per call on response headers; the kernel sums them and the
+        footer shows the turn's total. The counter is whatever the proxy
+        declared, so nothing is rendered unless a known name is present —
+        an unrecognised counter still reaches ``lisa tokens`` and any pack
+        reading the telemetry log, but the one-line footer only labels the
+        fields it can describe without guessing at units.
+        """
+
+        saved = self._status_proxy_telemetry.get("tokens_saved")
+        if not saved:
+            return
+        footer.append(" · ", style=STYLE_TEXT_MUTED)
+        footer.append(f"saved {_format_tokens(saved)}", style="dark_sea_green4")
+
+    def _accumulate_call_usage(self, data: dict[str, Any]) -> None:
+        """Fold one completed model call's usage into the turn totals.
+
+        Three figures accumulate independently, because they answer different
+        questions and must not be conflated:
+
+        * ``_status_turn_tokens`` — the *walk*: sum of every call's
+          ``total_tokens``. Grows quadratically across an agentic turn
+          because each iteration re-sends the whole conversation. Useful for
+          "how much context did this turn chew through", misleading as a bill.
+        * ``_status_billed_tokens`` — uncached prompt + completion, i.e. the
+          tokens the provider charges at full rate.
+        * ``_status_cost_usd`` / ``_status_provider_cost_usd`` — the kernel's
+          canonical estimate and the provider's own reported charge.
+        """
+
+        total_raw = data.get("_state.total_tokens") or data.get("total_tokens")
+        if total_raw not in (None, "", 0):
+            with contextlib.suppress(TypeError, ValueError):
+                self._status_turn_tokens += int(total_raw)
+        prompt_now = 0
+        with contextlib.suppress(TypeError, ValueError):
+            prompt_now = int(data.get("prompt_tokens") or 0)
+            self._status_prompt_tokens += prompt_now
+        completion_now = 0
+        with contextlib.suppress(TypeError, ValueError):
+            completion_now = int(data.get("completion_tokens") or 0)
+            self._status_completion_tokens += completion_now
+        cached_now = 0
+        with contextlib.suppress(TypeError, ValueError):
+            cached_now = int(data.get("cached_tokens") or 0)
+            self._status_cached_tokens += cached_now
+        self._status_billed_tokens += max(0, prompt_now - cached_now) + completion_now
+        with contextlib.suppress(TypeError, ValueError):
+            self._status_cost_usd += float(data.get("cost_usd") or 0.0)
+        provider_now = 0.0
+        with contextlib.suppress(TypeError, ValueError):
+            provider_now = float(data.get("provider_cost_usd") or 0.0)
+        if provider_now > 0.0:
+            self._status_provider_cost_usd += provider_now
+            self._status_provider_cost_calls += 1
+        # Proxy counters are summed without interpreting them: the key set is
+        # whatever the serving proxy declared, and the footer renders only the
+        # ones it knows how to label.
+        telemetry = data.get("proxy_telemetry")
+        if isinstance(telemetry, dict):
+            for key, raw in telemetry.items():
+                with contextlib.suppress(TypeError, ValueError):
+                    self._status_proxy_telemetry[str(key)] = self._status_proxy_telemetry.get(
+                        str(key), 0
+                    ) + max(0, int(raw))
+
+    def _resolve_turn_cost(self) -> tuple[float, bool]:
+        """Return ``(usd, authoritative)`` for the turn's cost segment.
+
+        Three sources, most trustworthy first:
+
+        1. ``_status_provider_cost_usd`` — the provider's own reported
+           charge (OpenRouter ``usage.cost``). Authoritative: it already
+           reflects the provider's real cache read/write rates and any
+           surcharges, so nothing here can be more accurate.
+        2. ``_status_cost_usd`` — the kernel's canonical estimate from the
+           manifest's per-token rates. Correct but list-price only.
+        3. ``_estimate_turn_cost()`` — this transport pricing the counts it
+           accumulated itself. Kept for runtimes whose stage payload predates
+           the cost fields, so an older kernel still yields a figure.
+
+        A provider charge wins only when *every* call in the turn reported
+        one; a partial sum would understate the bill, so mixed turns fall
+        back to the complete canonical estimate.
+        """
+
+        calls = self._model_call_count
+        provider_total = self._status_provider_cost_usd
+        if provider_total > 0.0 and calls > 0 and self._status_provider_cost_calls == calls:
+            return round(provider_total, 4), True
+        if self._status_cost_usd > 0.0:
+            return round(self._status_cost_usd, 4), False
+        return self._estimate_turn_cost(), False
+
     def _estimate_turn_cost(self) -> float:
         """Estimate the turn's USD cost from the manifest per-token prices.
 

{lisa_cli-0.2.0 → lisa_cli-0.3.0/src/lisa_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lisa-cli
-Version: 0.2.0
+Version: 0.3.0
 Summary: Terminal CLI for the Lisa Harness
 License-Expression: MIT
 Requires-Python: >=3.11

{lisa_cli-0.2.0 → lisa_cli-0.3.0}/src/lisa_cli.egg-info/SOURCES.txt

@@ -27,8 +27,8 @@ tests/test_prompt_transport.py
 tests/test_render_catalogs.py
 tests/test_render_models.py
 tests/test_restart.py
-tests/test_run_command.py
 tests/test_runtime_teardown.py
 tests/test_streaming.py
 tests/test_transport_stage.py
+tests/test_update_command.py
 tests/test_verify_command.py