copilot-cli-trace-deck 0.1.0__tar.gz → 0.2.0__tar.gz

{copilot_cli_trace_deck-0.1.0 → copilot_cli_trace_deck-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: copilot-cli-trace-deck
-Version: 0.1.0
+Version: 0.2.0
 Summary: Render GitHub Copilot CLI agent debug logs into a clear, inspectable trace view.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -41,6 +41,8 @@ By default the server listens on `http://127.0.0.1:9887` and opens that URL in y
 
 Live updates are pushed over Server-Sent Events and triggered by file-system changes in the session-state directory, so the home, summary, logs, and flow pages update without browser polling.
 
+The summary view also estimates per-session GitHub AI Credits / USD cost from shutdown metrics, aggregating token usage across model switches within the same session.
+
 You can also pass the session-state source and server options:
 
 ```bash

{copilot_cli_trace_deck-0.1.0 → copilot_cli_trace_deck-0.2.0}/README.md

@@ -31,6 +31,8 @@ By default the server listens on `http://127.0.0.1:9887` and opens that URL in y
 
 Live updates are pushed over Server-Sent Events and triggered by file-system changes in the session-state directory, so the home, summary, logs, and flow pages update without browser polling.
 
+The summary view also estimates per-session GitHub AI Credits / USD cost from shutdown metrics, aggregating token usage across model switches within the same session.
+
 You can also pass the session-state source and server options:
 
 ```bash

{copilot_cli_trace_deck-0.1.0 → copilot_cli_trace_deck-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "copilot-cli-trace-deck"
-version = "0.1.0"
+version = "0.2.0"
 description = "Render GitHub Copilot CLI agent debug logs into a clear, inspectable trace view."
 readme = "README.md"
 requires-python = ">=3.10"

{copilot_cli_trace_deck-0.1.0 → copilot_cli_trace_deck-0.2.0}/src/copilot_cli_trace_deck/data/sessions.py

@@ -1,10 +1,48 @@
 from __future__ import annotations
 
 import json
+from dataclasses import dataclass
 from datetime import datetime
+from decimal import Decimal
 from pathlib import Path
 
-from ..models import SessionFlowNode, SessionLogEntry, SessionLogSection, SessionPreview, SessionSummary
+from ..models import SessionFlowNode, SessionLogEntry, SessionLogSection, SessionModelUsage, SessionPreview, SessionSummary
+
+
+@dataclass(frozen=True)
+class ModelPricing:
+    input_usd_per_million: Decimal
+    cached_input_usd_per_million: Decimal
+    output_usd_per_million: Decimal
+    cache_write_usd_per_million: Decimal = Decimal("0")
+
+
+AI_CREDIT_USD = Decimal("0.01")
+TOKENS_PER_MILLION = Decimal("1000000")
+MODEL_PRICING: dict[str, ModelPricing] = {
+    "gpt-4.1": ModelPricing(Decimal("2.00"), Decimal("0.50"), Decimal("8.00")),
+    "gpt-5-mini": ModelPricing(Decimal("0.25"), Decimal("0.025"), Decimal("2.00")),
+    "gpt-5.2": ModelPricing(Decimal("1.75"), Decimal("0.175"), Decimal("14.00")),
+    "gpt-5.2-codex": ModelPricing(Decimal("1.75"), Decimal("0.175"), Decimal("14.00")),
+    "gpt-5.3-codex": ModelPricing(Decimal("1.75"), Decimal("0.175"), Decimal("14.00")),
+    "gpt-5.4": ModelPricing(Decimal("2.50"), Decimal("0.25"), Decimal("15.00")),
+    "gpt-5.4-mini": ModelPricing(Decimal("0.75"), Decimal("0.075"), Decimal("4.50")),
+    "gpt-5.4-nano": ModelPricing(Decimal("0.20"), Decimal("0.02"), Decimal("1.25")),
+    "gpt-5.5": ModelPricing(Decimal("5.00"), Decimal("0.50"), Decimal("30.00")),
+    "claude-haiku-4.5": ModelPricing(Decimal("1.00"), Decimal("0.10"), Decimal("5.00"), Decimal("1.25")),
+    "claude-sonnet-4": ModelPricing(Decimal("3.00"), Decimal("0.30"), Decimal("15.00"), Decimal("3.75")),
+    "claude-sonnet-4.5": ModelPricing(Decimal("3.00"), Decimal("0.30"), Decimal("15.00"), Decimal("3.75")),
+    "claude-sonnet-4.6": ModelPricing(Decimal("3.00"), Decimal("0.30"), Decimal("15.00"), Decimal("3.75")),
+    "claude-opus-4.5": ModelPricing(Decimal("5.00"), Decimal("0.50"), Decimal("25.00"), Decimal("6.25")),
+    "claude-opus-4.6": ModelPricing(Decimal("5.00"), Decimal("0.50"), Decimal("25.00"), Decimal("6.25")),
+    "claude-opus-4.7": ModelPricing(Decimal("5.00"), Decimal("0.50"), Decimal("25.00"), Decimal("6.25")),
+    "gemini-2.5-pro": ModelPricing(Decimal("1.25"), Decimal("0.125"), Decimal("10.00")),
+    "gemini-3-flash": ModelPricing(Decimal("0.50"), Decimal("0.05"), Decimal("3.00")),
+    "gemini-3.1-pro": ModelPricing(Decimal("2.00"), Decimal("0.20"), Decimal("12.00")),
+    "gemini-3.5-flash": ModelPricing(Decimal("1.50"), Decimal("0.15"), Decimal("9.00")),
+    "raptor-mini": ModelPricing(Decimal("0.25"), Decimal("0.025"), Decimal("2.00")),
+    "goldeneye": ModelPricing(Decimal("1.25"), Decimal("0.125"), Decimal("10.00")),
+}
 
 
 def load_session_previews(session_root: Path) -> list[SessionPreview]:
@@ -21,20 +59,28 @@ def load_session_previews(session_root: Path) -> list[SessionPreview]:
         if not title:
             continue
 
-        updated_at = metadata.get("updated_at") or metadata.get("created_at") or ""
+        events = read_jsonl_events(session_dir / "events.jsonl")
+        shutdown_event = find_current_shutdown_event(events)
+        model_name = find_current_model(events, shutdown_event)
+        updated_at = last_event_timestamp(events) or metadata.get("updated_at") or metadata.get("created_at") or first_event_timestamp(events)
         session_rows.append(
             (
                 updated_at,
-                SessionPreview(session_id=session_dir.name, title=title),
+                SessionPreview(
+                    session_id=session_dir.name,
+                    title=title,
+                    status="Idle" if shutdown_event else "Active",
+                    model_name=model_name,
+                    repository=repository_name(metadata.get("repository", "")),
+                    branch=metadata.get("branch", ""),
+                    updated_label=format_timestamp(updated_at) if updated_at else "",
+                    is_active=shutdown_event is None,
+                ),
             )
         )
 
     session_rows.sort(key=lambda item: item[0], reverse=True)
-    previews = [session for _, session in session_rows]
-    if previews:
-        active = previews[0]
-        previews[0] = SessionPreview(session_id=active.session_id, title=active.title, is_active=True)
-    return previews
+    return [session for _, session in session_rows]
 
 
 def load_session_summary(session_root: Path, session_id: str) -> SessionSummary | None:
@@ -48,11 +94,13 @@ def load_session_summary(session_root: Path, session_id: str) -> SessionSummary
         return None
 
     events = read_jsonl_events(session_dir / "events.jsonl")
-    shutdown_event = next((event for event in reversed(events) if event.get("type") == "session.shutdown"), None)
+    shutdown_event = find_current_shutdown_event(events)
     model_name = find_current_model(events, shutdown_event)
-    usage = extract_usage(shutdown_event, model_name)
+    model_usages, billing_stage = extract_model_usages(events, shutdown_event)
+    usage = aggregate_usage(model_usages)
+    estimated_cost_usd, estimated_ai_credits, billing_note = build_billing_estimate(model_usages, billing_stage)
     created_value = metadata.get("created_at") or first_event_timestamp(events)
-    updated_value = metadata.get("updated_at") or last_event_timestamp(events) or created_value
+    updated_value = last_event_timestamp(events) or metadata.get("updated_at") or created_value
 
     return SessionSummary(
         session_id=session_id,
@@ -63,6 +111,7 @@ def load_session_summary(session_root: Path, session_id: str) -> SessionSummary
         location="CLI",
         status="Idle" if shutdown_event else "Active",
         model_name=model_name or "Unknown",
+        models_used_label=build_models_used_label(model_usages, model_name),
         repository=repository_name(metadata.get("repository", "")),
         branch=metadata.get("branch", ""),
         model_turns=count_events(events, "assistant.turn_start"),
@@ -70,7 +119,12 @@ def load_session_summary(session_root: Path, session_id: str) -> SessionSummary
         total_input_tokens=usage.get("inputTokens", 0),
         total_output_tokens=usage.get("outputTokens", 0),
         total_cached_input_tokens=usage.get("cacheReadTokens", 0),
+        total_cache_write_tokens=usage.get("cacheWriteTokens", 0),
         total_tokens=usage.get("inputTokens", 0) + usage.get("outputTokens", 0),
+        estimated_cost_usd=estimated_cost_usd,
+        estimated_ai_credits=estimated_ai_credits,
+        billing_note=billing_note,
+        model_usages=model_usages,
         error_count=count_errors(events),
     )
 
@@ -90,7 +144,7 @@ def load_session_flow(session_root: Path, session_id: str) -> list[SessionFlowNo
         return None
 
     events = read_jsonl_events(session_dir / "events.jsonl")
-    shutdown_event = next((event for event in reversed(events) if event.get("type") == "session.shutdown"), None)
+    shutdown_event = find_current_shutdown_event(events)
     model_name = find_current_model(events, shutdown_event) or "Unknown"
     return build_flow_nodes(events, model_name)
 
@@ -143,30 +197,308 @@ def find_current_model(events: list[dict], shutdown_event: dict | None) -> str:
     return ""
 
 
-def extract_usage(shutdown_event: dict | None, current_model: str) -> dict[str, int]:
+def find_current_shutdown_event(events: list[dict]) -> dict | None:
+    latest_shutdown: dict | None = None
+    latest_shutdown_index = -1
+    latest_lifecycle_resume_index = -1
+
+    for index, event in enumerate(events):
+        event_type = event.get("type")
+        if event_type == "session.shutdown":
+            latest_shutdown = event
+            latest_shutdown_index = index
+            continue
+        if event_type in {"session.start", "session.resume"}:
+            latest_lifecycle_resume_index = index
+
+    if latest_shutdown_index == -1:
+        return None
+    if latest_lifecycle_resume_index > latest_shutdown_index:
+        return None
+    return latest_shutdown
+
+
+def extract_model_usages(events: list[dict], shutdown_event: dict | None) -> tuple[list[SessionModelUsage], str]:
+    shutdown_model_usages = extract_all_shutdown_model_usages(events)
+    if shutdown_event:
+        return shutdown_model_usages, "shutdown"
+
+    live_model_usages = extract_live_model_usages_since_last_shutdown(events)
+    merged_model_usages = merge_model_usages(shutdown_model_usages, live_model_usages)
+    if merged_model_usages:
+        return merged_model_usages, "live"
+    return [], "pending"
+
+
+def extract_all_shutdown_model_usages(events: list[dict]) -> list[SessionModelUsage]:
+    merged_model_usages: list[SessionModelUsage] = []
+    for event in events:
+        if event.get("type") != "session.shutdown":
+            continue
+        merged_model_usages = merge_model_usages(merged_model_usages, extract_shutdown_model_usages(event))
+    return merged_model_usages
+
+
+def extract_shutdown_model_usages(shutdown_event: dict | None) -> list[SessionModelUsage]:
     if not shutdown_event:
-        return {}
+        return []
 
     model_metrics = shutdown_event.get("data", {}).get("modelMetrics", {})
-    if not isinstance(model_metrics, dict) or not model_metrics:
-        return {}
+    if not isinstance(model_metrics, dict):
+        return []
 
-    if current_model and current_model in model_metrics:
-        usage = model_metrics[current_model].get("usage", {})
-    else:
-        first_metrics = next(iter(model_metrics.values()))
-        usage = first_metrics.get("usage", {}) if isinstance(first_metrics, dict) else {}
+    model_usages: list[SessionModelUsage] = []
+    for model_name, metrics in model_metrics.items():
+        if not isinstance(model_name, str) or not isinstance(metrics, dict):
+            continue
+        usage = metrics.get("usage", {})
+        if not isinstance(usage, dict):
+            continue
 
-    if not isinstance(usage, dict):
-        return {}
+        model_usage = build_model_usage(model_name, usage)
+        if model_usage is None:
+            continue
+        model_usages.append(model_usage)
+
+    model_usages.sort(key=model_usage_sort_key, reverse=True)
+    return model_usages
+
+
+def extract_live_model_usages(events: list[dict]) -> list[SessionModelUsage]:
+    usage_by_model: dict[str, dict[str, int]] = {}
+    current_model = ""
+    for event in events:
+        event_type = str(event.get("type") or "")
+        data = event.get("data") if isinstance(event.get("data"), dict) else {}
+        if event_type == "session.model_change":
+            model_name = data.get("newModel")
+            if isinstance(model_name, str) and model_name:
+                current_model = model_name
+            continue
+
+        if event_type != "assistant.message":
+            continue
 
+        model_name = data.get("model")
+        if not isinstance(model_name, str) or not model_name:
+            model_name = current_model
+        if not model_name:
+            continue
+
+        usage = usage_by_model.setdefault(
+            model_name,
+            {
+                "inputTokens": 0,
+                "outputTokens": 0,
+                "cacheReadTokens": 0,
+                "cacheWriteTokens": 0,
+            },
+        )
+        usage["inputTokens"] += parse_token_count(data.get("inputTokens"))
+        usage["outputTokens"] += parse_token_count(data.get("outputTokens"))
+        usage["cacheReadTokens"] += parse_token_count(data.get("cacheReadTokens"))
+        usage["cacheWriteTokens"] += parse_token_count(data.get("cacheWriteTokens"))
+
+    model_usages = [
+        model_usage
+        for model_name, usage in usage_by_model.items()
+        if (model_usage := build_model_usage(model_name, usage)) is not None
+    ]
+    model_usages.sort(key=model_usage_sort_key, reverse=True)
+    return model_usages
+
+
+def extract_live_model_usages_since_last_shutdown(events: list[dict]) -> list[SessionModelUsage]:
+    last_shutdown_index = -1
+    for index, event in enumerate(events):
+        if event.get("type") == "session.shutdown":
+            last_shutdown_index = index
+    return extract_live_model_usages(events[last_shutdown_index + 1 :])
+
+
+def build_model_usage(model_name: str, usage: dict[str, object]) -> SessionModelUsage | None:
+    if not model_name:
+        return None
+
+    input_tokens = parse_token_count(usage.get("inputTokens"))
+    output_tokens = parse_token_count(usage.get("outputTokens"))
+    cached_input_tokens = parse_token_count(usage.get("cacheReadTokens"))
+    cache_write_tokens = parse_token_count(usage.get("cacheWriteTokens"))
+    total_tokens = input_tokens + output_tokens + cached_input_tokens + cache_write_tokens
+    estimated_cost_usd = estimate_model_cost(
+        model_name,
+        input_tokens=input_tokens,
+        cached_input_tokens=cached_input_tokens,
+        cache_write_tokens=cache_write_tokens,
+        output_tokens=output_tokens,
+    )
+
+    return SessionModelUsage(
+        model_name=model_name,
+        input_tokens=input_tokens,
+        cached_input_tokens=cached_input_tokens,
+        cache_write_tokens=cache_write_tokens,
+        output_tokens=output_tokens,
+        total_tokens=total_tokens,
+        estimated_cost_usd=estimated_cost_usd,
+    )
+
+
+def merge_model_usages(*usage_lists: list[SessionModelUsage]) -> list[SessionModelUsage]:
+    merged_usage: dict[str, dict[str, int]] = {}
+    for usage_list in usage_lists:
+        for item in usage_list:
+            usage = merged_usage.setdefault(
+                item.model_name,
+                {
+                    "inputTokens": 0,
+                    "outputTokens": 0,
+                    "cacheReadTokens": 0,
+                    "cacheWriteTokens": 0,
+                },
+            )
+            usage["inputTokens"] += item.input_tokens
+            usage["outputTokens"] += item.output_tokens
+            usage["cacheReadTokens"] += item.cached_input_tokens
+            usage["cacheWriteTokens"] += item.cache_write_tokens
+
+    model_usages = [
+        model_usage
+        for model_name, usage in merged_usage.items()
+        if (model_usage := build_model_usage(model_name, usage)) is not None
+    ]
+    model_usages.sort(key=model_usage_sort_key, reverse=True)
+    return model_usages
+
+
+def aggregate_usage(model_usages: list[SessionModelUsage]) -> dict[str, int]:
     return {
-        "inputTokens": int(usage.get("inputTokens", 0) or 0),
-        "outputTokens": int(usage.get("outputTokens", 0) or 0),
-        "cacheReadTokens": int(usage.get("cacheReadTokens", 0) or 0),
+        "inputTokens": sum(item.input_tokens for item in model_usages),
+        "outputTokens": sum(item.output_tokens for item in model_usages),
+        "cacheReadTokens": sum(item.cached_input_tokens for item in model_usages),
+        "cacheWriteTokens": sum(item.cache_write_tokens for item in model_usages),
     }
 
 
+def parse_token_count(raw_value: object) -> int:
+    try:
+        return int(raw_value or 0)
+    except (TypeError, ValueError):
+        return 0
+
+
+def estimate_model_cost(
+    model_name: str,
+    *,
+    input_tokens: int,
+    cached_input_tokens: int,
+    cache_write_tokens: int,
+    output_tokens: int,
+) -> Decimal | None:
+    pricing = lookup_model_pricing(model_name)
+    if not pricing:
+        return Decimal("0") if not any((input_tokens, cached_input_tokens, cache_write_tokens, output_tokens)) else None
+
+    return (
+        Decimal(input_tokens) * pricing.input_usd_per_million
+        + Decimal(cached_input_tokens) * pricing.cached_input_usd_per_million
+        + Decimal(cache_write_tokens) * pricing.cache_write_usd_per_million
+        + Decimal(output_tokens) * pricing.output_usd_per_million
+    ) / TOKENS_PER_MILLION
+
+
+def build_billing_estimate(model_usages: list[SessionModelUsage], billing_stage: str) -> tuple[Decimal | None, Decimal | None, str]:
+    if not model_usages:
+        if billing_stage == "live":
+            return None, None, "Live billing estimate will appear after the first assistant response. Copilot only publishes live output tokens; input and cache token counters refresh on session shutdown."
+        return None, None, "Billing estimate appears after session shutdown publishes model metrics."
+
+    missing_pricing = [item.model_name for item in model_usages if item.total_tokens and item.estimated_cost_usd is None]
+    known_costs = [item.estimated_cost_usd for item in model_usages if item.estimated_cost_usd is not None]
+    if not known_costs and missing_pricing:
+        missing_models = ", ".join(missing_pricing)
+        return None, None, f"Billing estimate unavailable because pricing is missing for: {missing_models}."
+
+    estimated_cost_usd = sum(known_costs, Decimal("0"))
+    estimated_ai_credits = estimated_cost_usd / AI_CREDIT_USD
+    if missing_pricing:
+        missing_models = ", ".join(missing_pricing)
+        if billing_stage == "live":
+            note = f"Live partial estimate. Completed shutdown metrics are included when available; the active segment contributes output tokens only because Copilot does not publish live input or cache token counts. Unpriced models excluded: {missing_models}. Final shutdown metrics may increase totals."
+        else:
+            note = f"Partial estimate. Unpriced models excluded: {missing_models}."
+    elif billing_stage == "live":
+        note = "Live estimate includes completed shutdown metrics plus live output tokens from the active event log tail. Input and cache token totals refresh on the next session shutdown."
+    else:
+        note = "Estimate aggregates all models recorded in session shutdown metrics."
+    return estimated_cost_usd, estimated_ai_credits, note
+
+
+def build_models_used_label(model_usages: list[SessionModelUsage], current_model: str) -> str:
+    model_names = [item.model_name for item in model_usages if item.model_name]
+    if not model_names:
+        return current_model or "Unknown"
+    if len(model_names) == 1:
+        return model_names[0]
+
+    primary_model = current_model if current_model in model_names else model_names[0]
+    remaining_models = len(model_names) - 1
+    return f"{primary_model} + {remaining_models} more"
+
+
+def model_usage_sort_key(item: SessionModelUsage) -> tuple[int, Decimal, int, str]:
+    estimated_cost = item.estimated_cost_usd if item.estimated_cost_usd is not None else Decimal("-1")
+    has_pricing = 1 if item.estimated_cost_usd is not None else 0
+    return has_pricing, estimated_cost, item.total_tokens, item.model_name.lower()
+
+
+def lookup_model_pricing(model_name: str) -> ModelPricing | None:
+    for candidate in model_key_candidates(model_name):
+        pricing = MODEL_PRICING.get(candidate)
+        if pricing:
+            return pricing
+    return None
+
+
+def model_key_candidates(model_name: str) -> list[str]:
+    raw_candidates = {model_name}
+    for separator in ("/", ":", "@"):
+        if separator in model_name:
+            raw_candidates.add(model_name.rsplit(separator, 1)[-1])
+
+    normalized_candidates: list[str] = []
+    seen: set[str] = set()
+    for raw_candidate in raw_candidates:
+        candidate = normalize_model_key(raw_candidate)
+        for variant in candidate_variants(candidate):
+            if variant and variant not in seen:
+                seen.add(variant)
+                normalized_candidates.append(variant)
+    return normalized_candidates
+
+
+def candidate_variants(candidate: str) -> list[str]:
+    variants = [candidate]
+    for suffix in ("-public-preview", "-preview", "-ga"):
+        if candidate.endswith(suffix):
+            variants.append(candidate[: -len(suffix)])
+    return variants
+
+
+def normalize_model_key(value: str) -> str:
+    normalized_chars: list[str] = []
+    previous_is_separator = False
+    for char in value.strip().lower():
+        if char.isalnum() or char == ".":
+            normalized_chars.append(char)
+            previous_is_separator = False
+            continue
+        if not previous_is_separator:
+            normalized_chars.append("-")
+            previous_is_separator = True
+    return "".join(normalized_chars).strip("-")
+
+
 def count_events(events: list[dict], event_type: str) -> int:
     return sum(1 for event in events if event.get("type") == event_type)
 
@@ -379,6 +711,11 @@ def build_flow_nodes(events: list[dict], model_name: str) -> list[SessionFlowNod
                 pending_tools[tool_call_id] = data
             continue
 
+        if event_type == "session.resume":
+            nodes.append(build_resume_flow_node(next_index, event, event_index))
+            next_index += 1
+            continue
+
         if event_type in {"hook.start", "hook.end", "assistant.turn_start", "assistant.turn_end", "session.start", "session.model_change", "system.message", "session.shutdown"}:
             continue
 
@@ -611,11 +948,27 @@ def build_abort_flow_node(index: int, event: dict, event_index: int) -> SessionF
     )
 
 
+def build_resume_flow_node(index: int, event: dict, event_index: int) -> SessionFlowNode:
+    data = event.get("data") if isinstance(event.get("data"), dict) else {}
+    return SessionFlowNode(
+        index=index,
+        kind="state",
+        title="Session Resumed",
+        subtitle=format_log_timestamp(str(event.get("timestamp") or "")),
+        detail=compact_text(pretty_value(data), 180) if data else "Resumed previous Copilot CLI session",
+        meta="",
+        log_index=event_index,
+        status="muted",
+    )
+
+
 def flow_event_label(event: dict) -> str:
     event_type = str(event.get("type") or "event")
     data = event.get("data") if isinstance(event.get("data"), dict) else {}
     if event_type == "subagent.selected":
         return str(data.get("agentDisplayName") or data.get("agentName") or "Subagent")
+    if event_type == "session.resume":
+        return "Session Resumed"
     if event_type == "session.model_change":
         return str(data.get("newModel") or "Model selected")
     if event_type == "user.message" and is_internal_user_message(data):

{copilot_cli_trace_deck-0.1.0 → copilot_cli_trace_deck-0.2.0}/src/copilot_cli_trace_deck/models.py

@@ -1,12 +1,18 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from decimal import Decimal
 
 
 @dataclass(frozen=True)
 class SessionPreview:
     session_id: str
     title: str
+    status: str = ""
+    model_name: str = ""
+    repository: str = ""
+    branch: str = ""
+    updated_label: str = ""
     is_active: bool = False
 
 
@@ -27,10 +33,27 @@ class SessionSummary:
     total_input_tokens: int
     total_output_tokens: int
     total_cached_input_tokens: int
+    total_cache_write_tokens: int
     total_tokens: int
+    estimated_cost_usd: Decimal | None
+    estimated_ai_credits: Decimal | None
+    billing_note: str
+    models_used_label: str
+    model_usages: list["SessionModelUsage"]
     error_count: int
 
 
+@dataclass(frozen=True)
+class SessionModelUsage:
+    model_name: str
+    input_tokens: int
+    cached_input_tokens: int
+    cache_write_tokens: int
+    output_tokens: int
+    total_tokens: int
+    estimated_cost_usd: Decimal | None
+
+
 @dataclass(frozen=True)
 class SessionLogSection:
     title: str

{copilot_cli_trace_deck-0.1.0 → copilot_cli_trace_deck-0.2.0}/src/copilot_cli_trace_deck/web/pages.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import html
 import json
+from decimal import Decimal
 
 from ..models import SessionFlowNode, SessionLogEntry, SessionLogSection, SessionPreview, SessionSummary
 
@@ -199,6 +200,13 @@ def render_document(page_title: str, body: str) -> str:
         min-width: 0;
       }}
 
+      .session-copy {{
+        min-width: 0;
+        display: flex;
+        flex-direction: column;
+        gap: 6px;
+      }}
+
       .session-title {{
         margin: 0;
         font-size: clamp(0.96rem, 1.2vw, 1.28rem);
@@ -211,6 +219,20 @@ def render_document(page_title: str, body: str) -> str:
         text-overflow: ellipsis;
       }}
 
+      .session-meta {{
+        display: flex;
+        flex-wrap: wrap;
+        gap: 6px 10px;
+        color: #8d97a6;
+        font-size: 0.84rem;
+        line-height: 1.35;
+        letter-spacing: -0.015em;
+      }}
+
+      .session-meta-item {{
+        white-space: nowrap;
+      }}
+
       .icon {{
         flex: none;
         width: 24px;
@@ -338,13 +360,13 @@ def render_document(page_title: str, body: str) -> str:
 
       .card-grid {{
         display: grid;
-        grid-template-columns: repeat(6, minmax(180px, 1fr));
+        grid-template-columns: repeat(auto-fit, minmax(210px, 1fr));
         gap: 18px;
       }}
 
       .stat-card {{
         min-height: 102px;
-        padding: 20px 24px 18px;
+        padding: 20px 18px 18px;
         border: 1px solid var(--line);
         border-radius: 12px;
         background: rgba(9, 13, 20, 0.68);
@@ -354,12 +376,11 @@ def render_document(page_title: str, body: str) -> str:
       .stat-label {{
         display: block;
         color: var(--muted);
-        font-size: 0.9rem;
+        font-size: clamp(0.76rem, 0.72rem + 0.18vw, 0.88rem);
         line-height: 1.25;
         font-weight: 600;
+        letter-spacing: -0.02em;
         white-space: nowrap;
-        overflow: hidden;
-        text-overflow: ellipsis;
       }}
 
       .stat-value {{
@@ -373,6 +394,75 @@ def render_document(page_title: str, body: str) -> str:
         color: var(--text);
       }}
 
+      .billing-note {{
+        margin: 16px 0 0;
+        color: var(--muted);
+        font-size: 0.94rem;
+        line-height: 1.5;
+      }}
+
+      .model-usage-panel {{
+        margin-top: 18px;
+        border: 1px solid var(--line);
+        border-radius: 12px;
+        background: rgba(9, 13, 20, 0.68);
+        overflow: hidden;
+      }}
+
+      .model-usage-title {{
+        padding: 16px 18px 0;
+        color: var(--text);
+        font-size: 0.96rem;
+        line-height: 1.3;
+        font-weight: 600;
+      }}
+
+      .model-usage-scroller {{
+        overflow-x: auto;
+        padding: 12px 18px 18px;
+      }}
+
+      .model-usage-table {{
+        width: 100%;
+        min-width: 760px;
+        border-collapse: collapse;
+        font-variant-numeric: tabular-nums;
+      }}
+
+      .model-usage-table th,
+      .model-usage-table td {{
+        padding: 12px 0;
+        border-bottom: 1px solid rgba(255, 255, 255, 0.07);
+        text-align: left;
+      }}
+
+      .model-usage-table th {{
+        color: var(--muted);
+        font-size: 0.82rem;
+        line-height: 1.2;
+        font-weight: 700;
+        letter-spacing: 0.02em;
+        text-transform: uppercase;
+      }}
+
+      .model-usage-table tbody tr:last-child td {{
+        border-bottom: 0;
+      }}
+
+      .model-usage-table td {{
+        color: var(--text);
+        font-size: 0.95rem;
+        line-height: 1.35;
+        font-weight: 500;
+      }}
+
+      .model-usage-empty {{
+        padding: 16px 18px 18px;
+        color: var(--muted);
+        font-size: 0.94rem;
+        line-height: 1.5;
+      }}
+
       .action-row {{
         display: flex;
         flex-wrap: wrap;
@@ -525,6 +615,45 @@ def build_index_page(session_previews: list[SessionPreview]) -> str:
           let isPolling = false;
           let lastMarkup = sessionList ? sessionList.innerHTML.trim() : '';
 
+          function parseSessionItems(markup) {{
+            const template = document.createElement('template');
+            template.innerHTML = '<ul>' + markup + '</ul>';
+            return Array.from(template.content.querySelectorAll('li[data-session-id]'));
+          }}
+
+          function syncSessionList(markup) {{
+            if (!sessionList) {{
+              return;
+            }}
+
+            const nextItems = parseSessionItems(markup);
+            const existingItems = new Map(
+              Array.from(sessionList.querySelectorAll('li[data-session-id]')).map((item) => [item.dataset.sessionId || '', item]),
+            );
+
+            nextItems.forEach((nextItem, index) => {{
+              const sessionId = nextItem.dataset.sessionId || '';
+              const currentItem = existingItems.get(sessionId);
+              let itemToPlace = nextItem;
+
+              if (currentItem) {{
+                existingItems.delete(sessionId);
+                if (currentItem.outerHTML === nextItem.outerHTML) {{
+                  itemToPlace = currentItem;
+                }} else {{
+                  currentItem.replaceWith(nextItem);
+                }}
+              }}
+
+              const currentAtIndex = sessionList.children[index] || null;
+              if (itemToPlace !== currentAtIndex) {{
+                sessionList.insertBefore(itemToPlace, currentAtIndex);
+              }}
+            }});
+
+            existingItems.forEach((item) => item.remove());
+          }}
+
           async function refreshIndex() {{
             if (isPolling || document.hidden || !sessionList) {{
               return;
@@ -545,7 +674,7 @@ def build_index_page(session_previews: list[SessionPreview]) -> str:
                 return;
               }}
 
-              sessionList.innerHTML = itemsHtml;
+              syncSessionList(itemsHtml);
               lastMarkup = itemsHtml;
             }} catch (_error) {{
               return;
@@ -599,6 +728,7 @@ def build_index_page(session_previews: list[SessionPreview]) -> str:
 def build_session_page(summary: SessionSummary) -> str:
     title = html.escape(summary.title)
     detail_meta = build_session_detail_meta(summary)
+    stat_labels = build_summary_stat_labels(summary)
     body = f"""
     <main class="page detail-page">
       <div class="shell app-shell detail-shell">
@@ -635,12 +765,19 @@ def build_session_page(summary: SessionSummary) -> str:
             <div class="card-grid">
               {render_stat_card('Model Turns', summary.model_turns, value_id='session-model-turns-value')}
               {render_stat_card('Tool Calls', summary.tool_calls, value_id='session-tool-calls-value')}
-              {render_stat_card('Total Input Tokens', summary.total_input_tokens, value_id='session-total-input-value')}
+              {render_stat_card(stat_labels['totalInputLabel'], summary.total_input_tokens, value_id='session-total-input-value', label_id='session-total-input-label')}
               {render_stat_card('Total Output Tokens', summary.total_output_tokens, value_id='session-total-output-value')}
-              {render_stat_card('Total Cached Input Tokens', summary.total_cached_input_tokens, value_id='session-total-cached-input-value')}
+              {render_stat_card(stat_labels['totalCachedInputLabel'], summary.total_cached_input_tokens, value_id='session-total-cached-input-value', label_id='session-total-cached-input-label')}
+              {render_stat_card(stat_labels['totalCacheWriteLabel'], summary.total_cache_write_tokens, value_id='session-total-cache-write-value', label_id='session-total-cache-write-label')}
               {render_stat_card('Total Tokens', summary.total_tokens, value_id='session-total-tokens-value')}
+              {render_stat_card('Estimated AI Credits', format_ai_credits(summary.estimated_ai_credits), value_id='session-estimated-ai-credits-value')}
+              {render_stat_card('Estimated Cost (USD)', format_currency(summary.estimated_cost_usd), value_id='session-estimated-cost-usd-value')}
               {render_stat_card('Errors', summary.error_count, value_id='session-error-count-value')}
             </div>
+            <p class="billing-note" id="session-billing-note">{html.escape(summary.billing_note)}</p>
+            <div class="model-usage-panel" id="session-model-usage-breakdown">
+              {render_model_usage_breakdown(summary)}
+            </div>
           </div>
 
           <div class="explore-block">
@@ -667,6 +804,13 @@ def build_session_page(summary: SessionSummary) -> str:
             }}
           }}
 
+          function setHTML(id, value) {{
+            const node = document.getElementById(id);
+            if (node) {{
+              node.innerHTML = value;
+            }}
+          }}
+
           async function refreshSummary() {{
             if (isPolling || document.hidden) {{
               return;
@@ -688,13 +832,21 @@ def build_session_page(summary: SessionSummary) -> str:
               setText('session-status-value', summary.status || '');
               setText('session-created-value', summary.createdLabel || '');
               setText('session-updated-value', summary.updatedLabel || '');
+              setText('session-total-input-label', summary.totalInputLabel || 'Total Input Tokens');
+              setText('session-total-cached-input-label', summary.totalCachedInputLabel || 'Total Cached Input Tokens');
+              setText('session-total-cache-write-label', summary.totalCacheWriteLabel || 'Total Cache Write Tokens');
               setText('session-model-turns-value', summary.modelTurns || '0');
               setText('session-tool-calls-value', summary.toolCalls || '0');
               setText('session-total-input-value', summary.totalInputTokens || '0');
               setText('session-total-output-value', summary.totalOutputTokens || '0');
               setText('session-total-cached-input-value', summary.totalCachedInputTokens || '0');
+              setText('session-total-cache-write-value', summary.totalCacheWriteTokens || '0');
               setText('session-total-tokens-value', summary.totalTokens || '0');
+              setText('session-estimated-ai-credits-value', summary.estimatedAiCredits || '-');
+              setText('session-estimated-cost-usd-value', summary.estimatedCostUsd || '-');
               setText('session-error-count-value', summary.errorCount || '0');
+              setText('session-billing-note', summary.billingNote || '');
+              setHTML('session-model-usage-breakdown', summary.modelUsageBreakdownHtml || '');
             }} catch (_error) {{
               return;
             }} finally {{
@@ -2123,31 +2275,65 @@ def render_session_list_markup(session_previews: list[SessionPreview]) -> str:
     return "\n".join(render_session_item(session) for session in session_previews)
 
 
+def build_session_preview_meta(session: SessionPreview) -> str:
+    items: list[str] = []
+    if session.repository:
+        items.append(session.repository)
+    if session.branch:
+        items.append(session.branch)
+    if session.model_name:
+        items.append(session.model_name)
+
+    if session.updated_label:
+        items.append(f"Updated {session.updated_label}")
+
+    return "".join(f'<span class="session-meta-item">{html.escape(item)}</span>' for item in items)
+
+
 def render_session_item(session: SessionPreview) -> str:
     title = html.escape(session.title)
     badge = '<span class="badge">Active</span>' if session.is_active else ""
+    meta = build_session_preview_meta(session)
     return f"""
-          <li>
+          <li data-session-id="{html.escape(session.session_id, quote=True)}">
             <a class="session-link" href="/sessions/{session.session_id}" aria-label="Open {title}">
               <div class="session-main">
                 {chat_icon()}
-                <p class="session-title">{title}</p>
+                <div class="session-copy">
+                  <p class="session-title">{title}</p>
+                  <div class="session-meta">{meta}</div>
+                </div>
               </div>
               {badge}
             </a>
           </li>"""
 
 
-def render_stat_card(label: str, value: int, value_id: str | None = None) -> str:
-  return render_live_stat_card(label, value, value_id=value_id)
+def build_summary_stat_labels(summary: SessionSummary) -> dict[str, str]:
+    if summary.status == "Active":
+        return {
+            "totalInputLabel": "Input Tokens (Finalized)",
+            "totalCachedInputLabel": "Cached Input (Finalized)",
+            "totalCacheWriteLabel": "Cache Write (Finalized)",
+        }
+    return {
+        "totalInputLabel": "Total Input Tokens",
+        "totalCachedInputLabel": "Total Cached Input Tokens",
+        "totalCacheWriteLabel": "Total Cache Write Tokens",
+    }
+
+
+def render_stat_card(label: str, value: int | str, value_id: str | None = None, label_id: str | None = None) -> str:
+  return render_live_stat_card(label, value, value_id=value_id, label_id=label_id)
 
 
-def render_live_stat_card(label: str, value: int, value_id: str | None = None) -> str:
+def render_live_stat_card(label: str, value: int | str, value_id: str | None = None, label_id: str | None = None) -> str:
+    label_id_attr = f' id="{html.escape(label_id, quote=True)}"' if label_id else ''
     value_id_attr = f' id="{html.escape(value_id, quote=True)}"' if value_id else ''
     return f"""
               <article class="stat-card">
-                <span class="stat-label">{html.escape(label)}</span>
-                <span class="stat-value"{value_id_attr}>{format_number(value)}</span>
+                <span class="stat-label"{label_id_attr}>{html.escape(label)}</span>
+                <span class="stat-value"{value_id_attr}>{html.escape(format_stat_value(value))}</span>
               </article>"""
 
 
@@ -2195,6 +2381,7 @@ def render_empty_flow_state() -> str:
 
 
 def build_session_snapshot_payload(summary: SessionSummary) -> dict[str, str]:
+  stat_labels = build_summary_stat_labels(summary)
   return {
     "detailMeta": build_session_detail_meta(summary),
     "sessionType": summary.session_type,
@@ -2202,12 +2389,20 @@ def build_session_snapshot_payload(summary: SessionSummary) -> dict[str, str]:
     "status": summary.status,
     "createdLabel": summary.created_label,
     "updatedLabel": summary.updated_label,
+    "totalInputLabel": stat_labels["totalInputLabel"],
+    "totalCachedInputLabel": stat_labels["totalCachedInputLabel"],
+    "totalCacheWriteLabel": stat_labels["totalCacheWriteLabel"],
     "modelTurns": format_number(summary.model_turns),
     "toolCalls": format_number(summary.tool_calls),
     "totalInputTokens": format_number(summary.total_input_tokens),
     "totalOutputTokens": format_number(summary.total_output_tokens),
     "totalCachedInputTokens": format_number(summary.total_cached_input_tokens),
+    "totalCacheWriteTokens": format_number(summary.total_cache_write_tokens),
     "totalTokens": format_number(summary.total_tokens),
+    "estimatedAiCredits": format_ai_credits(summary.estimated_ai_credits),
+    "estimatedCostUsd": format_currency(summary.estimated_cost_usd),
+    "billingNote": summary.billing_note,
+    "modelUsageBreakdownHtml": render_model_usage_breakdown(summary),
     "errorCount": format_number(summary.error_count),
   }
 
@@ -2292,7 +2487,8 @@ def render_empty_log_list() -> str:
 
 
 def build_session_detail_meta(summary: SessionSummary) -> str:
-    return f"Model: {summary.model_name or 'Unknown'} · Repository: {summary.repository or '-'} · Branch: {summary.branch or '-'}"
+    label = "Models" if len(summary.model_usages) > 1 else "Model"
+    return f"{label}: {summary.models_used_label or 'Unknown'} · Repository: {summary.repository or '-'} · Branch: {summary.branch or '-'}"
 
 
 def chat_icon() -> str:
@@ -2303,3 +2499,58 @@ def chat_icon() -> str:
 
 def format_number(value: int) -> str:
     return f"{value:,}"
+
+
+def format_stat_value(value: int | str) -> str:
+    return format_number(value) if isinstance(value, int) else value
+
+
+def format_currency(value: Decimal | None) -> str:
+    if value is None:
+        return "-"
+    return f"${value.quantize(Decimal('0.000001')):,.6f}".rstrip("0").rstrip(".")
+
+
+def format_ai_credits(value: Decimal | None) -> str:
+    if value is None:
+        return "-"
+    return f"{value.quantize(Decimal('0.0001')):,.4f}".rstrip("0").rstrip(".")
+
+
+def render_model_usage_breakdown(summary: SessionSummary) -> str:
+    if not summary.model_usages:
+        return '<div class="model-usage-empty">No per-model usage metrics available yet.</div>'
+
+    rows = "\n".join(
+        f"""
+                  <tr>
+                    <td>{html.escape(item.model_name)}</td>
+                    <td>{format_number(item.input_tokens)}</td>
+                    <td>{format_number(item.cached_input_tokens)}</td>
+                    <td>{format_number(item.cache_write_tokens)}</td>
+                    <td>{format_number(item.output_tokens)}</td>
+                    <td>{format_number(item.total_tokens)}</td>
+                    <td>{html.escape(format_currency(item.estimated_cost_usd))}</td>
+                  </tr>"""
+        for item in summary.model_usages
+    )
+    return f"""
+              <div class="model-usage-title">Model Usage Breakdown</div>
+              <div class="model-usage-scroller">
+                <table class="model-usage-table">
+                  <thead>
+                    <tr>
+                      <th>Model</th>
+                      <th>Input</th>
+                      <th>Cached Input</th>
+                      <th>Cache Write</th>
+                      <th>Output</th>
+                      <th>Total</th>
+                      <th>Est. USD</th>
+                    </tr>
+                  </thead>
+                  <tbody>
+                    {rows}
+                  </tbody>
+                </table>
+              </div>"""

{copilot_cli_trace_deck-0.1.0 → copilot_cli_trace_deck-0.2.0}/src/copilot_cli_trace_deck.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: copilot-cli-trace-deck
-Version: 0.1.0
+Version: 0.2.0
 Summary: Render GitHub Copilot CLI agent debug logs into a clear, inspectable trace view.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -41,6 +41,8 @@ By default the server listens on `http://127.0.0.1:9887` and opens that URL in y
 
 Live updates are pushed over Server-Sent Events and triggered by file-system changes in the session-state directory, so the home, summary, logs, and flow pages update without browser polling.
 
+The summary view also estimates per-session GitHub AI Credits / USD cost from shutdown metrics, aggregating token usage across model switches within the same session.
+
 You can also pass the session-state source and server options:
 
 ```bash