deepy-cli 0.2.9__tar.gz → 0.2.11__tar.gz

{deepy_cli-0.2.9 → deepy_cli-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: deepy-cli
-Version: 0.2.9
+Version: 0.2.11
 Summary: Deepy - Vibe coding for DeepSeek models in your terminal
 Keywords: deepseek,coding-agent,terminal,cli,agents
 Author: kirineko

{deepy_cli-0.2.9 → deepy_cli-0.2.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deepy-cli"
-version = "0.2.9"
+version = "0.2.11"
 description = "Deepy - Vibe coding for DeepSeek models in your terminal"
 readme = "README.md"
 authors = [

{deepy_cli-0.2.9 → deepy_cli-0.2.11}/src/deepy/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-__version__ = "0.2.9"
+__version__ = "0.2.11"
 
 
 def main() -> None:

deepy_cli-0.2.11/src/deepy/session_cost.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+import urllib.parse
+from decimal import Decimal, InvalidOperation
+from typing import Any, Mapping
+
+from deepy.config import Settings
+
+
+def should_track_session_cost(settings: Settings) -> bool:
+    if not settings.model.api_key:
+        return False
+    parsed = urllib.parse.urlparse(settings.model.base_url)
+    return parsed.scheme in {"http", "https"} and parsed.hostname == "api.deepseek.com"
+
+
+def balance_snapshot_to_dict(balance: Any, *, captured_at_ms: int) -> dict[str, Any]:
+    unavailable_reason = _string_or_none(_field(balance, "unavailable_reason"))
+    if unavailable_reason:
+        return {
+            "capturedAt": captured_at_ms,
+            "unavailableReason": unavailable_reason,
+        }
+
+    infos: list[dict[str, str]] = []
+    for item in _field(balance, "balance_infos") or ():
+        currency = _string_or_none(_field(item, "currency"))
+        total = _string_or_none(_field(item, "total_balance"))
+        granted = _string_or_none(_field(item, "granted_balance"))
+        topped_up = _string_or_none(_field(item, "topped_up_balance"))
+        if None in (currency, total, granted, topped_up):
+            return {
+                "capturedAt": captured_at_ms,
+                "unavailableReason": "invalid balance snapshot",
+            }
+        infos.append(
+            {
+                "currency": currency or "",
+                "totalBalance": total or "",
+                "grantedBalance": granted or "",
+                "toppedUpBalance": topped_up or "",
+            }
+        )
+    is_available = _field(balance, "is_available")
+    return {
+        "capturedAt": captured_at_ms,
+        "isAvailable": is_available if isinstance(is_available, bool) else None,
+        "balanceInfos": infos,
+    }
+
+
+def start_session_cost(snapshot: Mapping[str, Any]) -> dict[str, Any]:
+    cost: dict[str, Any] = {
+        "attempted": True,
+        "start": dict(snapshot),
+    }
+    if reason := _snapshot_unavailable_reason(snapshot):
+        cost["unavailableReason"] = f"start {reason}"
+    return cost
+
+
+def complete_session_cost(
+    existing: Mapping[str, Any] | None,
+    end_snapshot: Mapping[str, Any],
+) -> dict[str, Any]:
+    cost: dict[str, Any] = dict(existing or {})
+    cost["attempted"] = True
+    cost["end"] = dict(end_snapshot)
+    start = cost.get("start")
+    if not isinstance(start, Mapping):
+        cost["amounts"] = []
+        cost["unavailableReason"] = "start snapshot missing"
+        return cost
+    amounts, reason = compute_session_cost_amounts(start, end_snapshot)
+    cost["amounts"] = amounts
+    if reason:
+        cost["unavailableReason"] = reason
+    else:
+        cost.pop("unavailableReason", None)
+    return cost
+
+
+def compute_session_cost_amounts(
+    start_snapshot: Mapping[str, Any],
+    end_snapshot: Mapping[str, Any],
+) -> tuple[list[dict[str, str]], str | None]:
+    if reason := _snapshot_unavailable_reason(start_snapshot):
+        return [], f"start {reason}"
+    if reason := _snapshot_unavailable_reason(end_snapshot):
+        return [], f"end {reason}"
+
+    start_infos = _snapshot_infos_by_currency(start_snapshot)
+    end_infos = _snapshot_infos_by_currency(end_snapshot)
+    if start_infos is None or end_infos is None:
+        return [], "invalid balance snapshot"
+    shared = [currency for currency in start_infos if currency in end_infos]
+    if not shared:
+        return [], "currency mismatch"
+
+    amounts: list[dict[str, str]] = []
+    for currency in shared:
+        start_total_text = start_infos[currency]
+        end_total_text = end_infos[currency]
+        start_total = _decimal(start_total_text)
+        end_total = _decimal(end_total_text)
+        if start_total is None or end_total is None:
+            return [], "invalid balance amount"
+        spent = start_total - end_total
+        if spent > 0:
+            amounts.append(
+                {
+                    "currency": currency,
+                    "startTotal": start_total_text,
+                    "endTotal": end_total_text,
+                    "spent": _format_decimal(spent),
+                }
+            )
+    if not amounts:
+        return [], "no measurable spend"
+    return amounts, None
+
+
+def format_session_cost(cost: Any) -> str | None:
+    if not isinstance(cost, Mapping) or not cost.get("attempted"):
+        return None
+    amounts = cost.get("amounts")
+    if isinstance(amounts, list) and amounts:
+        parts: list[str] = []
+        for item in amounts:
+            if not isinstance(item, Mapping):
+                continue
+            currency = _string_or_none(item.get("currency"))
+            spent = _string_or_none(item.get("spent"))
+            if currency and spent:
+                parts.append(f"{currency} {spent}")
+        if parts:
+            return f"{', '.join(parts)} (DeepSeek balance delta)"
+    reason = _string_or_none(cost.get("unavailableReason")) or "unknown"
+    return f"unavailable ({reason})"
+
+
+def _field(value: Any, name: str) -> Any:
+    if isinstance(value, Mapping):
+        return value.get(name)
+    return getattr(value, name, None)
+
+
+def _string_or_none(value: Any) -> str | None:
+    return value if isinstance(value, str) and value else None
+
+
+def _snapshot_unavailable_reason(snapshot: Mapping[str, Any]) -> str | None:
+    return _string_or_none(snapshot.get("unavailableReason"))
+
+
+def _snapshot_infos_by_currency(snapshot: Mapping[str, Any]) -> dict[str, str] | None:
+    raw_infos = snapshot.get("balanceInfos")
+    if not isinstance(raw_infos, list):
+        return None
+    infos: dict[str, str] = {}
+    for item in raw_infos:
+        if not isinstance(item, Mapping):
+            return None
+        currency = _string_or_none(item.get("currency"))
+        total = _string_or_none(item.get("totalBalance"))
+        if not currency or total is None:
+            return None
+        infos[currency] = total
+    return infos
+
+
+def _decimal(value: str) -> Decimal | None:
+    try:
+        return Decimal(value)
+    except (InvalidOperation, ValueError):
+        return None
+
+
+def _format_decimal(value: Decimal) -> str:
+    text = format(value.normalize(), "f")
+    if "." not in text:
+        return text
+    return text.rstrip("0").rstrip(".") or "0"

{deepy_cli-0.2.9 → deepy_cli-0.2.11}/src/deepy/sessions/jsonl.py

@@ -40,6 +40,7 @@ class SessionEntry:
     pending_tokens: int = 0
     last_usage_record_count: int | None = None
     todo_state: list[dict[str, str]] | None = None
+    session_cost: dict[str, Any] | None = None
 
 
 def project_code(project_root: Path) -> str:
@@ -160,6 +161,7 @@ class DeepyJsonlSession:
             pending_tokens=0,
             last_usage_record_count=0,
             todo_state=[],
+            session_cost=None,
         )
 
     def record_usage(self, usage: TokenUsage | dict[str, Any] | None) -> None:
@@ -207,6 +209,32 @@ class DeepyJsonlSession:
             ) + max(elapsed_ms, 0)
         self._touch_index(input_suggestion_usage=accumulated)
 
+    def record_session_cost_start(self, snapshot: dict[str, Any]) -> None:
+        from deepy.session_cost import start_session_cost
+
+        previous = _entry_for_session(self.path.parent / "sessions-index.json", self.session_id)
+        previous_cost = previous.get("sessionCost") if previous else None
+        if isinstance(previous_cost, dict) and isinstance(previous_cost.get("start"), dict):
+            return
+        self._touch_index(session_cost=start_session_cost(snapshot))
+
+    def record_session_cost_end(self, snapshot: dict[str, Any]) -> None:
+        from deepy.session_cost import complete_session_cost
+
+        previous = _entry_for_session(self.path.parent / "sessions-index.json", self.session_id)
+        previous_cost = previous.get("sessionCost") if previous else None
+        self._touch_index(
+            session_cost=complete_session_cost(
+                previous_cost if isinstance(previous_cost, dict) else None,
+                snapshot,
+            )
+        )
+
+    def session_cost(self) -> dict[str, Any] | None:
+        previous = _entry_for_session(self.path.parent / "sessions-index.json", self.session_id)
+        cost = previous.get("sessionCost") if previous else None
+        return cost if isinstance(cost, dict) else None
+
     def context_token_state(
         self,
         records: list[dict[str, Any]] | None = None,
@@ -361,6 +389,7 @@ class DeepyJsonlSession:
         last_usage_record_count: int | None = None,
         todo_state: object = _UNSET,
         input_suggestion_usage: dict[str, Any] | None = None,
+        session_cost: object = _UNSET,
     ) -> None:
         self.path.parent.mkdir(parents=True, exist_ok=True)
         index_path = self.path.parent / "sessions-index.json"
@@ -432,6 +461,11 @@ class DeepyJsonlSession:
             ),
             **({"processes": previous["processes"]} if "processes" in previous else {}),
         }
+        if session_cost is _UNSET:
+            if isinstance(previous.get("sessionCost"), dict):
+                entry["sessionCost"] = previous["sessionCost"]
+        elif isinstance(session_cost, dict):
+            entry["sessionCost"] = session_cost
         if todo_state is _UNSET:
             if "todoState" in previous:
                 entry["todoState"] = previous["todoState"]
@@ -498,6 +532,7 @@ def list_session_entries(project_root: Path, deepy_home: Path | None = None) ->
             path = f"{session_id}.jsonl"
         usage = item.get("usage")
         input_suggestion_usage = item.get("inputSuggestionUsage")
+        session_cost = item.get("sessionCost")
         entries.append(
             SessionEntry(
                 id=session_id,
@@ -515,6 +550,7 @@ def list_session_entries(project_root: Path, deepy_home: Path | None = None) ->
                 pending_tokens=_coerce_int(item.get("pendingTokens"), 0),
                 last_usage_record_count=_optional_int(item.get("lastUsageRecordCount")),
                 todo_state=normalize_persisted_todo_state(item.get("todoState")),
+                session_cost=session_cost if isinstance(session_cost, dict) else None,
             )
         )
     return entries

{deepy_cli-0.2.9 → deepy_cli-0.2.11}/src/deepy/tui/app.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import shutil
+import time
 from collections import OrderedDict
 from collections.abc import Callable, Coroutine
 from pathlib import Path
@@ -39,6 +40,7 @@ from deepy.mcp import load_mcp_config
 from deepy.prompts.init_agents import build_agents_init_prompt
 from deepy.prompts.rules import has_agents_instructions
 from deepy.sessions import DeepyJsonlSession, SessionEntry, list_session_entries
+from deepy.session_cost import balance_snapshot_to_dict, should_track_session_cost
 from deepy.sessions.manager import DeepySessionManager
 from deepy.skill_market import (
     InstalledSkill,
@@ -389,6 +391,7 @@ class DeepyTuiApp(App[None]):
         self._todo_text = ""
         self._local_command_sequence = 0
         self.exit_summary_text: str | None = None
+        self._pending_session_cost_start: dict[str, Any] | None = None
 
     def compose(self) -> ComposeResult:
         yield Header(show_clock=True)
@@ -495,6 +498,7 @@ class DeepyTuiApp(App[None]):
 
     def _start_model_turn(self, prompt: str, skill_names: list[str], *, status: str) -> None:
         self._clear_input_suggestion()
+        self._pending_session_cost_start = self._capture_session_cost_start()
         self.state = set_busy(reset_turn_buffers(self.state), True, status)
         self._assistant_block = None
         self._thinking_block = None
@@ -1166,6 +1170,7 @@ class DeepyTuiApp(App[None]):
         summary = message.summary
         await self._flush_assistant_block()
         self.state = set_session_id(self.state, summary.session_id)
+        self._record_pending_session_cost_start(summary.session_id)
         self.state = set_usage(self.state, summary.usage)
         self.state = set_pending_questions(self.state, summary.pending_questions)
         self.state = set_busy(self.state, False, "Idle")
@@ -1179,6 +1184,7 @@ class DeepyTuiApp(App[None]):
     @on(TurnFailedMessage)
     async def on_turn_failed(self, message: TurnFailedMessage) -> None:
         message.stop()
+        self._pending_session_cost_start = None
         self.state = set_busy(self.state, False, "Error")
         await self._append_block(ErrorBlock(str(message.error)))
         self._update_status("Error")
@@ -1468,6 +1474,7 @@ class DeepyTuiApp(App[None]):
         self.set_timer(2.0, self._clear_quit_confirm)
 
     def _exit_with_summary(self) -> None:
+        self._record_session_cost_end()
         self.exit_summary_text = self._build_exit_summary_text()
         self.exit()
 
@@ -1497,6 +1504,53 @@ class DeepyTuiApp(App[None]):
             session_id=self.state.session_id,
         )
 
+    def _capture_session_cost_start(self) -> dict[str, Any] | None:
+        if not should_track_session_cost(self.settings):
+            return None
+        if self.state.session_id and self._session_cost_has_start(self.state.session_id):
+            return None
+        return balance_snapshot_to_dict(
+            fetch_deepseek_balance(self.settings),
+            captured_at_ms=_now_ms(),
+        )
+
+    def _record_pending_session_cost_start(self, session_id: str | None) -> None:
+        if not session_id or self._pending_session_cost_start is None:
+            return
+        try:
+            DeepyJsonlSession.open(self.project_root, session_id).record_session_cost_start(
+                self._pending_session_cost_start
+            )
+        except Exception:
+            pass
+        finally:
+            self._pending_session_cost_start = None
+
+    def _record_session_cost_end(self) -> None:
+        session_id = self.state.session_id
+        if (
+            not session_id
+            or not should_track_session_cost(self.settings)
+            or not self._session_cost_has_start(session_id)
+        ):
+            return
+        snapshot = balance_snapshot_to_dict(
+            fetch_deepseek_balance(self.settings),
+            captured_at_ms=_now_ms(),
+        )
+        try:
+            DeepyJsonlSession.open(self.project_root, session_id).record_session_cost_end(snapshot)
+        except Exception:
+            return
+
+    def _session_cost_has_start(self, session_id: str) -> bool:
+        return any(
+            entry.id == session_id
+            and isinstance(entry.session_cost, dict)
+            and isinstance(entry.session_cost.get("start"), dict)
+            for entry in list_session_entries(self.project_root)
+        )
+
     def _clear_quit_confirm(self) -> None:
         if self.state.quit_confirm_pending:
             self.state = set_quit_confirm(self.state, False)
@@ -1924,6 +1978,10 @@ def _format_market_skills(skills: list[MarketSkill]) -> str:
     return "\n".join(lines)
 
 
+def _now_ms() -> int:
+    return int(time.time() * 1000)
+
+
 def _format_installed_records(records: list[InstalledSkill]) -> str:
     if not records:
         return "No market-installed skills."

{deepy_cli-0.2.9 → deepy_cli-0.2.11}/src/deepy/ui/exit_summary.py

@@ -4,6 +4,8 @@ from dataclasses import dataclass
 from collections.abc import Sequence
 from typing import Any, Mapping
 
+from deepy.session_cost import format_session_cost
+
 
 INNER_WIDTH = 98
 CONTENT_WIDTH = INNER_WIDTH - 4
@@ -92,6 +94,9 @@ def build_exit_summary_text(
                 ),
             )
         )
+    cost = format_session_cost(_get_session_cost(session))
+    if cost:
+        rows.append(("session cost", cost))
     return _simple_box("Deepy Session Summary", rows)
 
 def _usage_summary(
@@ -134,6 +139,14 @@ def _get_input_suggestion_usage(session: Any | None) -> Any:
     return getattr(session, "input_suggestion_usage", None)
 
 
+def _get_session_cost(session: Any | None) -> Any:
+    if session is None:
+        return None
+    if isinstance(session, Mapping):
+        return session.get("session_cost") or session.get("sessionCost")
+    return getattr(session, "session_cost", None)
+
+
 def _get_session_id(session: Any | None) -> str | None:
     if session is None:
         return None

{deepy_cli-0.2.9 → deepy_cli-0.2.11}/src/deepy/ui/terminal.py

@@ -15,6 +15,7 @@ from dataclasses import dataclass, replace
 from pathlib import Path
 from typing import Any
 
+from rich.cells import cell_len
 from rich.console import Console
 from rich.prompt import Prompt
 from rich.text import Text
@@ -47,6 +48,7 @@ from deepy.mcp import DeepyMcpRuntime, format_mcp_status
 from deepy.prompts.init_agents import build_agents_init_prompt
 from deepy.prompts.rules import has_agents_instructions
 from deepy.sessions import DeepyJsonlSession, SessionEntry, list_session_entries
+from deepy.session_cost import balance_snapshot_to_dict, should_track_session_cost
 from deepy.sessions.manager import DeepySessionManager
 from deepy.skill_market import (
     install_market_skill,
@@ -282,6 +284,7 @@ def run_interactive(
                         continue
                     request = slash.argument or f"Use the {skill.name} skill."
                     anchor_status_output = _print_submitted_user_input(output, text, palette=palette)
+                    cost_start = _capture_session_cost_start(root, session_id, settings)
                     summary = _run_once_with_status(
                         output,
                         run_once,
@@ -296,6 +299,7 @@ def run_interactive(
                         anchor_status_output_lines=1 if anchor_status_output else 0,
                     )
                     session_id = summary.session_id
+                    _record_session_cost_start(root, session_id, cost_start)
                     clarification_rounds = 0
                     while summary.status == "waiting_for_user":
                         if clarification_rounds >= MAX_CLARIFICATION_ROUNDS_PER_TURN:
@@ -308,6 +312,7 @@ def run_interactive(
                         if not response:
                             break
                         clarification_rounds += 1
+                        cost_start = _capture_session_cost_start(root, session_id, settings)
                         summary = _run_once_with_status(
                             output,
                             run_once,
@@ -322,6 +327,7 @@ def run_interactive(
                             anchor_status_output=True,
                         )
                         session_id = summary.session_id
+                        _record_session_cost_start(root, session_id, cost_start)
                     _print_assistant_output(output, summary.output, palette=palette)
                     _print_usage_footer(output, summary, settings=settings, project_root=root, palette=palette)
                     _prepare_input_suggestion(
@@ -340,6 +346,7 @@ def run_interactive(
                     continue
                 if slash.name == "init":
                     anchor_status_output = _print_submitted_user_input(output, text, palette=palette)
+                    cost_start = _capture_session_cost_start(root, session_id, settings)
                     summary = _run_once_with_status(
                         output,
                         run_once,
@@ -354,6 +361,7 @@ def run_interactive(
                         anchor_status_output_lines=1 if anchor_status_output else 0,
                     )
                     session_id = summary.session_id
+                    _record_session_cost_start(root, session_id, cost_start)
                     _print_assistant_output(output, summary.output, palette=palette)
                     _print_usage_footer(output, summary, settings=settings, project_root=root, palette=palette)
                     _prepare_input_suggestion(
@@ -407,6 +415,7 @@ def run_interactive(
                 continue
 
             anchor_status_output = _print_submitted_user_input(output, text, palette=palette)
+            cost_start = _capture_session_cost_start(root, session_id, settings)
             summary = _run_once_with_status(
                 output,
                 run_once,
@@ -421,6 +430,7 @@ def run_interactive(
                 anchor_status_output_lines=1 if anchor_status_output else 0,
             )
             session_id = summary.session_id
+            _record_session_cost_start(root, session_id, cost_start)
             clarification_rounds = 0
             while summary.status == "waiting_for_user":
                 if clarification_rounds >= MAX_CLARIFICATION_ROUNDS_PER_TURN:
@@ -433,6 +443,7 @@ def run_interactive(
                 if not response:
                     break
                 clarification_rounds += 1
+                cost_start = _capture_session_cost_start(root, session_id, settings)
                 summary = _run_once_with_status(
                     output,
                     run_once,
@@ -447,6 +458,7 @@ def run_interactive(
                     anchor_status_output=True,
                 )
                 session_id = summary.session_id
+                _record_session_cost_start(root, session_id, cost_start)
             _print_assistant_output(output, summary.output, palette=palette)
             _print_usage_footer(output, summary, settings=settings, project_root=root, palette=palette)
             _prepare_input_suggestion(
@@ -610,6 +622,7 @@ def _run_once_with_status(
             status_started_at=started_at,
             palette=active_palette,
             footer=footer,
+            output_lock=getattr(status, "output_lock", None),
         )
         stop_status_refresh = threading.Event()
         status_thread = threading.Thread(
@@ -805,6 +818,7 @@ class TerminalStreamRenderer:
         status_started_at: float | None = None,
         palette: UiPalette | None = None,
         footer: StatusFooter | None = None,
+        output_lock: threading.RLock | None = None,
     ) -> None:
         self.console = console
         self.project_root = project_root
@@ -818,16 +832,28 @@ class TerminalStreamRenderer:
         self.pending_tool_calls: dict[str, ToolCallDisplay] = {}
         self.reasoning_started = False
         self.reasoning_buffer = ""
+        self.output_lock = output_lock
 
     def __call__(self, event: DeepyStreamEvent) -> None:
-        _print_stream_event(
-            self.console,
-            event,
-            project_root=self.project_root,
-            pending_tool_calls=self.pending_tool_calls,
-            reasoning_sink=self,
-            palette=self.palette,
-        )
+        if self.output_lock is None:
+            _print_stream_event(
+                self.console,
+                event,
+                project_root=self.project_root,
+                pending_tool_calls=self.pending_tool_calls,
+                reasoning_sink=self,
+                palette=self.palette,
+            )
+            return
+        with self.output_lock:
+            _print_stream_event(
+                self.console,
+                event,
+                project_root=self.project_root,
+                pending_tool_calls=self.pending_tool_calls,
+                reasoning_sink=self,
+                palette=self.palette,
+            )
 
     def add_reasoning(self, text: str) -> None:
         if not text:
@@ -863,6 +889,13 @@ class TerminalStreamRenderer:
             )
 
     def flush(self) -> None:
+        if self.output_lock is not None:
+            with self.output_lock:
+                self._flush_unlocked()
+            return
+        self._flush_unlocked()
+
+    def _flush_unlocked(self) -> None:
         if self.reasoning_buffer:
             self.console.print()
         self.reasoning_started = False
@@ -1977,6 +2010,7 @@ def _print_exit_summary(
     session_entry: SessionEntry | None = None
     messages: list[dict[str, object]] = []
     if session_id:
+        _record_session_cost_end(project_root, session_id, settings)
         session_entry = next(
             (entry for entry in list_session_entries(project_root) if entry.id == session_id),
             None,
@@ -1995,6 +2029,60 @@ def _print_exit_summary(
     )
 
 
+def _capture_session_cost_start(
+    project_root: Path,
+    session_id: str | None,
+    settings: Settings,
+) -> dict[str, Any] | None:
+    if not should_track_session_cost(settings):
+        return None
+    if session_id and _session_cost_has_start(project_root, session_id):
+        return None
+    return balance_snapshot_to_dict(
+        fetch_deepseek_balance(settings),
+        captured_at_ms=_now_ms(),
+    )
+
+
+def _record_session_cost_start(
+    project_root: Path,
+    session_id: str | None,
+    snapshot: dict[str, Any] | None,
+) -> None:
+    if not session_id or snapshot is None:
+        return
+    try:
+        DeepyJsonlSession.open(project_root, session_id).record_session_cost_start(snapshot)
+    except Exception:
+        return
+
+
+def _record_session_cost_end(project_root: Path, session_id: str, settings: Settings) -> None:
+    if not should_track_session_cost(settings) or not _session_cost_has_start(project_root, session_id):
+        return
+    snapshot = balance_snapshot_to_dict(
+        fetch_deepseek_balance(settings),
+        captured_at_ms=_now_ms(),
+    )
+    try:
+        DeepyJsonlSession.open(project_root, session_id).record_session_cost_end(snapshot)
+    except Exception:
+        return
+
+
+def _session_cost_has_start(project_root: Path, session_id: str) -> bool:
+    return any(
+        entry.id == session_id
+        and isinstance(entry.session_cost, dict)
+        and isinstance(entry.session_cost.get("start"), dict)
+        for entry in list_session_entries(project_root)
+    )
+
+
+def _now_ms() -> int:
+    return int(time.time() * 1000)
+
+
 def _print_usage_footer(
     console: Console,
     summary: RunSummary,
@@ -2149,7 +2237,8 @@ def _status_display(
     anchor_output_lines: int = 0,
 ):
     if _should_use_bottom_status_overlay(console):
-        status = _TerminalBottomStatus(console, palette=palette)
+        output_lock = threading.RLock()
+        status = _TerminalBottomStatus(console, palette=palette, output_lock=output_lock)
         status.start(anchor_output=anchor_output, anchor_output_lines=anchor_output_lines)
         status.update(initial_status)
         try:
@@ -2172,54 +2261,60 @@ class _TerminalBottomStatus:
         console: Console,
         *,
         palette: UiPalette,
+        output_lock: threading.RLock | None = None,
     ) -> None:
         self.console = console
         self.palette = palette
         self.rows = 0
         self.columns = 0
+        self.output_lock = output_lock or threading.RLock()
 
     def start(self, *, anchor_output: bool = False, anchor_output_lines: int = 0) -> None:
-        self.columns, self.rows = shutil.get_terminal_size((80, 24))
-        if self.rows <= 1:
-            return
-        scroll_bottom = self.rows - 1
-        scroll_lines = max(anchor_output_lines, 2 if anchor_output else 0)
-        if scroll_lines:
-            output_row = max(scroll_bottom - scroll_lines + 1, 1)
-            scroll_text = "\n" * scroll_lines
-            self.console.file.write(
-                f"\x1b[1;{scroll_bottom}r\x1b[{scroll_bottom};1H"
-                f"{scroll_text}"
-                f"\x1b[{output_row};1H"
-            )
-        else:
-            self.console.file.write(f"\x1b7\x1b[1;{scroll_bottom}r\x1b[{scroll_bottom};1H\x1b8")
-        self.console.file.flush()
+        with self.output_lock:
+            self.columns, self.rows = shutil.get_terminal_size((80, 24))
+            if self.rows <= 1:
+                return
+            scroll_bottom = self.rows - 1
+            scroll_lines = max(anchor_output_lines, 2 if anchor_output else 0)
+            if scroll_lines:
+                output_row = max(scroll_bottom - scroll_lines + 1, 1)
+                scroll_text = "\n" * scroll_lines
+                self.console.file.write(
+                    f"\x1b[1;{scroll_bottom}r\x1b[{scroll_bottom};1H"
+                    f"{scroll_text}"
+                    f"\x1b[{output_row};1H"
+                )
+            else:
+                self.console.file.write(
+                    f"\x1b7\x1b[1;{scroll_bottom}r\x1b[{scroll_bottom};1H\x1b8"
+                )
+            self.console.file.flush()
 
     def update(self, status: Text) -> None:
-        columns, rows = shutil.get_terminal_size((80, 24))
-        self.columns = columns
-        self.rows = rows
-        if rows <= 1:
-            return
-        self._write_line(rows, status.plain, _terminal_runtime_status_style(self.palette))
-        self.console.file.flush()
+        with self.output_lock:
+            columns, rows = shutil.get_terminal_size((80, 24))
+            self.columns = columns
+            self.rows = rows
+            if rows <= 1:
+                return
+            self._write_line(rows, status.plain, _terminal_runtime_status_style(self.palette))
+            self.console.file.flush()
 
     def clear(self) -> None:
-        columns, rows = shutil.get_terminal_size((80, 24))
-        self.columns = columns
-        self.rows = rows
-        if rows <= 1:
-            return
-        self.console.file.write("\x1b7\x1b[r")
-        self.console.file.write(f"\x1b[{rows};1H\x1b[2K")
-        self.console.file.write("\x1b8")
-        self.console.file.flush()
+        with self.output_lock:
+            columns, rows = shutil.get_terminal_size((80, 24))
+            self.columns = columns
+            self.rows = rows
+            if rows <= 1:
+                return
+            self.console.file.write("\x1b7\x1b[r")
+            self.console.file.write(f"\x1b[{rows};1H\x1b[2K")
+            self.console.file.write("\x1b8")
+            self.console.file.flush()
 
     def _write_line(self, row: int, text: str, style: str) -> None:
         width = max(self.columns - 1, 1)
-        line = _truncate_status_line(text, max_width=width)
-        padded = line.ljust(width)
+        padded = _fit_status_line(text, width=width)
         self.console.file.write(f"\x1b7\x1b[{row};1H\x1b[2K{style}{padded}\x1b[0m\x1b8")
 
 
@@ -2261,11 +2356,26 @@ def _ansi_rgb(prefix: str, color: str) -> str:
 
 
 def _truncate_status_line(text: str, *, max_width: int) -> str:
-    if len(text) <= max_width:
+    if cell_len(text) <= max_width:
         return text
     if max_width <= 1:
-        return text[:max_width]
-    return f"{text[: max_width - 1]}…"
+        return "…" if max_width == 1 else ""
+    suffix = "…"
+    available = max_width - cell_len(suffix)
+    used = 0
+    result: list[str] = []
+    for char in text:
+        char_width = cell_len(char)
+        if used + char_width > available:
+            break
+        result.append(char)
+        used += char_width
+    return "".join(result).rstrip() + suffix
+
+
+def _fit_status_line(text: str, *, width: int) -> str:
+    line = _truncate_status_line(text, max_width=max(width, 0))
+    return line + (" " * max(0, width - cell_len(line)))
 
 
 def _working_status_text(
@@ -2464,19 +2574,12 @@ def _windows_terminal_cursor_row() -> int | None:
     try:
         windll = getattr(ctypes, "windll")
         kernel32 = windll.kernel32
-        with contextlib.suppress(Exception):
-            kernel32.GetStdHandle.argtypes = [wintypes.DWORD]
-            kernel32.GetStdHandle.restype = wintypes.HANDLE
-            kernel32.GetConsoleScreenBufferInfo.argtypes = [
-                wintypes.HANDLE,
-                ctypes.POINTER(_WindowsConsoleScreenBufferInfo),
-            ]
-            kernel32.GetConsoleScreenBufferInfo.restype = wintypes.BOOL
-        handle = kernel32.GetStdHandle(_STD_OUTPUT_HANDLE)
+        get_std_handle, get_console_screen_buffer_info = _windows_console_functions(kernel32)
+        handle = get_std_handle(_STD_OUTPUT_HANDLE)
         if handle in {None, 0, _INVALID_HANDLE_VALUE}:
             return None
         info = _WindowsConsoleScreenBufferInfo()
-        if not kernel32.GetConsoleScreenBufferInfo(handle, ctypes.byref(info)):
+        if not get_console_screen_buffer_info(handle, ctypes.byref(info)):
             return None
         return _visible_cursor_row_from_windows_buffer(
             cursor_y=int(info.dwCursorPosition.Y),
@@ -2487,6 +2590,20 @@ def _windows_terminal_cursor_row() -> int | None:
         return None
 
 
+def _windows_console_functions(kernel32: Any) -> tuple[Callable[[int], Any], Callable[[Any, Any], Any]]:
+    prototype_factory = getattr(ctypes, "WINFUNCTYPE", None)
+    if prototype_factory is None:
+        return kernel32.GetStdHandle, kernel32.GetConsoleScreenBufferInfo
+    return (
+        prototype_factory(wintypes.HANDLE, wintypes.DWORD)(("GetStdHandle", kernel32)),
+        prototype_factory(
+            wintypes.BOOL,
+            wintypes.HANDLE,
+            ctypes.POINTER(_WindowsConsoleScreenBufferInfo),
+        )(("GetConsoleScreenBufferInfo", kernel32)),
+    )
+
+
 def _visible_cursor_row_from_windows_buffer(
     *,
     cursor_y: int,